soulbridge 0.0.26 → 0.0.98

package/dist/packages/core/src/context.js

@@ -1,4 +1,7 @@
-import { rank } from './scoring.js';
+import { FACT_STATUS } from './config/status.js';
+import { ANCHOR_TYPES } from './config/labels.js';
+import { isActive, roleOf } from './roles.js';
+import { escapeAttr, escapeBlockText } from './inject-text.js';
 import { selectDirectives } from './affect/directives.js';
 export const DEFAULT_MAX_CHARS = 1200;
 /** Characters reserved for the affect section; if it does not fit, it is dropped whole. */
@@ -32,20 +35,25 @@ export function buildContext(store, request, now = Date.now()) {
     const emotion = store.emotion(request.soulId, request.userId);
     const maxChars = request.maxChars ?? DEFAULT_MAX_CHARS;
     const sections = [];
-    const since = identity ? timeTogether(identity.createdAt, now) : '你刚开始认识这个用户';
-    sections.push(`<soul name="${name}">\n你是${name}，一个持续成长的伙伴。${since}。\n</soul>`);
-    const styles = styleDirectives(emotion);
+    if (request.includeSoul !== false) {
+        const since = identity ? timeTogether(identity.createdAt, now) : '你刚开始认识这个用户';
+        // The name comes from configuration, but every attribute goes through one rule.
+        const safeName = escapeAttr(name);
+        sections.push(`<soul name="${safeName}">\n你是${safeName}，一个持续成长的伙伴。${since}。\n</soul>`);
+    }
+    const styles = request.includeStyle === false ? [] : styleDirectives(emotion);
     if (styles.length > 0) {
-        sections.push(`<style>\n${styles.map((s) => `- ${s}`).join('\n')}\n</style>`);
+        sections.push(`<style>\n${escapeBlockText(styles.map((s) => `- ${s}`).join('\n'))}\n</style>`);
     }
     // Affect: newest sample only, and only when it is confident and recent enough.
+    // Excluded on request: a stable prompt cannot carry a value that changes every turn.
     let affectMeta;
-    const [latest] = store.recentAffect(request.soulId, request.userId, now - AFFECT_WINDOW_MS);
+    const [latest] = request.includeAffect === false ? [] : store.recentAffect(request.soulId, request.userId, now - AFFECT_WINDOW_MS);
     if (latest) {
         const directives = selectDirectives(latest);
         if (directives.length > 0) {
-            const section = `<affect confidence="${latest.confidence.toFixed(2)}" analyzer="${latest.analyzer}">\n` +
-                `${directives.map((d) => `- ${d.text}`).join('\n')}\n</affect>`;
+            const section = `<affect confidence="${latest.confidence.toFixed(2)}" analyzer="${escapeAttr(latest.analyzer)}">\n` +
+                `${escapeBlockText(directives.map((d) => `- ${d.text}`).join('\n'))}\n</affect>`;
             const usedSoFar = sections.join('\n\n').length;
             if (section.length <= AFFECT_BUDGET && usedSoFar + section.length + 2 <= maxChars) {
                 sections.push(section);
@@ -53,32 +61,55 @@ export function buildContext(store, request, now = Date.now()) {
             }
         }
     }
-    const candidates = store
-        .query({ soulId: request.soulId, userId: request.userId })
-        .filter((memory) => (request.types === undefined || request.types.includes(memory.type)) &&
-        (request.minImportance === undefined || memory.importance >= request.minImportance));
-    const ranked = rank(candidates, request.query ?? '', now);
+    // Anchors come from two places during the migration: concluded judgments and
+    // lessons are facts now (ADR 0032), while the legacy `memories` table is still
+    // read until its rows have been migrated and deleted. The union keeps the
+    // injection stable across that switch instead of dropping every lesson at once.
+    // The anchor vocabulary is declared in config/labels.ts; this file only filters.
+    // A fact carrying the 锚点 slot is explicit ("the user asked me to remember this"),
+    // so it is injected whatever its type name — otherwise an explicit note typed as
+    // 事实 would be stored and never surface.
+    const anchorTypes = new Set(ANCHOR_TYPES);
+    const explicitAnchor = (fact) => (fact.slots ?? []).some((slot) => slot.slot === '锚点' && slot.value.kind === 'text' && slot.value.value === '是');
+    // Roles replace the old type-name check; roleOf() falls back to typeName for rows written
+    // before the migration, so anchors stay stable across the switch.
+    const ANCHOR_ROLES = new Set(['judgment', 'lesson']);
+    const anchors = store
+        .facts({ soulId: request.soulId, userId: request.userId, limit: 300 })
+        .filter((fact) => isActive(fact) &&
+        (ANCHOR_ROLES.has(roleOf(fact)) || anchorTypes.has(fact.typeName ?? '') || explicitAnchor(fact)))
+        .map((fact) => ({ id: fact.id, label: fact.typeName ?? '事实', text: fact.statement, score: fact.confidence }));
+    for (const memory of store.query({ soulId: request.soulId, userId: request.userId })) {
+        if (request.types !== undefined && !request.types.includes(memory.type))
+            continue;
+        if (request.minImportance !== undefined && memory.importance < request.minImportance)
+            continue;
+        anchors.push({ id: memory.id, label: memory.type, text: memory.content, score: memory.importance / 10 });
+    }
+    anchors.sort((a, b) => b.score - a.score);
     const maxItems = request.maxItems ?? Number.POSITIVE_INFINITY;
     let chars = sections.join('\n\n').length;
     let dropped = 0;
     const lines = [];
     const used = [];
-    for (const { memory } of ranked) {
+    for (const anchor of anchors) {
         if (lines.length >= maxItems) {
             dropped += 1;
             continue;
         }
-        const line = `- [${memory.type}] ${memory.content}`;
+        // Escaping can lengthen a line (one `&lt;` is four characters), so cost is charged
+        // on the escaped text — the budget has to measure what actually gets injected.
+        const line = `- [${escapeBlockText(anchor.label)}] ${escapeBlockText(anchor.text)}`;
         const cost = line.length + 1 + 10; // line + newline + section overhead share
         if (chars + cost > maxChars) {
             dropped += 1;
             continue;
         }
         lines.push(line);
-        used.push(memory.id);
+        used.push(anchor.id);
         chars += cost;
     }
-    if (lines.length > 0)
+    if (request.includeAnchors !== false && lines.length > 0)
         sections.push(`<memories>\n${lines.join('\n')}\n</memories>`);
     const text = sections.join('\n\n');
     if (request.track !== false && used.length > 0)

package/dist/packages/core/src/dimension-text.d.ts

@@ -0,0 +1,6 @@
+import type { ProfileDimension } from './config/dimensions.ts';
+export declare function isProfileDimension(value: unknown): value is ProfileDimension;
+/** The definitions block both prompts embed, generated from the declaration. */
+export declare function renderDimensionDefinitions(): string;
+/** The dimension choice line, generated rather than retyped. */
+export declare function dimensionChoices(): string;

package/dist/packages/core/src/dimension-text.js

@@ -0,0 +1,24 @@
+/**
+ * Decoders for the dimension vocabulary.
+ *
+ * `config/dimensions.ts` holds the data and nothing else; everything that turns that
+ * data into text or validates an answer lives here. The split is what makes the
+ * config folder safe to edit: no behaviour hides in a definition file, and the
+ * check in health-check enforces it.
+ */
+import { PROFILE_DIMENSIONS, PROFILE_DIMENSION_DEFINITIONS } from './config/dimensions.js';
+export function isProfileDimension(value) {
+    return typeof value === 'string' && PROFILE_DIMENSIONS.includes(value);
+}
+/** The definitions block both prompts embed, generated from the declaration. */
+export function renderDimensionDefinitions() {
+    const lines = PROFILE_DIMENSIONS.map((dimension) => `- ${dimension}：${PROFILE_DIMENSION_DEFINITIONS[dimension]}`);
+    return `<dimensions>
+每个维度是什么，决定什么算一条、什么不算：
+${lines.join('\n')}
+</dimensions>`;
+}
+/** The dimension choice line, generated rather than retyped. */
+export function dimensionChoices() {
+    return `维度=${PROFILE_DIMENSIONS.join('|')}`;
+}

package/dist/packages/core/src/dimensions.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The profile dimension vocabulary, declared once.
+ *
+ * A dimension is a noun we ship to two model stages and to the merge parser: the
+ * classifier decides which lens a lesson belongs to, the merge decides which lens a
+ * line belongs to, and the parser rejects anything else. Those three must agree, so
+ * the names AND their admission criteria live here and nowhere else — prompts render
+ * this, they do not retype it.
+ *
+ * The definitions are borrowed from measurement traditions on purpose:
+ * 价值观 ← Schwartz; 人际关系 ← interpersonal circumplex (warmth × dominance);
+ * 生活兴趣 ← RIASEC; 情绪 ← core affect. 边界 has no taxonomy — it quotes the words.
+ * These are admission criteria for a sentence, not a personality theory.
+ */
+export declare const PROFILE_DIMENSIONS: readonly ['价值观', '工作方式', '沟通偏好', '情绪', '人际关系', '生活兴趣', '边界'];
+export type ProfileDimension = (typeof PROFILE_DIMENSIONS)[number];
+/** What counts as a line in each dimension, and what does not. */
+export declare const PROFILE_DIMENSION_DEFINITIONS: Record<ProfileDimension, string>;
+export declare function isProfileDimension(value: unknown): value is ProfileDimension;
+/**
+ * Render the definitions block both prompts embed.
+ *
+ * Generated from the declaration above so a new dimension cannot be added to the
+ * vocabulary without appearing in the prompt (and vice versa).
+ */
+export declare function renderDimensionDefinitions(): string;
+/** The "维度=价值观|工作方式|…" line, generated rather than retyped. */
+export declare function dimensionChoices(): string;

package/dist/packages/core/src/dimensions.js

@@ -0,0 +1,53 @@
+/**
+ * The profile dimension vocabulary, declared once.
+ *
+ * A dimension is a noun we ship to two model stages and to the merge parser: the
+ * classifier decides which lens a lesson belongs to, the merge decides which lens a
+ * line belongs to, and the parser rejects anything else. Those three must agree, so
+ * the names AND their admission criteria live here and nowhere else — prompts render
+ * this, they do not retype it.
+ *
+ * The definitions are borrowed from measurement traditions on purpose:
+ * 价值观 ← Schwartz; 人际关系 ← interpersonal circumplex (warmth × dominance);
+ * 生活兴趣 ← RIASEC; 情绪 ← core affect. 边界 has no taxonomy — it quotes the words.
+ * These are admission criteria for a sentence, not a personality theory.
+ */
+export const PROFILE_DIMENSIONS = [
+    '价值观',
+    '工作方式',
+    '沟通偏好',
+    '情绪',
+    '人际关系',
+    '生活兴趣',
+    '边界',
+];
+/** What counts as a line in each dimension, and what does not. */
+export const PROFILE_DIMENSION_DEFINITIONS = {
+    价值观: '超越具体情境、值得追求的目标（Schwartz）。"想把事做对"算；"这个接口用 POST"不算。',
+    工作方式: '面对任务时的稳定做法。"先验证再动手"算；"这次改了 A 文件"不算。',
+    沟通偏好: '希望信息以什么形式、什么节奏出现。"整轮对话当整体"算。',
+    情绪: '对具体事件的感受与强度。"被反复确认会烦"算；"今天天气"不算。',
+    人际关系: '与特定人的位置和距离（温暖 × 支配）。"她最近压力大"算。',
+    生活兴趣: '自愿投入时间的事。"喜欢爬山"算。',
+    边界: '明确说过的"不要"。没有公认分类学，必须贴着原话，不许概括。',
+};
+export function isProfileDimension(value) {
+    return typeof value === 'string' && PROFILE_DIMENSIONS.includes(value);
+}
+/**
+ * Render the definitions block both prompts embed.
+ *
+ * Generated from the declaration above so a new dimension cannot be added to the
+ * vocabulary without appearing in the prompt (and vice versa).
+ */
+export function renderDimensionDefinitions() {
+    const lines = PROFILE_DIMENSIONS.map((dimension) => `- ${dimension}：${PROFILE_DIMENSION_DEFINITIONS[dimension]}`);
+    return `<dimensions>
+每个维度是什么，决定什么算一条、什么不算：
+${lines.join('\n')}
+</dimensions>`;
+}
+/** The "维度=价值观|工作方式|…" line, generated rather than retyped. */
+export function dimensionChoices() {
+    return `维度=${PROFILE_DIMENSIONS.join('|')}`;
+}

package/dist/packages/core/src/extract.d.ts

@@ -0,0 +1,140 @@
+/**
+ * Extraction (spec/model.v0.md): turn text → drafts of entities, facts, gaps.
+ *
+ * Three rules that shape everything here:
+ *
+ * 1. Drafts, not writes. Extraction produces candidates; committing them is a
+ *    separate step with its own gate (entity resolution, dedupe). Drafts are
+ *    easy to test and bad drafts never reach the database.
+ * 2. Rules first. Most sentences in a conversation are templated ("我同事小林
+ *    上周被裁员了"), and a rule is fast, explainable and testable. The model is
+ *    only asked when the rules miss — synthesis is the model's job, parsing is
+ *    the code's (ADR 0027).
+ * 3. Nothing is invented. A rule that cannot decide emits less, not a guess:
+ *    an unknown time stays `atText`, an unresolved "她" stays unresolved.
+ *
+ * Pure functions, no I/O, no dependencies.
+ */
+import type { ThreadAttribution, ExtractDraft } from './types.ts';
+/**
+ * What a fact's confidence is when the model did not give one.
+ *
+ * The midpoint is the only honest value: 0 says "probably false" and 1 says
+ * "certain", and neither is what "no answer" means. Used by both the text and the
+ * JSON paths so the two shapes cannot disagree.
+ */
+export declare const UNKNOWN_CONFIDENCE = 0.6;
+/**
+ * A calendar date, or nothing.
+ *
+ * `Date.parse('2026-02-31T00:00:00Z')` does not fail: it rolls to 2026-03-03. A rolled
+ * date is worse than a missing one — it is confidently wrong and joins time retrieval
+ * as if it were exact. Round-tripping through Date is the only reliable check.
+ */
+export declare function calendarDate(year: number, month: number, day: number): number | undefined;
+/** Parse `YYYY-MM-DD`; anything that is not a real day on the calendar returns undefined. */
+export declare function parseIsoDate(text: string): number | undefined;
+/**
+ * Rule extraction. Returns drafts for one turn's user text; may return an empty
+ * list, which is a valid answer (small talk is not a fact).
+ *
+ * Pronouns are resolved only inside the same turn, and only to the most recent
+ * explicit person: "我同事小林被裁了。不知道她后来怎么样" can bind 她→小林 because
+ * the turn itself said who she is. Across turns we do not guess — an unresolved
+ * "她" stays unresolved instead of being attached to the wrong person.
+ */
+export declare function extractByRules(text: string, at?: number): ExtractDraft;
+interface ModelParseResult {
+    draft: ExtractDraft | null;
+    error?: string;
+}
+/** What the model is allowed to know about the store before extracting. */
+export interface ExtractionContext {
+    entities: Array<{
+        id: string;
+        name: string;
+        aliases?: string[];
+        relation?: string;
+    }>;
+    facts: Array<{
+        id: string;
+        statement: string;
+        atText?: string;
+    }>;
+    previousUserText?: string;
+    /** Open threads, for attribution (labels plus their last lines, ADR 0034). */
+    threads?: Array<{
+        id: string;
+        topic: string;
+        ago?: number;
+        recent?: Array<{
+            role: 'user' | 'assistant';
+            text: string;
+        }>;
+    }>;
+    previousThreadId?: string;
+}
+/**
+ * Model extraction: one call, strict JSON, validated afterwards.
+ *
+ * The model sees the entities and facts already stored, so it can reuse a name
+ * instead of inventing a duplicate and can supersede a fact that the new
+ * sentence contradicts. That merge decision is the difference between "a log of
+ * sentences" and memory (Mem0's ADD/UPDATE/DELETE, Graphiti's invalidation).
+ *
+ * The prompt itself is rendered from `prompts.ts`, not written here.
+ */
+export declare function extractWithModel(text: string, llm: (prompt: string) => Promise<string> | string, at?: number, context?: ExtractionContext, assistantText?: string): Promise<ModelParseResult>;
+/**
+ * Parse the attribution line.
+ *
+ *  线索: 继续 th_ab12
+ *  线索: 新 | 在聊 cookie 与认证
+ */
+export declare function parseThreadLine(raw: string): ThreadAttribution | null;
+/**
+ * What the model's thread line said, including whether it said anything.
+ *
+ * `parseThreadLine` collapses "no line" and "a line I cannot read" into null, which made
+ * the fallback rate unmeasurable — 75% of attributions arrived as `fallback-previous`
+ * with no way to tell whether the model was silent or unparseable. The kinds are kept
+ * apart here; only `continue` and `new` are usable attributions.
+ */
+export declare function readThreadLine(raw: string): {
+    kind: 'continue';
+    id: string;
+    topic?: string;
+} | {
+    kind: 'new';
+    topic?: string;
+} | {
+    kind: 'absent';
+} | {
+    kind: 'invalid';
+    line: string;
+};
+/**
+ * Validate and normalise a model answer. Anything malformed is dropped rather
+ * than repaired: a missing statement cannot be invented, and a bad entity type
+ * would poison retrieval later.
+ *
+ * `supersede` / `update` must point at a fact the model was actually shown —
+ * otherwise it could retire a memory it never read.
+ */
+export declare function validateDraft(json: unknown, at?: number, context?: ExtractionContext): ModelParseResult;
+/**
+ * Parse the line template the model is asked to fill in.
+ *
+ * Requiring valid JSON makes the whole extraction hinge on one character:
+ * a missing brace turns a correct answer into "model-failed". A line template
+ * fails per line instead, so one malformed record costs one record. The shape it
+ * builds is the same object `validateDraft` already checks, so there is one gate,
+ * not two.
+ *
+ *   实体: 小林 | person | 同事
+ *   事实: 陈述 | 类型名 | 2026-10-24 | 上周 | told | 0.8 | 被裁员者=小林
+ *   缺口: 怎么了 | 0.6 | 小林
+ *   无
+ */
+export declare function parseLineDraft(raw: string): Record<string, unknown> | null;
+export {};