dsh-theone 0.3.20 → 0.3.22

package/dist/fact-flow.d.ts

@@ -0,0 +1,39 @@
+import type { ContextStore } from './store.ts';
+import { type LinkScope } from './linkage.ts';
+import { type EvidenceEvent, type FactCandidate, type FactView } from './facts.ts';
+/** Confirmed facts this message might use, best first, within budget. Ranking only. */
+export declare function factCandidates(store: ContextStore, scope: LinkScope, text: string, recent: string[], currentId?: string): FactCandidate[];
+export interface FactDelivery {
+    notices: string[];
+    facts: string[];
+    /** Record what was sent; call only once the briefing carrying these lines is actually sent. */
+    commit(): void;
+}
+/**
+ * What a topic is told about facts before its Worker answers: changes to facts it used before
+ * (also on a plain "go on") and the facts this request imports. Every fact is checked here, against
+ * the topic finally chosen and the settings now; nothing is recorded until `commit`.
+ */
+export declare function factDelivery(store: ContextStore, scope: LinkScope, contextId: string, imports: string[], inputId?: string): FactDelivery;
+/** The topic's own recorded facts, with ids and versions, for its Worker's descriptor. */
+export declare function ownFactsText(store: ContextStore, contextId: string): string;
+/** Optional extraction after a turn; every item it returns is checked like a Worker's own record. */
+export declare const EXTRACT_PROMPT = "\u4F60\u5728\u5E2E\u4E00\u4E2A\u8BDD\u9898\u8BB0\u5F55\u5DF2\u7ECF\u786E\u5B9A\u4E0B\u6765\u7684\u8981\u70B9\uFF1A\u6570\u5B57\u3001\u65E5\u671F\u3001\u51B3\u5B9A\u3001\u6587\u4EF6\u6216\u94FE\u63A5\u7684\u4F4D\u7F6E\u3002\u8F93\u5165\u662F\u672C\u8F6E\u7684\u7528\u6237\u6D88\u606F user\u3001\u52A9\u624B\u56DE\u7B54 assistant\uFF0C\u4EE5\u53CA\u672C\u8BDD\u9898\u5DF2\u8BB0\u5F55\u7684\u8981\u70B9 facts\uFF08\u542B factId \u548C\u7248\u672C\uFF09\u3002\n\u53EA\u8BB0\u5F55\u7528\u6237\u4EB2\u53E3\u8BF4\u51FA\u7684\u503C\uFF0C\u6216\u7528\u6237\u660E\u786E\u63A5\u53D7\u4E86\u52A9\u624B\u63D0\u8BAE\u7684\u503C\uFF08\u6B64\u65F6 acceptsQuote \u586B\u52A9\u624B\u63D0\u8BAE\u7684\u539F\u8BDD\uFF09\uFF1B\u52A9\u624B\u81EA\u5DF1\u7684\u5EFA\u8BAE\u3001\u63A8\u6D4B\u3001\u672A\u5B9A\u7684\u4E8B\u4E0D\u8981\u8BB0\u5F55\u3002\n\u6BCF\u6761\u90FD\u5FC5\u987B\u7ED9\u51FA evidenceQuote\uFF1A\u672C\u8F6E\u5BF9\u8BDD\u91CC\u80FD\u8BC1\u660E\u5B83\u7684\u539F\u8BDD\uFF0C\u9010\u5B57\u590D\u5236\u3002\u5DF2\u8BB0\u5F55\u8FC7\u7684\u540C\u4E00\u4EF6\u4E8B\u7528\u5B83\u7684 factId \u66F4\u65B0\uFF1B\u7528\u6237\u8BF4\u67D0\u4E2A\u503C\u4E0D\u518D\u6210\u7ACB\u6216\u8FD8\u6CA1\u5B9A\u65F6\uFF0C\u8F93\u51FA op \u4E3A \"retract\" \u5E76\u7ED9\u51FA\u7528\u6237\u539F\u8BDD\u3002\u6CA1\u6709\u5C31\u8F93\u51FA\u7A7A\u6570\u7EC4\u3002\n\u53EA\u8F93\u51FA JSON \u6570\u7EC4\uFF0C\u4F8B\u5982 [{\"op\":\"set\",\"factId\":null,\"label\":\"\u9884\u7B97\",\"kind\":\"fact\",\"value\":\"800\",\"evidenceQuote\":\"\u9884\u7B97\u5B9A\u4E3A 800 \u5143\"}]\u3002kind \u53EA\u80FD\u662F fact\u3001decision\u3001artifact\u3002";
+/** The extraction request for the turn that just ended: cleaned, and within its size budget. */
+export declare function extractionPayload(events: readonly EvidenceEvent[], base: readonly FactView[]): {
+    user: string;
+    assistant: string;
+    facts: object[];
+} | undefined;
+/**
+ * Store what an extraction returned, by the same rules as a Worker's record: evidence is checked in
+ * the session, and every write expects the version the topic had when the turn ended, so a late
+ * extraction cannot overwrite a newer value. Returns how many items were stored.
+ */
+export declare function applyExtraction(store: ContextStore, input: {
+    sessionId: string;
+    contextId: string;
+    events: readonly EvidenceEvent[];
+    base: readonly FactView[];
+    items: unknown;
+}): number;

