dsh-theone 0.3.20 → 0.3.21

package/dist/facts.d.ts

@@ -0,0 +1,127 @@
+import type { SessionEvent } from '@deepseek-ai/dsh-session';
+export type FactKind = 'fact' | 'decision' | 'artifact';
+export type FactStatus = 'confirmed' | 'proposed' | 'retracted';
+export type Speaker = 'user' | 'assistant' | 'tool';
+export declare const FACT_KINDS: readonly FactKind[];
+/** Where a version came from. `seq` is null when the quoted words were not found in the session. */
+export interface FactEvidence {
+    sessionId: string;
+    seq: number | null;
+    speaker: Speaker | 'unverified';
+    quote: string;
+    /** For a confirmation such as "ok, go with that": the assistant's proposal it accepted. */
+    accepts?: {
+        seq: number;
+        quote: string;
+    };
+}
+/** A fact as it stands now: its identity and its current version. */
+export interface FactView {
+    id: string;
+    contextId: string;
+    key: string;
+    label: string;
+    aliases: string[];
+    kind: FactKind;
+    version: number;
+    status: FactStatus;
+    value: string | null;
+    evidence: FactEvidence;
+    origin: 'worker' | 'extractor';
+    createdAt: number;
+    deletedAt?: number;
+    mergedFrom?: string;
+}
+/** Every size limit of the feature in one place; each is a hard cap on characters or items. */
+export declare const FACT_LIMITS: {
+    readonly label: 60;
+    readonly value: 300;
+    readonly quote: 200;
+    readonly aliases: 6;
+    readonly alias: 60;
+    readonly recordItems: 8;
+    readonly routerBudget: 1200;
+    readonly routerLabel: 40;
+    readonly routerValue: 80;
+    readonly routerItems: 12;
+    readonly imports: 5;
+    readonly briefingBudget: 1200;
+    readonly noticeBudget: 600;
+    readonly ownBudget: 1500;
+    readonly ownItems: 20;
+    readonly lookupItems: 10;
+    readonly extractionBudget: 6000;
+    readonly extractionFacts: 1500;
+};
+/** Text that may be stored or shown: credentials and personal addresses removed, then shortened. */
+export declare const safe: (text: string, max: number) => string;
+/**
+ * The name two writes must share to be the same fact. Case, width and spacing are folded, and only
+ * wrapping quotes and punctuation are dropped, so `C++`, `C#` and `.NET` stay distinct.
+ */
+export declare function factKey(label: string): string;
+/** Folded text for finding a quote inside a message: width, case, spacing and thousands separators. */
+export declare function matchText(text: string): string;
+/** Literal evidence, with complete numeric tokens and units; similarity is for ranking, not proof. */
+export declare function states(source: string, value: string): boolean;
+/** "ok, go with that": an explicit acceptance, without a refusal and not itself a question. */
+export declare function accepts(text: string): boolean;
+/** A retraction needs words withdrawing or reopening a value, not merely any user quote. */
+export declare function retracts(text: string): boolean;
+export interface EvidenceEvent {
+    seq: number;
+    speaker: Speaker;
+    text: string;
+    toolResult?: boolean;
+    isError?: boolean;
+}
+/**
+ * The messages of a topic session that can serve as evidence, newest last: the user's own messages,
+ * the assistant's answers and tool activity. TheOne's reference material for the session (its
+ * descriptor, cross-topic briefings) is not the user speaking and never counts.
+ */
+export declare function evidenceEvents(events: readonly SessionEvent[], limit?: number): EvidenceEvent[];
+/** The newest event containing `quote` (folded), optionally only from one speaker or before a point. */
+export declare function findQuote(events: readonly EvidenceEvent[], quote: string, options?: {
+    speaker?: Speaker;
+    before?: number;
+}): EvidenceEvent | undefined;
+export interface Verdict {
+    status: 'confirmed' | 'proposed';
+    evidence: FactEvidence;
+    reason?: string;
+}
+/**
+ * Decide from the session itself whether a value was confirmed. The model only points at words; the
+ * speaker and the position come from the session. Confirmed means: the user stated the value; or the
+ * user explicitly accepted an earlier assistant proposal that stated it; or, for an artifact, a tool
+ * produced it. Anything else is a proposal and stays inside its topic.
+ */
+export declare function verify(input: {
+    sessionId: string;
+    events: readonly EvidenceEvent[];
+    kind: FactKind;
+    value: string;
+    quote: string;
+    acceptsQuote?: string;
+}): Verdict;
+/** One fact as other topics are shown it: `【topic】label = value (version n, confirmed at …)`. */
+export declare function factLine(fact: FactView, topicTitle: string): string;
+/** Lines up to a character budget, whole lines only. */
+export declare function within(lines: string[], budget: number): string[];
+export interface FactCandidate {
+    id: string;
+    topic: string;
+    label: string;
+    kind: FactKind;
+    value: string;
+}
+/**
+ * Facts from other topics that the message may draw on, best first. Ranking only: whether a fact may
+ * actually be delivered is decided again at delivery, against the final topic and current settings.
+ */
+export declare function rankCandidates(facts: readonly (FactView & {
+    topicTitle: string;
+    related: number;
+    lastUsedAt?: number;
+})[], text: string, now?: number): FactCandidate[];

