dsh-theone 0.3.21 → 0.3.23

package/dist/feedback.d.ts

@@ -0,0 +1,113 @@
+import type { SessionEvent } from '@deepseek-ai/dsh-session';
+import type { RouteView } from './types.ts';
+/** Where reports go: a small Cloudflare Worker run by TheOne's maintainer (server/feedback). */
+export declare const FEEDBACK_URL = "https://feedback.yulid.org/v1/reports";
+export declare const FEEDBACK_EMAIL = "theone@yulid.org";
+export declare const FEEDBACK_LIMITS: {
+    readonly description: 4000;
+    readonly contact: 200;
+    readonly routes: 30;
+    readonly replyText: 8000;
+    readonly body: 60000;
+};
+/** Strings as they may leave this computer: secrets, emails, addresses and the home folder removed. */
+export declare function scrub(value: unknown, home?: string): unknown;
+/** Recent routes without their text or topics: what happened, how, how long, and any error code. */
+export declare function routeDigest(routes: readonly RouteView[], now?: number): {
+    corrected?: boolean | undefined;
+    error?: string | undefined;
+    ms?: number | undefined;
+    model?: string | undefined;
+    via?: "rules" | "llm" | undefined;
+    minutesAgo: number;
+    action: import("./types.ts").Action;
+    reason: string;
+    status: "planned" | "running" | "completed" | "failed";
+}[];
+/**
+ * One exchange in a session: the user message `messageId` (or, failing that, the latest user message
+ * with the same text) and every assistant text up to the next user message.
+ */
+export declare function exchange(events: readonly SessionEvent[], messageId: string, sameText?: string): {
+    user: string;
+    reply: string;
+    steps: number;
+} | undefined;
+/**
+ * Whether main chat showed what the topic's own session said, and signs of garbled text in either:
+ * replacement characters (U+FFFD), stray control characters, and long runs of one repeated character.
+ */
+export declare function compareReplies(main: string, worker: string): {
+    main: {
+        chars: number;
+        replacement: number;
+        control: number;
+        repeatedRuns: number;
+    };
+    worker: {
+        chars: number;
+        replacement: number;
+        control: number;
+        repeatedRuns: number;
+    };
+    firstDifference?: number | undefined;
+    identical: boolean;
+};
+/** The part of a report about one message: always the comparison, the texts only when the user agreed. */
+export declare function replySection(route: RouteView, main: ReturnType<typeof exchange>, worker: ReturnType<typeof exchange>, includeText: boolean, now?: number): {
+    topicSessionReply?: string | undefined;
+    mainChatReply?: string | undefined;
+    message?: string | undefined;
+    comparison?: {
+        main: {
+            chars: number;
+            replacement: number;
+            control: number;
+            repeatedRuns: number;
+        };
+        worker: {
+            chars: number;
+            replacement: number;
+            control: number;
+            repeatedRuns: number;
+        };
+        firstDifference?: number | undefined;
+        identical: boolean;
+    } | undefined;
+    topicSteps?: number | undefined;
+    mainSteps?: number | undefined;
+    route: {
+        corrected?: boolean | undefined;
+        error?: string | undefined;
+        ms?: number | undefined;
+        model?: string | undefined;
+        via?: "rules" | "llm" | undefined;
+        minutesAgo: number;
+        action: import("./types.ts").Action;
+        reason: string;
+        status: "planned" | "running" | "completed" | "failed";
+    };
+    found: {
+        mainChat: boolean;
+        topicSession: boolean;
+    };
+};
+export interface FeedbackDraft {
+    v: 1;
+    app: 'theone';
+    version: string;
+    diagnostics: Record<string, unknown>;
+    reply?: Record<string, unknown>;
+}
+export interface FeedbackReport extends FeedbackDraft {
+    lang: 'zh' | 'en';
+    description: string;
+    contact?: string;
+}
+/**
+ * The report to send: the draft the user saw plus what they typed. The draft comes back from the
+ * page, so it is checked and scrubbed again here; anything malformed is refused, not repaired.
+ */
+export declare function finalReport(input: Record<string, unknown>, version: string, home?: string): FeedbackReport;
+/** Send a report; resolves to its id, or throws RATE_LIMITED, REJECTED, UNREACHABLE or SERVER_ERROR. */
+export declare function sendReport(report: FeedbackReport, url?: string, fetcher?: typeof fetch): Promise<string>;

