dsh-theone 0.3.20 → 0.3.22

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/history-catalog.d.ts

@@ -34,6 +34,15 @@ export declare class HistoryCatalog {
     get incomplete(): boolean;
     refresh(): Promise<void>;
     private scan;
+    /** DSH's archive set, when a workspace registry is present. Empty means nothing is archived. */
+    private archivedSessionIds;
+    /**
+     * The scan only walks the conversations that still exist, so a topic whose sessions were deleted
+     * or archived would otherwise stay in the routing candidates forever. Hiding is recomputed whole
+     * on every scan, which keeps it reversible: restoring or unarchiving a conversation brings its
+     * topic back, and no topic is removed from the directory behind the reader's back.
+     */
+    private reconcile;
     /**
      * Up to 16 topics worth showing the classifier. `contexts` may carry learned terms; `prior`
      * favours topics used recently, often, or together with the current one.

package/dist/history-catalog.js

@@ -108,8 +108,10 @@ export class HistoryCatalog {
         this.schedule(1000); }
     async close() { this.abort.abort(); clearTimeout(this.timer); await this.run?.catch(() => { }); }
     snapshot() {
+        const hidden = this.store.hiddenReasons();
         return { status: { ...this.status }, groups: this.store.groups(),
-            contexts: this.store.contexts().map(context => ({ ...context, sourceSessionIds: this.store.sources(context.id) })) };
+            contexts: this.store.contexts().map(context => ({ ...context, sourceSessionIds: this.store.sources(context.id),
+                ...(hidden.has(context.id) ? { hidden: hidden.get(context.id) } : {}) })) };
     }
     get incomplete() { return !this.status.lastCompletedAt || (this.settledPending ?? 1) > 0 || !!this.status.searchUnavailable; }
     refresh() {
@@ -137,6 +139,7 @@ export class HistoryCatalog {
             return;
         }
         this.status.pending = records.length;
+        const archived = this.archivedSessionIds();
         let budget = this.batchBudget;
         for (const record of records) {
             signal.throwIfAborted();
@@ -146,6 +149,12 @@ export class HistoryCatalog {
                 this.status.pending--;
                 continue;
             }
+            // An archived conversation still sits on disk, but its topic must not be pulled back in.
+            if (archived.has(sessionId)) {
+                this.status.skipped++;
+                this.status.pending--;
+                continue;
+            }
             const live = this.ctx.agents.get(sessionId);
             if (live && live.status !== 'idle') {
                 // Its turn in progress is indexed once it settles; what was already indexed stays usable meanwhile.
@@ -227,15 +236,52 @@ export class HistoryCatalog {
             }
         }
         this.settledPending = this.status.pending;
+        this.reconcile(records, archived);
         this.status.lastCompletedAt = Date.now();
     }
+    /** DSH's archive set, when a workspace registry is present. Empty means nothing is archived. */
+    archivedSessionIds() {
+        try {
+            const registry = this.ctx.get('workspaceRegistry');
+            const ids = registry?.archivedSessionIds;
+            return new Set(Array.isArray(ids) ? ids.filter((id) => typeof id === 'string') : []);
+        }
+        catch {
+            // A registry that is not ready yet must never fail a scan.
+            return new Set();
+        }
+    }
+    /**
+     * The scan only walks the conversations that still exist, so a topic whose sessions were deleted
+     * or archived would otherwise stay in the routing candidates forever. Hiding is recomputed whole
+     * on every scan, which keeps it reversible: restoring or unarchiving a conversation brings its
+     * topic back, and no topic is removed from the directory behind the reader's back.
+     */
+    reconcile(records, archived) {
+        const live = new Set(records.map(record => record.header.id));
+        const hidden = [];
+        for (const context of this.store.contexts()) {
+            const conversations = [context.workingSessionId, ...this.store.sources(context.id)];
+            // Only conversations the catalog has actually seen count: a Worker session exists on disk only
+            // once TheOne has run it, so an untouched placeholder must not look like a lost conversation.
+            const known = conversations.filter(sessionId => this.store.indexState(sessionId) !== undefined);
+            if (known.length && known.every(sessionId => archived.has(sessionId)))
+                hidden.push({ id: context.id, reason: 'archived' });
+            // Nothing left to read: every conversation is off disk, and at least one of them was indexed.
+            else if (known.length && !conversations.some(sessionId => live.has(sessionId)))
+                hidden.push({ id: context.id, reason: 'orphaned' });
+        }
+        this.store.replaceHidden(hidden);
+        this.status.hidden = hidden.length;
+    }
     /**
      * Up to 16 topics worth showing the classifier. `contexts` may carry learned terms; `prior`
      * favours topics used recently, often, or together with the current one.
      */
     async candidates(text, currentId, signal, hints = {}) {
         this.status.searchUnavailable = false;
-        const all = hints.contexts ?? this.store.contexts();
+        const hidden = this.store.hiddenReasons();
+        const all = (hints.contexts ?? this.store.contexts()).filter(context => !hidden.has(context.id));
         if (all.length <= 16)
             return all;
         const normalized = text.toLowerCase();

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;
@@ -31,8 +32,16 @@ export interface Config {
     routeNotice?: 'hidden' | 'switch' | 'all';
     /** Show notices the maintainer publishes (read from a static file; nothing is sent). */
     notices?: boolean;
+    /** Experimental: topics share confirmed facts (a figure, a decision) with evidence and versions. */
+    factLinks?: boolean;
+    /** With factLinks: after each turn, a small model call proposes facts the Worker did not record. */
+    factExtraction?: boolean;
+    /** A routing card per topic, written in the background after its first replies; on unless turned off (tests). */
+    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 {
@@ -99,6 +108,12 @@ 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;
@@ -148,6 +163,12 @@ export default class TheOne extends Service {
      * Cross-topic reference for a Worker about to start: the recent main chat after a topic switch,
      * and the news of related topics (plus those the request itself named). Undefined when empty.
      */
+    /** Confirmed facts this message might use (see fact-flow). */
+    private factCandidates;
+    /** What a topic is told about facts before its Worker answers (see fact-flow). */
+    private factDelivery;
+    /** The topic's own recorded facts for its Worker's descriptor; empty unless shared facts are on. */
+    private ownFacts;
     private briefingFor;
     /**
      * No one views a Worker session, so its approval questions would fail closed. Ask in the
@@ -165,6 +186,8 @@ export default class TheOne extends Service {
     private forwardQuestions;
     /** Capability is scoped to the exact owned Worker; the model cannot select another Context. */
     private registerWorkerTools;
+    /** Recording facts with evidence, and looking up other topics' confirmed facts (shared facts only). */
+    private registerFactTools;
     /** Mirror the routed Worker's steps into the main chat; tools execute exclusively in the Worker. */
     answer(options: GenerateOptions): AsyncIterable<StreamChunk>;
     /** The message answered just before `inputId` in this main chat, with the topic it went to. */
@@ -173,6 +196,16 @@ export default class TheOne extends Service {
     private reroute;
     /** Learning from corrections in flight; tests and shutdown can wait for it. */
     learning: Promise<void>;
+    /** Fact extractions in flight, one queue per topic so they commit in turn order. */
+    private readonly extractions;
+    /** All extractions in flight; tests and shutdown can wait for it. */
+    get extracting(): Promise<void>;
+    /** Queue an extraction of the turn that just ended in `worker`'s topic. */
+    private queueExtraction;
+    /** Queue a routing card for this topic, after any extraction already queued for it. */
+    private queueCard;
+    private writeCard;
+    private extractFacts;
     /**
      * The user moved a message to another topic: remember it, and teach both topics. The right topic
      * gains the message's distinctive terms and the wrong one loses them; `weight` is lower for
@@ -181,7 +214,10 @@ export default class TheOne extends Service {
     private applyCorrection;
     /** Ask the selected model, thinking off, for the few terms that tie a message to its topic. */
     private pickTerms;
-    /** Topics with the terms corrections taught them added to their own keywords. */
+    /**
+     * Topics as routing sees them: with the terms corrections taught them, and when each was last
+     * active. Topics set aside (untouched for longer than this user usually comes back) go last.
+     */
     private routingContexts;
     /**
      * Favour topics used recently or often, and those linked to the current one, when narrowing