package/dist/facts.js

@@ -0,0 +1,177 @@
+import { redactRoutingText, textFeatures } from "./routing-policy.js";
+export const FACT_KINDS = ['fact', 'decision', 'artifact'];
+/** Every size limit of the feature in one place; each is a hard cap on characters or items. */
+export const FACT_LIMITS = {
+    label: 60, value: 300, quote: 200, aliases: 6, alias: 60, recordItems: 8,
+    routerBudget: 1200, routerLabel: 40, routerValue: 80, routerItems: 12, imports: 5,
+    briefingBudget: 1200, noticeBudget: 600, ownBudget: 1500, ownItems: 20, lookupItems: 10,
+    extractionBudget: 6000, extractionFacts: 1500,
+};
+const clip = (text, max) => text.length > max ? text.slice(0, Math.max(0, max - 1)) + '…' : text;
+/** Text that may be stored or shown: credentials and personal addresses removed, then shortened. */
+export const safe = (text, max) => clip(redactRoutingText(text).trim(), max);
+/**
+ * The name two writes must share to be the same fact. Case, width and spacing are folded, and only
+ * wrapping quotes and punctuation are dropped, so `C++`, `C#` and `.NET` stay distinct.
+ */
+export function factKey(label) {
+    return label.normalize('NFKC').toLowerCase().replace(/\s+/g, ' ').trim()
+        .replace(/^[\s"'“”‘’「」『』《》〈〉()（）[\]【】,;:!?，。；：！？、]+/, '')
+        .replace(/[\s"'“”‘’「」『』《》〈〉()（）[\]【】.,;:!?，。；：！？、]+$/, '');
+}
+/** Folded text for finding a quote inside a message: width, case, spacing and thousands separators. */
+export function matchText(text) {
+    return redactRoutingText(text).normalize('NFKC').toLowerCase().replace(/(\d)[,，](?=\d{3}\b)/g, '$1').replace(/\s+/g, '');
+}
+/** Literal evidence, with complete numeric tokens and units; similarity is for ranking, not proof. */
+export function states(source, value) {
+    const s = matchText(source), v = matchText(value);
+    if (!v || !s)
+        return false;
+    const present = new Set(numberTokens(source));
+    if (numberTokens(value).some(number => !present.has(number)))
+        return false;
+    return s.includes(v);
+}
+/**
+ * Whole numbers as written, read before spaces are folded away (so "12 3pm" is 12 and 3, not 123).
+ * A sign only where no digit precedes it, so "2026-10-05" holds 10 and 05, not -10 and -05.
+ */
+function numberTokens(text) {
+    return redactRoutingText(text).normalize('NFKC').replace(/(\d)[,，](?=\d{3}\b)/g, '$1').match(/(?<![\d.])[+-]?\d+(?:\.\d+)?/g) ?? [];
+}
+const NEGATION = /(不行|不可以|不好|不要|不用|不能|不是|不再|不同意|不采用|不选|别这样|算了|再想想|\bno\b|\bnot\b|\bdon'?t\b|\bnope\b|rather than|instead of)/i;
+const UNCERTAIN = /(未定|没定|没(?:有)?确定|未确认|未确定|不确定|暂定|待定|建议|假设|如果|或许|可能|\b(might|maybe|perhaps|suggest|suppose|if|undecided)\b)/i;
+const QUESTION = /[?？]|(吗|呢)\s*[。！!]?\s*$/;
+const ACCEPTANCE = /((?:^|[\s，,。.!！;；])(?:好的?|行|可以|确定|定了)(?=$|[\s，,。.!！;；]|就|按)|就按|就这样|就用|就它|同意|就这么定|没问题|按你说的|\bok(ay)?\b|\byes\b|\bsure\b|sounds good|go with|let'?s (do|go|use)|\bagreed?\b|\bdeal\b|works for me|that works)/i;
+/** Naming the assistant's suggestion ("就按你的建议", "your suggestion") is how an acceptance points at it. */
+const THEIR_SUGGESTION = /((?:你|您)(?:的|刚才的|说的)?(?:建议|提议|方案))|\byour (?:suggestion|proposal|idea)\b/gi;
+/** "ok, go with that": an explicit acceptance, without a refusal and not itself a question. */
+export function accepts(text) {
+    return ACCEPTANCE.test(text) && !NEGATION.test(text) && !UNCERTAIN.test(text.replace(THEIR_SUGGESTION, '')) && !QUESTION.test(text.trim());
+}
+/** A retraction needs words withdrawing or reopening a value, not merely any user quote. */
+export function retracts(text) {
+    return !QUESTION.test(text.trim()) && /(撤回|取消|不再|不要|不用|未定|没定|没(?:有)?确定|未确认|未确定|不确定|先不定|待定|\b(withdraw|withdrawn|cancel|cancelled|canceled|undecided)\b|no longer|is off|not (yet )?(settled|decided))/i.test(text);
+}
+/** Check the actual sentence, including words a shortened model quote might have omitted. */
+function assertsValue(text, value, quote) {
+    const needle = matchText(quote);
+    const clauses = text.replace(/(\d)[,，](?=\d{3}\b)/g, '$1').split(/(?<=[。！？!?;；\n])/).flatMap(sentence => sentence.split(/[,，]/).filter(clause => states(clause, value) &&
+        (matchText(clause).includes(needle) || needle.includes(matchText(clause))))
+        .map(clause => ({ text: clause, question: QUESTION.test(sentence.trim()) })));
+    return clauses.length > 0 && clauses.every(clause => !clause.question && !NEGATION.test(clause.text) && !UNCERTAIN.test(clause.text));
+}
+/**
+ * The messages of a topic session that can serve as evidence, newest last: the user's own messages,
+ * the assistant's answers and tool activity. TheOne's reference material for the session (its
+ * descriptor, cross-topic briefings) is not the user speaking and never counts.
+ */
+export function evidenceEvents(events, limit = 200) {
+    const text = (blocks) => blocks.flatMap(block => block.type === 'text' && block.text ? [block.text] : []).join('\n');
+    // TheOne's own tools repeat the quotes they are given; a call citing itself proves nothing.
+    const own = new Set(events.flatMap(event => event.type === 'tool/call' && event.data.name.startsWith('theone_') ? [String(event.data.callId)] : []));
+    const result = [];
+    for (const event of events) {
+        if (event.type === 'user/message' && event.data.source.kind === 'user')
+            result.push({ seq: event.seq, speaker: 'user', text: text(event.data.content) });
+        else if (event.type === 'assistant/message')
+            result.push({ seq: event.seq, speaker: 'assistant', text: text(event.data.message.content) });
+        else if (event.type === 'tool/result' && !own.has(String(event.data.message.source.callId)))
+            result.push({ seq: event.seq, speaker: 'tool', text: text(event.data.message.content), toolResult: true, isError: event.data.message.isError === true });
+    }
+    return result.filter(item => item.text.trim()).slice(-limit);
+}
+/** The newest event containing `quote` (folded), optionally only from one speaker or before a point. */
+export function findQuote(events, quote, options = {}) {
+    const needle = matchText(quote);
+    if (needle.length < 2)
+        return undefined;
+    for (let index = events.length - 1; index >= 0; index--) {
+        const event = events[index];
+        if (options.before !== undefined && event.seq >= options.before)
+            continue;
+        if (options.speaker && event.speaker !== options.speaker)
+            continue;
+        if (matchText(event.text).includes(needle))
+            return event;
+    }
+    return undefined;
+}
+/**
+ * Decide from the session itself whether a value was confirmed. The model only points at words; the
+ * speaker and the position come from the session. Confirmed means: the user stated the value; or the
+ * user explicitly accepted an earlier assistant proposal that stated it; or, for an artifact, a tool
+ * produced it. Anything else is a proposal and stays inside its topic.
+ */
+export function verify(input) {
+    const quote = safe(input.quote, FACT_LIMITS.quote);
+    // The user's own message wins over an echo of it (the assistant repeating what the user said).
+    const hit = findQuote(input.events, input.quote, { speaker: 'user' }) ?? findQuote(input.events, input.quote);
+    if (!hit)
+        return { status: 'proposed', reason: 'quote-not-found', evidence: { sessionId: input.sessionId, seq: null, speaker: 'unverified', quote } };
+    const evidence = { sessionId: input.sessionId, seq: hit.seq, speaker: hit.speaker, quote };
+    if (hit.speaker === 'user' && states(input.quote, input.value) && assertsValue(hit.text, input.value, input.quote))
+        return { status: 'confirmed', evidence };
+    if (hit.speaker === 'user' && input.acceptsQuote && accepts(input.quote) && accepts(hit.text)) {
+        const proposal = findQuote(input.events, input.acceptsQuote, { speaker: 'assistant', before: hit.seq });
+        const latest = input.events.findLast(event => event.speaker === 'assistant' && event.seq < hit.seq);
+        if (proposal && proposal.seq === latest?.seq && states(input.acceptsQuote, input.value))
+            return { status: 'confirmed', evidence: { ...evidence, accepts: { seq: proposal.seq, quote: safe(input.acceptsQuote, FACT_LIMITS.quote) } } };
+        return { status: 'proposed', reason: 'proposal-not-found', evidence };
+    }
+    if (input.kind === 'artifact' && hit.speaker === 'tool' && hit.toolResult && !hit.isError && states(hit.text, input.value))
+        return { status: 'confirmed', evidence };
+    return { status: 'proposed', reason: hit.speaker === 'user' ? 'value-not-in-quote' : `said-by-${hit.speaker}`, evidence };
+}
+/** One fact as other topics are shown it: `【topic】label = value (version n, confirmed at …)`. */
+export function factLine(fact, topicTitle) {
+    const at = new Date(fact.createdAt).toISOString().slice(0, 16).replace('T', ' ') + ' UTC';
+    const confirmedBy = fact.evidence.speaker === 'tool' ? '工具验证于' : '用户确认于';
+    return `- 【${safe(topicTitle, 40)}】${safe(fact.label, FACT_LIMITS.label)} = ${safe(fact.value ?? '', FACT_LIMITS.value)}（第 ${fact.version} 版，${confirmedBy} ${at}）`;
+}
+/** Lines up to a character budget, whole lines only. */
+export function within(lines, budget) {
+    const kept = [];
+    let used = 0;
+    for (const line of lines) {
+        if (used + line.length + 1 > budget)
+            break;
+        kept.push(line);
+        used += line.length + 1;
+    }
+    return kept;
+}
+/**
+ * Facts from other topics that the message may draw on, best first. Ranking only: whether a fact may
+ * actually be delivered is decided again at delivery, against the final topic and current settings.
+ */
+export function rankCandidates(facts, text, now = Date.now()) {
+    const query = textFeatures(text);
+    const lower = text.toLowerCase();
+    const scored = facts.flatMap(fact => {
+        const words = textFeatures([fact.label, ...fact.aliases, fact.value ?? ''].join(' '));
+        let shared = 0;
+        for (const feature of words)
+            if (query.has(feature))
+                shared++;
+        const lexical = words.size ? shared / Math.sqrt(words.size * Math.max(1, query.size)) : 0;
+        const named = fact.topicTitle && lower.includes(fact.topicTitle.toLowerCase()) ? 0.3 : 0;
+        const fresh = 0.1 * 0.5 ** ((now - (fact.lastUsedAt ?? fact.createdAt)) / (14 * 86400000));
+        const score = lexical + named + Math.min(0.3, fact.related * 0.1) + fresh;
+        return lexical > 0 || named > 0 ? [{ fact, score }] : [];
+    }).sort((a, b) => b.score - a.score);
+    const result = [];
+    let used = 2; // The serialized array's brackets and commas count towards the router budget too.
+    for (const { fact } of scored) {
+        if (result.length >= FACT_LIMITS.routerItems)
+            break;
+        const item = { id: fact.id, topic: clip(fact.topicTitle, 40), label: clip(fact.label, FACT_LIMITS.routerLabel), kind: fact.kind, value: safe(fact.value ?? '', FACT_LIMITS.routerValue) };
+        const size = JSON.stringify(item).length + (result.length ? 1 : 0);
+        if (used + size > FACT_LIMITS.routerBudget)
+            break;
+        result.push(item);
+        used += size;
+    }
+    return result;
+}

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

@@ -31,6 +31,12 @@ 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;
 }
@@ -148,6 +154,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 +177,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 +187,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 +205,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