package/dist/feedback.js

@@ -0,0 +1,146 @@
+import { redactRoutingText } from "./routing-policy.js";
+/** Where reports go: a small Cloudflare Worker run by TheOne's maintainer (server/feedback). */
+export const FEEDBACK_URL = 'https://feedback.yulid.org/v1/reports';
+export const FEEDBACK_EMAIL = 'theone@yulid.org';
+export const FEEDBACK_LIMITS = { description: 4000, contact: 200, routes: 30, replyText: 8000, body: 60000 };
+const MINUTE = 60000;
+/** Strings as they may leave this computer: secrets, emails, addresses and the home folder removed. */
+export function scrub(value, home) {
+    if (typeof value === 'string') {
+        let text = redactRoutingText(value);
+        if (home && home.length > 1)
+            text = text.split(home).join('~');
+        return text;
+    }
+    if (Array.isArray(value))
+        return value.map(item => scrub(item, home));
+    if (value && typeof value === 'object')
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, scrub(item, home)]));
+    return value;
+}
+/** A decision's reason when it is one of TheOne's own codes; a model's free-text reason may quote the message. */
+function reasonCode(reason) {
+    return /^[a-z][\w:-]{0,59}$/i.test(reason) ? reason : 'model';
+}
+/** Recent routes without their text or topics: what happened, how, how long, and any error code. */
+export function routeDigest(routes, now = Date.now()) {
+    return routes.slice(0, FEEDBACK_LIMITS.routes).map(route => ({
+        minutesAgo: Math.max(0, Math.round((now - route.at) / MINUTE)),
+        action: route.decision.action,
+        reason: reasonCode(route.decision.reason),
+        status: route.status,
+        ...(route.receipt ? { via: route.receipt.mode, ...(route.receipt.model ? { model: route.receipt.model } : {}),
+            ...(route.receipt.elapsedMs !== undefined ? { ms: route.receipt.elapsedMs } : {}), ...(route.receipt.errorCode ? { error: route.receipt.errorCode } : {}) } : {}),
+        ...(route.correctedTo ? { corrected: route.correctedTo !== route.decision.contextId } : {}),
+    }));
+}
+const blockText = (blocks) => blocks.flatMap(block => block.type === 'text' && block.text ? [block.text] : []).join('');
+/**
+ * One exchange in a session: the user message `messageId` (or, failing that, the latest user message
+ * with the same text) and every assistant text up to the next user message.
+ */
+export function exchange(events, messageId, sameText) {
+    let start = events.findIndex(event => event.type === 'user/message' && event.data.id === messageId);
+    if (start < 0 && sameText !== undefined) {
+        for (let index = events.length - 1; index >= 0; index--) {
+            const event = events[index];
+            if (event.type === 'user/message' && event.data.source.kind === 'user' && blockText(event.data.content).trim() === sameText.trim()) {
+                start = index;
+                break;
+            }
+        }
+    }
+    if (start < 0)
+        return undefined;
+    const first = events[start];
+    if (first.type !== 'user/message')
+        return undefined;
+    const replies = [];
+    for (const event of events.slice(start + 1)) {
+        if (event.type === 'user/message' && event.data.source.kind === 'user')
+            break;
+        if (event.type === 'assistant/message')
+            replies.push(blockText(event.data.message.content));
+    }
+    return { user: blockText(first.data.content), reply: replies.join(''), steps: replies.length };
+}
+const count = (text, pattern) => (text.match(pattern) ?? []).length;
+/**
+ * Whether main chat showed what the topic's own session said, and signs of garbled text in either:
+ * replacement characters (U+FFFD), stray control characters, and long runs of one repeated character.
+ */
+export function compareReplies(main, worker) {
+    let first = 0;
+    while (first < main.length && first < worker.length && main[first] === worker[first])
+        first++;
+    const identical = main === worker;
+    const signs = (text) => ({ chars: text.length, replacement: count(text, /�/g),
+        control: count(text, /[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g), repeatedRuns: count(text, /(.)\1{19,}/gsu) });
+    return { identical, ...(identical ? {} : { firstDifference: first }), main: signs(main), worker: signs(worker) };
+}
+/** Text around the first difference, so a long reply still shows where the two part ways. */
+function excerpt(text, around) {
+    if (text.length <= FEEDBACK_LIMITS.replyText)
+        return text;
+    const start = around === undefined ? 0 : Math.max(0, Math.min(text.length - FEEDBACK_LIMITS.replyText, around - FEEDBACK_LIMITS.replyText / 2));
+    return (start ? '…' : '') + text.slice(start, start + FEEDBACK_LIMITS.replyText) + (start + FEEDBACK_LIMITS.replyText < text.length ? '…' : '');
+}
+/** The part of a report about one message: always the comparison, the texts only when the user agreed. */
+export function replySection(route, main, worker, includeText, now = Date.now()) {
+    const comparison = main && worker ? compareReplies(main.reply, worker.reply) : undefined;
+    return {
+        route: routeDigest([route], now)[0],
+        found: { mainChat: !!main, topicSession: !!worker },
+        ...(main ? { mainSteps: main.steps } : {}), ...(worker ? { topicSteps: worker.steps } : {}),
+        ...(comparison ? { comparison } : {}),
+        ...(includeText ? {
+            message: (main ?? worker)?.user.slice(0, 2000),
+            ...(main ? { mainChatReply: excerpt(main.reply, comparison?.firstDifference) } : {}),
+            ...(worker ? { topicSessionReply: excerpt(worker.reply, comparison?.firstDifference) } : {}),
+        } : {}),
+    };
+}
+/**
+ * The report to send: the draft the user saw plus what they typed. The draft comes back from the
+ * page, so it is checked and scrubbed again here; anything malformed is refused, not repaired.
+ */
+export function finalReport(input, version, home) {
+    const draft = input.draft;
+    const description = typeof input.description === 'string' ? input.description.trim() : '';
+    const contact = typeof input.contact === 'string' ? input.contact.trim() : '';
+    if (!draft || typeof draft !== 'object' || draft.v !== 1 || draft.app !== 'theone')
+        throw new Error('INVALID_INPUT');
+    if (!draft.diagnostics || typeof draft.diagnostics !== 'object' || Array.isArray(draft.diagnostics))
+        throw new Error('INVALID_INPUT');
+    if (draft.reply != null && (typeof draft.reply !== 'object' || Array.isArray(draft.reply)))
+        throw new Error('INVALID_INPUT');
+    if (!description)
+        throw new Error('DESCRIPTION_REQUIRED');
+    if (description.length > FEEDBACK_LIMITS.description || contact.length > FEEDBACK_LIMITS.contact)
+        throw new Error('TOO_LARGE');
+    const report = { v: 1, app: 'theone', version, lang: input.lang === 'zh' ? 'zh' : 'en', description,
+        ...(contact ? { contact } : {}),
+        diagnostics: scrub(draft.diagnostics, home),
+        ...(draft.reply ? { reply: scrub(draft.reply, home) } : {}) };
+    if (JSON.stringify(report).length > FEEDBACK_LIMITS.body)
+        throw new Error('TOO_LARGE');
+    return report;
+}
+/** Send a report; resolves to its id, or throws RATE_LIMITED, REJECTED, UNREACHABLE or SERVER_ERROR. */
+export async function sendReport(report, url = FEEDBACK_URL, fetcher = fetch) {
+    let response;
+    try {
+        response = await fetcher(url, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(report), signal: AbortSignal.timeout(15000) });
+    }
+    catch {
+        throw new Error('UNREACHABLE');
+    }
+    if (response.status === 429)
+        throw new Error('RATE_LIMITED');
+    if (response.status >= 400 && response.status < 500)
+        throw new Error('REJECTED');
+    const body = await response.json().catch(() => undefined);
+    if (!response.ok || typeof body?.id !== 'string' || !/^FB-[A-Z0-9]{4,12}$/.test(body.id))
+        throw new Error('SERVER_ERROR');
+    return body.id;
+}