package/dist/fact-flow.js

@@ -0,0 +1,135 @@
+import { LINK_SIGNAL, mayShare, relatedTopics } from "./linkage.js";
+import { FACT_KINDS, FACT_LIMITS, factKey, factLine, findQuote, rankCandidates, retracts, safe, verify, within } from "./facts.js";
+/** Confirmed facts this message might use, best first, within budget. Ranking only. */
+export function factCandidates(store, scope, text, recent, currentId) {
+    if (scope === 'off')
+        return [];
+    // A topic whose conversations are gone or archived offers nothing (see HistoryCatalog.reconcile).
+    const hidden = store.hiddenReasons();
+    const titles = new Map(store.contexts().filter(context => !hidden.has(context.id)).map(context => [context.id, context.title]));
+    const related = new Map(currentId ? relatedTopics(store, currentId, scope, 10).map(topic => [topic.id, topic.score]) : []);
+    // The current topic's own facts are candidates too: the message may be moving elsewhere with them.
+    // A first filter for the topic in view; delivery checks again against the topic finally chosen.
+    const pool = store.sharedFacts().filter(fact => titles.has(fact.contextId) &&
+        (currentId ? !mayShare(store, scope, fact.contextId, currentId) : !store.isPrivate(fact.contextId)))
+        .map(fact => ({ ...fact, topicTitle: titles.get(fact.contextId), related: related.get(fact.contextId) ?? 0 }));
+    return rankCandidates(pool, [...recent.slice(-2), text].join('\n'));
+}
+/**
+ * What a topic is told about facts before its Worker answers: changes to facts it used before
+ * (also on a plain "go on") and the facts this request imports. Every fact is checked here, against
+ * the topic finally chosen and the settings now; nothing is recorded until `commit`.
+ */
+export function factDelivery(store, scope, contextId, imports, inputId) {
+    const hidden = store.hiddenReasons();
+    const titles = new Map(store.contexts().filter(context => !hidden.has(context.id)).map(context => [context.id, context.title]));
+    const allowed = (sourceId) => titles.has(sourceId) && !mayShare(store, scope, sourceId, contextId);
+    const notices = [];
+    const quiet = [];
+    const noticed = new Set();
+    for (const dependency of store.dependencies(contextId)) {
+        const fact = store.fact(dependency.factId);
+        const label = safe(fact?.label ?? '一个要点', 40);
+        if (!fact || fact.deletedAt !== undefined || !allowed(fact.contextId)) {
+            // Only the name: a topic that may no longer share must not leak its new value.
+            notices.push({ line: `- 之前引用的「${label}」不再可用，不要再使用它之前的值。`, commit: () => store.forgetDependency(contextId, dependency.factId) });
+        }
+        else if (fact.version > dependency.versionSeen) {
+            const title = safe(titles.get(fact.contextId), 40);
+            const before = store.factVersion(fact.id, dependency.versionSeen);
+            // The same value said again (a reaffirmation is a new version): nothing to tell; move the mark on.
+            if (before && before.status === fact.status && before.value === fact.value) {
+                quiet.push(() => store.recordDelivery(contextId, fact, 'notice', inputId));
+                continue;
+            }
+            const line = fact.status !== 'confirmed' ? `- 【${title}】${label}：已撤回或目前没有确认的值，不要再使用之前的值。`
+                : before?.status === 'confirmed' ? `- 【${title}】${label}：${safe(before.value ?? '', 80)} → ${safe(fact.value ?? '', 80)}（第 ${fact.version} 版）`
+                    : `- 【${title}】${label}：重新确认为 ${safe(fact.value ?? '', 80)}（第 ${fact.version} 版）`;
+            notices.push({ line, commit: () => store.recordDelivery(contextId, fact, 'notice', inputId) });
+        }
+        else
+            continue;
+        noticed.add(dependency.factId);
+    }
+    const facts = [];
+    for (const id of new Set(imports)) {
+        const fact = store.fact(id);
+        if (!fact || noticed.has(id) || fact.deletedAt !== undefined || fact.status !== 'confirmed' || fact.contextId === contextId || !allowed(fact.contextId))
+            continue;
+        facts.push({ line: factLine(fact, titles.get(fact.contextId)), commit: () => {
+                store.recordDelivery(contextId, fact, 'route', inputId);
+                store.learnLink(contextId, fact.contextId, LINK_SIGNAL.mention);
+            } });
+    }
+    const fit = (items, budget) => items.slice(0, within(items.map(item => item.line), budget).length);
+    const sentNotices = fit(notices, FACT_LIMITS.noticeBudget), sentFacts = fit(facts, FACT_LIMITS.briefingBudget);
+    return { notices: sentNotices.map(item => item.line), facts: sentFacts.map(item => item.line),
+        commit: () => { for (const item of [...sentNotices, ...sentFacts])
+            item.commit(); for (const mark of quiet)
+            mark(); } };
+}
+/** The topic's own recorded facts, with ids and versions, for its Worker's descriptor. */
+export function ownFactsText(store, contextId) {
+    const lines = store.facts(contextId, true).slice(0, FACT_LIMITS.ownItems).map(fact => `- [${fact.id} v${fact.version}] ${safe(fact.label, FACT_LIMITS.label)} = ${safe(fact.value ?? '', 120)}${fact.status === 'proposed' ? '（建议，用户未确认）' : fact.status === 'retracted' ? '（已撤回）' : ''}`);
+    const kept = within(lines, FACT_LIMITS.ownBudget);
+    return kept.length ? `\n本话题已记录的要点（更新或撤回时用 theone_record，带上 factId 和 expectedVersion）：\n${kept.join('\n')}` : '';
+}
+/** Optional extraction after a turn; every item it returns is checked like a Worker's own record. */
+export const EXTRACT_PROMPT = `你在帮一个话题记录已经确定下来的要点：数字、日期、决定、文件或链接的位置。输入是本轮的用户消息 user、助手回答 assistant，以及本话题已记录的要点 facts（含 factId 和版本）。
+只记录用户亲口说出的值，或用户明确接受了助手提议的值（此时 acceptsQuote 填助手提议的原话）；助手自己的建议、推测、未定的事不要记录。
+每条都必须给出 evidenceQuote：本轮对话里能证明它的原话，逐字复制。已记录过的同一件事用它的 factId 更新；用户说某个值不再成立或还没定时，输出 op 为 "retract" 并给出用户原话。没有就输出空数组。
+只输出 JSON 数组，例如 [{"op":"set","factId":null,"label":"预算","kind":"fact","value":"800","evidenceQuote":"预算定为 800 元"}]。kind 只能是 fact、decision、artifact。`;
+/** The extraction request for the turn that just ended: cleaned, and within its size budget. */
+export function extractionPayload(events, base) {
+    const lastUser = events.findLastIndex(event => event.speaker === 'user');
+    if (lastUser < 0)
+        return undefined;
+    // An accepted proposal is quoted from the reply before the user's words, so that reply is included.
+    const previous = events.slice(0, lastUser).findLast(event => event.speaker === 'assistant');
+    const user = events[lastUser].text, assistant = [previous?.text, ...events.slice(lastUser + 1).filter(event => event.speaker === 'assistant').map(event => event.text)].filter(Boolean).join('\n');
+    const known = within(base.map(fact => JSON.stringify({ factId: fact.id, version: fact.version, status: fact.status, label: safe(fact.label, FACT_LIMITS.label), value: safe(fact.value ?? '', 120) })), FACT_LIMITS.extractionFacts);
+    const room = FACT_LIMITS.extractionBudget - known.join('').length;
+    const payload = { user: safe(user, Math.floor(room / 3)), assistant: safe(assistant, room - Math.floor(room / 3) - 200), facts: known.map(line => JSON.parse(line)) };
+    // Escaping quotes, newlines and backslashes can double the serialized request size.
+    while (JSON.stringify(payload).length > FACT_LIMITS.extractionBudget && (payload.user || payload.assistant)) {
+        const field = payload.assistant.length >= payload.user.length ? 'assistant' : 'user';
+        const excess = JSON.stringify(payload).length - FACT_LIMITS.extractionBudget;
+        payload[field] = payload[field].slice(0, Math.max(0, payload[field].length - Math.ceil(excess / 2)));
+    }
+    return payload;
+}
+/**
+ * Store what an extraction returned, by the same rules as a Worker's record: evidence is checked in
+ * the session, and every write expects the version the topic had when the turn ended, so a late
+ * extraction cannot overwrite a newer value. Returns how many items were stored.
+ */
+export function applyExtraction(store, input) {
+    if (!Array.isArray(input.items))
+        return 0;
+    const byId = new Map(input.base.map(fact => [fact.id, fact.version]));
+    const byName = new Map(input.base.flatMap(fact => [fact.key, ...fact.aliases].map(key => [key, fact.version])));
+    let stored = 0;
+    for (const item of input.items.slice(0, FACT_LIMITS.recordItems)) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const text = (key) => typeof item[key] === 'string' ? item[key] : undefined;
+        const quote = text('evidenceQuote') ?? '', factId = text('factId'), label = text('label') ?? input.base.find(fact => fact.id === factId)?.label ?? '';
+        // A name that did not exist when the turn ended must still not exist: expected version 0.
+        const expectedVersion = factId ? byId.get(factId) : byName.get(factKey(label)) ?? 0;
+        if (factId && expectedVersion === undefined)
+            continue;
+        if (item.op === 'retract') {
+            const said = factId ? findQuote(input.events, quote, { speaker: 'user' }) : undefined;
+            if (said && retracts(quote) && retracts(said.text) && store.retractFact(input.contextId, factId, { sessionId: input.sessionId, seq: said.seq, speaker: 'user', quote }, 'extractor', expectedVersion).outcome === 'retracted')
+                stored++;
+            continue;
+        }
+        const kind = (FACT_KINDS.includes(item.kind) ? item.kind : 'fact');
+        const verdict = verify({ sessionId: input.sessionId, events: input.events, kind, value: text('value') ?? '', quote, acceptsQuote: text('acceptsQuote') });
+        const result = store.recordFact(input.contextId, { ...(factId ? { factId } : {}), label, kind, value: text('value') ?? '', status: verdict.status,
+            evidence: verdict.evidence, origin: 'extractor', expectedVersion });
+        if (result.outcome === 'created' || result.outcome === 'updated')
+            stored++;
+    }
+    return stored;
+}

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/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>;