package/dist/index.d.ts

@@ -11,6 +11,7 @@ import { type SettingsSnapshot } from './settings-types.ts';
 import { type LinkScope } from './linkage.ts';
 import { Updater } from './update.ts';
 import { NoticeBoard } from './notices.ts';
+import { type FeedbackDraft } from './feedback.ts';
 export interface Config {
     databasePath?: string;
     contextsPath?: string;
@@ -39,6 +40,8 @@ export interface Config {
     topicCards?: boolean;
     /** Where notices are read from; for testing. */
     noticeUrl?: string;
+    /** Where problem reports are sent when the user presses Send; "off" leaves only copy and email. For testing. */
+    feedbackUrl?: string;
 }
 declare module '@deepseek-ai/cordis' {
     interface Context {
@@ -105,11 +108,27 @@ export default class TheOne extends Service {
     private editTopics;
     /** Existing DSH sessions a topic can take as history: not main chats and not topics' own Workers. */
     private attachableSessions;
+    /**
+     * What a problem report carries before the user adds their words: versions, settings and how
+     * routing went, without message text or topic names. With `messageId`, also how that message's
+     * reply in main chat compares with its topic session, and the texts themselves if `includeReply`.
+     */
+    feedbackDraft(messageId: string | undefined, includeReply: boolean): Promise<FeedbackDraft>;
     /** Read only public options; never read or return the API key environment value. */
     settingsSnapshot(): Promise<SettingsSnapshot>;
     private routerFor;
     /** Saved settings take effect for the next message; only the background catalog waits for a restart. */
     private applySettings;
+    /**
+     * DSH saves any session's model choice as its global default, so main chat choosing TheOne used
+     * to make every new ordinary chat a TheOne chat. TheOne must not change the user's settings:
+     * before main chat picks its model the default is held, and put back right after.
+     */
+    private heldDefault?;
+    holdDefaultModel(): void;
+    restoreDefaultModel(): Promise<void>;
+    /** Once: undo the default earlier versions left as TheOne, back to the model in use before it. */
+    private repairDefaultModel;
     /** Capture before Web saves the gateway itself as DSH's new default. */
     captureDefaultModel(): void;
     private backingModel;

package/dist/index.js

@@ -25,6 +25,8 @@ import { applyExtraction, EXTRACT_PROMPT, extractionPayload, factCandidates, fac
 import { activityLabel, CARD_AFTER_REPLIES, CARD_PROMPT, cardPayload, learnDormancy, parseCard } from "./topic-memory.js";
 import { PACKAGE_NAME, Updater } from "./update.js";
 import { NOTICE_URL, NoticeBoard } from "./notices.js";
+import { exchange, FEEDBACK_EMAIL, FEEDBACK_LIMITS, FEEDBACK_URL, finalReport, replySection, routeDigest, scrub, sendReport } from "./feedback.js";
+import { createRequire } from 'node:module';
 function redactDescriptor(text) {
     return text.replace(/\bsk-[a-zA-Z0-9_-]{16,}|\bBearer\s+\S+/gi, '[REDACTED]')
         .replace(/((?:api[_ -]?key|password|密码|密钥)\s*[:=：]\s*)\S+/gi, '$1[REDACTED]');
@@ -139,6 +141,15 @@ function readOwnVersion() {
         return '0.0.0';
     }
 }
+/** DSH's own version, as far as its packages say; undefined when it cannot be read. */
+function readDshVersion() {
+    try {
+        return String(createRequire(import.meta.url)('@deepseek-ai/dsh-agent/package.json').version ?? '') || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 function readDescriptors(path) {
     const value = JSON.parse(readFileSync(path, 'utf8'));
     if (!Array.isArray(value))
@@ -176,6 +187,7 @@ export default class TheOne extends Service {
         factExtraction: z.boolean().default(false),
         topicCards: z.boolean().default(true),
         noticeUrl: z.string(),
+        feedbackUrl: z.string(),
     });
     store;
     catalog;
@@ -254,6 +266,7 @@ export default class TheOne extends Service {
         if (!!config.workerProvider !== !!config.workerModel)
             throw new Error('Set both workerProvider and workerModel, or neither');
         this.captureDefaultModel();
+        this.repairDefaultModel();
         this.router = this.routerFor(config.routerMode);
         if (config.historyCatalog ?? true) {
             this.catalog = new HistoryCatalog(ctx, this.store, () => this.backingModel(), config.catalogIntervalMs);
@@ -581,6 +594,11 @@ export default class TheOne extends Service {
                         await mkdir(this.gatewayDirectory, { recursive: true });
                         return Response.json({ cwd: this.gatewayDirectory }, { headers: { 'cache-control': 'no-store' } });
                     } }));
+                // Main chat is about to pick its model; DSH would save that as the user's default.
+                scope.effect(() => connection.fetch.register({ path: '/api/theone/gateway/hold', methods: ['POST'], requestBody: 'buffered', fetch: async () => {
+                        this.holdDefaultModel();
+                        return Response.json({ held: true });
+                    } }));
                 scope.effect(() => connection.fetch.register({ path: '/api/theone/gateway/prepare', methods: ['POST'], requestBody: 'buffered', fetch: async (request) => {
                         let value;
                         try {
@@ -611,6 +629,7 @@ export default class TheOne extends Service {
                         await scope.workspaceRegistry.unarchiveSession(id);
                         const locale = 'locale' in value && typeof value.locale === 'string' ? value.locale.slice(0, 16) : 'en';
                         this.welcomeGateway(id, locale);
+                        await this.restoreDefaultModel().catch(error => console.warn('TheOne could not restore DSH\'s default model.', error));
                         return Response.json({ prepared: true, workspaceId: null });
                     } }));
             });
@@ -697,6 +716,34 @@ export default class TheOne extends Service {
                     const dismissed = this.store.dismissedNotices();
                     return Response.json({ notices: (await this.noticeBoard.notices()).filter(notice => !dismissed.has(notice.id)) }, { headers: { 'cache-control': 'no-store' } });
                 } }));
+            // Problem reports: a draft to show the user in full, then sent only when they press Send.
+            child.effect(() => connection.fetch.register({ path: '/api/theone/feedback', methods: ['POST'], requestBody: 'buffered', fetch: async (request) => {
+                    let row;
+                    try {
+                        row = await request.json();
+                    }
+                    catch {
+                        return Response.json({ error: 'INVALID_INPUT' }, { status: 400 });
+                    }
+                    const url = this.config.feedbackUrl || FEEDBACK_URL;
+                    try {
+                        if (row?.action === 'draft') {
+                            const messageId = typeof row.messageId === 'string' ? row.messageId : undefined;
+                            return Response.json({ draft: await this.feedbackDraft(messageId, row.includeReply === true), email: FEEDBACK_EMAIL, direct: url !== 'off' }, { headers: { 'cache-control': 'no-store' } });
+                        }
+                        if (row?.action === 'send') {
+                            if (url === 'off')
+                                return Response.json({ error: 'DIRECT_OFF' }, { status: 400 });
+                            const report = finalReport(row, this.updater.current, homedir());
+                            return Response.json({ id: await sendReport(report, url) }, { headers: { 'cache-control': 'no-store' } });
+                        }
+                        return Response.json({ error: 'INVALID_INPUT' }, { status: 400 });
+                    }
+                    catch (error) {
+                        const code = error instanceof Error && /^[A-Z_]+$/.test(error.message) ? error.message : 'FEEDBACK_FAILED';
+                        return Response.json({ error: code }, { status: ['UNREACHABLE', 'SERVER_ERROR', 'RATE_LIMITED', 'REJECTED'].includes(code) ? 502 : 400 });
+                    }
+                } }));
             child.effect(() => connection.fetch.register({ path: '/api/theone/sessions', methods: ['GET'], requestBody: 'buffered', fetch: async () => Response.json({ sessions: await this.attachableSessions() }, { headers: { 'cache-control': 'no-store' } }) }));
             // The user's corrections to topic linking always take precedence over what was learned.
             child.effect(() => connection.fetch.register({ path: '/api/theone/links', methods: ['POST'], requestBody: 'buffered', fetch: async (request) => {
@@ -736,6 +783,9 @@ export default class TheOne extends Service {
                     }
                     if (!value || typeof value !== 'object' || !('contextId' in value) || typeof value.contextId !== 'string' || !this.store.contexts().some(c => c.id === value.contextId))
                         return Response.json({ error: 'UNKNOWN_CONTEXT' }, { status: 400 });
+                    // Its conversations are gone or archived: mounting it would only start an empty Worker.
+                    if (this.store.hiddenReasons().has(value.contextId))
+                        return Response.json({ error: 'TOPIC_HIDDEN' }, { status: 409 });
                     if (this.active || this.reservedGateway)
                         return Response.json({ error: 'GATEWAY_BUSY' }, { status: 409 });
                     this.store.mount(this.config.gatewayKey, value.contextId);
@@ -830,6 +880,52 @@ export default class TheOne extends Service {
             return { id: record.header.id, title: title || new Date(record.header.createdAt).toISOString().slice(0, 16).replace('T', ' '), createdAt: record.header.createdAt };
         });
     }
+    /**
+     * What a problem report carries before the user adds their words: versions, settings and how
+     * routing went, without message text or topic names. With `messageId`, also how that message's
+     * reply in main chat compares with its topic session, and the texts themselves if `includeReply`.
+     */
+    async feedbackDraft(messageId, includeReply) {
+        const c = this.config;
+        const settings = await this.settingsSnapshot().catch(() => undefined);
+        const values = settings?.values;
+        const status = this.catalog?.snapshot().status;
+        const update = await this.updater.status().catch(() => undefined);
+        const routes = this.store.recentRoutes(c.gatewayKey, FEEDBACK_LIMITS.routes);
+        const diagnostics = {
+            theone: this.updater.current, dsh: readDshVersion() ?? null, node: process.version, platform: `${process.platform}-${process.arch}`,
+            model: settings?.model ? { provider: settings.model.provider, model: settings.model.model } : null,
+            ...(settings?.modelUnavailable ? { modelUnavailable: true } : {}),
+            settings: values ? { routerMode: values.routerMode, linkScope: values.linkScope, routeNotice: values.routeNotice, notices: values.notices,
+                historyCatalog: values.historyCatalog, factLinks: values.factLinks, factExtraction: values.factExtraction, topicCards: c.topicCards !== false,
+                maxResponseChars: values.maxResponseChars, maxDescriptorChars: values.maxDescriptorChars,
+                pinnedModel: !!(values.workerProvider && values.workerModel), manualCatalog: !!values.contextsPath } : null,
+            topics: { total: this.store.contexts().length, hidden: this.store.hiddenReasons().size, workspaces: this.store.groups().length },
+            catalog: status ? { running: status.running, scanned: status.scanned, indexed: status.indexed, skipped: status.skipped, failed: status.failed,
+                pending: status.pending, ...(status.searchUnavailable ? { searchUnavailable: true } : {}) } : { off: true },
+            routing: { stats: this.store.routeStats(c.gatewayKey), recent: routeDigest(routes) },
+            update: update ? { source: update.source, ...(update.latest ? { latest: update.latest } : {}), ...(update.state ? { state: update.state } : {}),
+                ...(update.error ? { error: update.error } : {}) } : null,
+            busy: this.active,
+        };
+        let reply;
+        if (messageId) {
+            const route = routes.find(item => item.messageId === messageId);
+            const stored = this.store.route(messageId);
+            if (!route || !stored || !this.store.isGateway(stored.gatewayId))
+                throw new Error('UNKNOWN_MESSAGE');
+            const read = (id) => this.ctx.sessionQuery.readSession(SessionId(id)).then(log => log.events, () => undefined);
+            const mainEvents = await read(stored.gatewayId);
+            const main = mainEvents && exchange(mainEvents, messageId);
+            const sessionId = this.store.contexts().find(context => context.id === route.decision.contextId)?.workingSessionId;
+            const workerEvents = sessionId ? await read(sessionId) : undefined;
+            const worker = workerEvents && exchange(workerEvents, messageId, main?.user);
+            reply = replySection(route, main, worker, includeReply);
+        }
+        // Scrubbed here too, so what the user reads is exactly what is sent.
+        return { v: 1, app: 'theone', version: this.updater.current, diagnostics: scrub(diagnostics, homedir()),
+            ...(reply ? { reply: scrub(reply, homedir()) } : {}) };
+    }
     /** Read only public options; never read or return the API key environment value. */
     async settingsSnapshot() {
         const c = this.config;
@@ -888,6 +984,34 @@ export default class TheOne extends Service {
             catch { /* Released during shutdown. */ }
         this.store.seed(descriptors);
     }
+    /**
+     * DSH saves any session's model choice as its global default, so main chat choosing TheOne used
+     * to make every new ordinary chat a TheOne chat. TheOne must not change the user's settings:
+     * before main chat picks its model the default is held, and put back right after.
+     */
+    heldDefault;
+    holdDefaultModel() {
+        const current = this.ctx.agentDefaultModel.currentSelection();
+        // A default the user set to TheOne themselves stays as it is.
+        this.heldDefault = current.provider && current.provider !== 'theone' ? current : undefined;
+    }
+    async restoreDefaultModel() {
+        const held = this.heldDefault;
+        this.heldDefault = undefined;
+        // Saves run in order, so this lands after the one DSH queued for main chat's selection.
+        if (held)
+            await this.ctx.agentDefaultModel.saveSelection?.(held);
+    }
+    /** Once: undo the default earlier versions left as TheOne, back to the model in use before it. */
+    repairDefaultModel() {
+        const current = this.ctx.agentDefaultModel.currentSelection();
+        if (current.provider !== 'theone')
+            return;
+        const before = this.store.rememberedModel(this.config.gatewayKey);
+        if (!before || !this.store.markOnce('default-model-restored'))
+            return;
+        void this.ctx.agentDefaultModel.saveSelection?.(before)?.catch(error => console.warn('TheOne could not restore DSH\'s default model.', error));
+    }
     /** Capture before Web saves the gateway itself as DSH's new default. */
     captureDefaultModel() {
         const current = this.ctx.agentDefaultModel.currentSelection();

package/dist/store.d.ts

@@ -250,6 +250,8 @@ export declare class ContextStore {
     private purgeFacts;
     /** Notices the user closed; they are not shown again on any browser. */
     dismissNotice(id: string, now?: number): void;
+    /** True the first time `name` is marked, false ever after: for one-time repairs. */
+    markOnce(name: string, now?: number): boolean;
     dismissedNotices(): Set<string>;
     /**
      * Topics kept in the directory but hidden from routing and briefings: every conversation they can

package/dist/store.js

@@ -95,6 +95,7 @@ export class ContextStore {
         context_id TEXT NOT NULL, term TEXT NOT NULL, weight REAL NOT NULL, updated_at INTEGER NOT NULL, PRIMARY KEY(context_id, term)
       );
       CREATE TABLE IF NOT EXISTS dismissed_notices (id TEXT PRIMARY KEY, dismissed_at INTEGER NOT NULL);
+      CREATE TABLE IF NOT EXISTS plugin_flags (name TEXT PRIMARY KEY, set_at INTEGER NOT NULL);
       CREATE TABLE IF NOT EXISTS route_details (
         message_id TEXT PRIMARY KEY, excerpt TEXT NOT NULL, receipt TEXT, corrected_to TEXT, corrected_at INTEGER
       );
@@ -932,6 +933,10 @@ export class ContextStore {
     dismissNotice(id, now = Date.now()) {
         this.db.prepare('INSERT OR IGNORE INTO dismissed_notices VALUES (?, ?)').run(id, now);
     }
+    /** True the first time `name` is marked, false ever after: for one-time repairs. */
+    markOnce(name, now = Date.now()) {
+        return this.db.prepare('INSERT OR IGNORE INTO plugin_flags VALUES (?, ?)').run(name, now).changes === 1;
+    }
     dismissedNotices() {
         return new Set(this.db.prepare('SELECT id FROM dismissed_notices').all().map(row => String(row.id)));
     }

package/package.json

@@ -1,9 +1,22 @@
 {
   "name": "dsh-theone",
-  "version": "0.3.21",
+  "version": "0.3.23",
   "private": false,
   "type": "module",
-  "description": "Automatic context routing for DeepSeek Harness",
+  "description": "One chat for everything in DeepSeek Harness (DSH): no more hunting for old conversations. Each message goes to the topic it belongs to, with its own context.",
+  "keywords": [
+    "deepseek-harness",
+    "dsh",
+    "dsh-plugin",
+    "deepseek",
+    "ai-chat",
+    "chat-organizer",
+    "conversation-management",
+    "chat-history",
+    "context-management",
+    "conversation-routing",
+    "productivity"
+  ],
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
@@ -57,7 +70,8 @@
     "pack:plugin": "npm run build && node scripts/pack-plugin.mjs",
     "install:local": "npm run build && node scripts/install-local.mjs",
     "start:local": "node scripts/start-local.mjs",
-    "eval:test": "node --test eval/test/*.test.mjs && python3 -m unittest discover -s eval/test"
+    "eval:test": "node --test eval/test/*.test.mjs && python3 -m unittest discover -s eval/test",
+    "feedback:test": "node --test server/feedback/test/*.test.mjs"
   },
   "dependencies": {
     "@deepseek-ai/schemastery": "3.18.4"
@@ -106,5 +120,9 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/YunongDai2005/dsh-theone.git"
+  },
+  "bugs": {
+    "url": "https://github.com/YunongDai2005/dsh-theone/issues",
+    "email": "theone@yulid.org"
   }
 }