soulbridge 0.0.3 → 0.0.5

package/dist/packages/core/src/affect/analyze.js

@@ -0,0 +1,210 @@
+import { EMPTY_AFFECT } from '../types.js';
+import { ABSTAIN_TERMS, DEGREE_DELTA, NEGATORS } from './lexicon.js';
+import { SEED_LEXICON } from './seed-lexicon.js';
+export const MAX_INPUT_CHARS = 32_000;
+export const NEGATION_WINDOW = 3;
+export const DEGREE_WINDOW = 2;
+export class AffectBudgetError extends Error {
+    code = 'BUDGET_EXCEEDED';
+    constructor(length) {
+        super(`affect input too large: ${length} chars (max ${MAX_INPUT_CHARS})`);
+        this.name = 'AffectBudgetError';
+    }
+}
+const cache = new WeakMap();
+function prepare(lexicon) {
+    const cached = cache.get(lexicon);
+    if (cached)
+        return cached;
+    const entries = new Map(Object.entries(lexicon.entries));
+    const fillers = new Set(lexicon.fillers);
+    const hedges = new Set(lexicon.hedges);
+    const vague = new Set(Object.keys(lexicon.vague));
+    const degree = new Map();
+    for (const level of Object.keys(DEGREE_DELTA)) {
+        for (const word of lexicon.degree[level])
+            degree.set(word, DEGREE_DELTA[level]);
+    }
+    const dict = new Set([
+        ...entries.keys(),
+        ...fillers,
+        ...hedges,
+        ...vague,
+        ...degree.keys(),
+        ...NEGATORS,
+        ...ABSTAIN_TERMS,
+    ]);
+    let maxLen = 1;
+    for (const word of dict)
+        maxLen = Math.max(maxLen, word.length);
+    const prepared = { entries, fillers, hedges, vague, degree, dict, maxLen };
+    cache.set(lexicon, prepared);
+    return prepared;
+}
+/** Full-width punctuation → ASCII, strip code fences and shell lines, drop emoji. */
+export function normalizeForAffect(text) {
+    const withoutCode = text.replace(/```[\s\S]*?```/g, ' ');
+    const lines = withoutCode
+        .split(/\r?\n/)
+        .filter((line) => !/^\s*\$\s/.test(line))
+        .join('\n');
+    return lines
+        .replace(/[\uff01-\uff5e]/g, (ch) => String.fromCharCode(ch.charCodeAt(0) - 0xfee0))
+        .replace(/[\u{1f000}-\u{1faff}\u{2600}-\u{27bf}\u{fe0f}\u{200d}]/gu, ' ')
+        .replace(/[\u0000-\u001f\u007f]/g, ' ')
+        .toLowerCase();
+}
+/** Max forward match over the lexicon dictionary; punctuation and spaces are separators. */
+export function tokenizeForAffect(text, dict, maxLen) {
+    const tokens = [];
+    let i = 0;
+    while (i < text.length) {
+        const ch = text[i];
+        if (/[\s\p{P}\p{S}]/u.test(ch)) {
+            i += 1;
+            continue;
+        }
+        let matched = '';
+        for (let len = Math.min(maxLen, text.length - i); len >= 1; len -= 1) {
+            const candidate = text.slice(i, i + len);
+            if (dict.has(candidate)) {
+                matched = candidate;
+                break;
+            }
+        }
+        if (matched) {
+            tokens.push(matched);
+            i += matched.length;
+        }
+        else {
+            tokens.push(ch);
+            i += 1;
+        }
+    }
+    return tokens;
+}
+const clamp = (n, lo, hi) => Math.min(hi, Math.max(lo, n));
+/**
+ * Negating a positive emotion turns it negative ("不开心"), but negating a
+ * negative one does not turn it positive ("不生气" is relief, not joy) — it
+ * becomes neutral. This is a deliberate, testable simplification.
+ */
+function flip(polarity) {
+    if (polarity === 'positive')
+        return 'negative';
+    return 'neutral';
+}
+export function analyzeAffect(text, options = {}) {
+    if (typeof text !== 'string')
+        throw new TypeError('text must be a string');
+    if (text.length > MAX_INPUT_CHARS)
+        throw new AffectBudgetError(text.length);
+    const lexicon = options.lexicon ?? SEED_LEXICON;
+    const prepared = prepare(lexicon);
+    const normalized = normalizeForAffect(text);
+    const tokens = tokenizeForAffect(normalized, prepared.dict, prepared.maxLen);
+    const hits = [];
+    for (let i = 0; i < tokens.length; i += 1) {
+        const entry = prepared.entries.get(tokens[i]);
+        if (!entry)
+            continue;
+        let negated = false;
+        for (let back = 1; back <= NEGATION_WINDOW && i - back >= 0; back += 1) {
+            const prev = tokens[i - back];
+            if (NEGATORS.includes(prev)) {
+                negated = true;
+                break;
+            }
+            if (prepared.entries.has(prev))
+                break;
+        }
+        let degree = 0;
+        for (let back = 1; back <= DEGREE_WINDOW && i - back >= 0; back += 1) {
+            const delta = prepared.degree.get(tokens[i - back]);
+            if (delta !== undefined) {
+                degree = delta;
+                break;
+            }
+        }
+        let intensity = clamp(entry.intensity + degree, 1, 9);
+        let polarity = entry.polarity;
+        if (negated) {
+            polarity = flip(polarity);
+            intensity = Math.max(1, Math.round(intensity * 0.8));
+        }
+        hits.push({
+            term: tokens[i],
+            category: entry.category,
+            intensity,
+            polarity,
+            negated,
+            position: i,
+        });
+    }
+    const byCategory = new Map();
+    let weighted = 0;
+    let total = 0;
+    for (const hit of hits) {
+        byCategory.set(hit.category, (byCategory.get(hit.category) ?? 0) + hit.intensity);
+        const sign = hit.polarity === 'positive' ? 1 : hit.polarity === 'negative' ? -1 : 0;
+        weighted += sign * hit.intensity;
+        total += hit.intensity;
+    }
+    let dominant = null;
+    let best = 0;
+    for (const [category, sum] of byCategory) {
+        if (sum > best) {
+            best = sum;
+            dominant = category;
+        }
+    }
+    const emphasis = (normalized.match(/[!?]{2,}|…{2,}/g) ?? []).length + (normalized.match(/(.)\1{2,}/gu) ?? []).length;
+    let intensity = hits.length > 0 ? Math.max(...hits.map((h) => h.intensity)) : 0;
+    if (hits.length > 0 && emphasis > 0)
+        intensity = clamp(intensity + Math.min(2, emphasis), 1, 9);
+    const fillers = tokens.filter((t) => prepared.fillers.has(t)).length;
+    const hedges = tokens.filter((t) => prepared.hedges.has(t)).length;
+    const vague = tokens.filter((t) => prepared.vague.has(t)).length;
+    const abstain = hits.length === 0 && ABSTAIN_TERMS.some((term) => normalized.includes(term));
+    // No hits means no judgement at all — length alone must never produce confidence.
+    let confidence = 0;
+    if (hits.length > 0) {
+        confidence =
+            0.4 * Math.min(1, hits.length / 2) +
+                0.2 * Math.min(1, tokens.length / 20) +
+                0.25 * (dominant ? 1 : 0) +
+                0.15 * (intensity / 9);
+        if (tokens.length <= 3)
+            confidence *= 0.5;
+    }
+    if (abstain)
+        confidence = Math.min(confidence, 0.5);
+    return {
+        analyzer: 'lexicon',
+        hits,
+        dominant,
+        intensity: Math.round(intensity * 10) / 10,
+        valence: total > 0 ? Math.round((weighted / total) * 100) / 100 : 0,
+        arousal: clamp(intensity / 9 + 0.1 * emphasis, 0, 1),
+        features: {
+            fillers,
+            hedges,
+            vague,
+            tokens: tokens.length,
+            density: tokens.length > 0 ? (tokens.length - fillers - hedges) / tokens.length : 1,
+        },
+        confidence: clamp(Math.round(confidence * 100) / 100, 0, 1),
+        abstain,
+    };
+}
+/** Lexicon analyzer as a port implementation (ADR 0015). */
+export const lexiconAnalyzer = {
+    id: 'lexicon',
+    analyze(text) {
+        return analyzeAffect(text);
+    },
+};
+/** Empty signal helper so callers do not reach for the shared constant by accident. */
+export function emptyAffect(analyzer = 'none') {
+    return { ...EMPTY_AFFECT, analyzer, features: { ...EMPTY_AFFECT.features } };
+}

package/dist/packages/core/src/affect/directives.js

@@ -0,0 +1,29 @@
+export const DIRECTIVE_CATALOG = [
+    { id: 'negative_high', text: '对方情绪偏负面：先承接，再给方案；不要急着讲道理' },
+    { id: 'positive_high', text: '对方情绪偏正面：回答可以更简短' },
+    { id: 'hedging', text: '对方表达里犹豫词偏多：给结论，少加限定语' },
+    { id: 'fragmented', text: '对方表达较碎片：先复述你的理解，再回答' },
+    { id: 'vague_terms', text: '对方用词较笼统：必要时确认具体所指' },
+];
+const per100 = (count, tokens) => (tokens > 0 ? (count * 100) / tokens : 0);
+/** Which catalog entries the signal justifies, in priority order, capped at `max`. */
+export function selectDirectives(signal, max = 2) {
+    if (signal.hits.length === 0 || signal.confidence < 0.6)
+        return [];
+    const triggered = new Set();
+    if (signal.valence <= -0.4 && signal.intensity >= 6)
+        triggered.add('negative_high');
+    if (signal.valence >= 0.4 && signal.intensity >= 6)
+        triggered.add('positive_high');
+    // Absolute minimums stop a single "这个" in a ten-token sentence from
+    // reading as "fragmented" — rate alone is misleading on short inputs.
+    if (signal.features.hedges >= 2 && per100(signal.features.hedges, signal.features.tokens) >= 6) {
+        triggered.add('hedging');
+    }
+    if (signal.features.fillers >= 3 && per100(signal.features.fillers, signal.features.tokens) >= 8) {
+        triggered.add('fragmented');
+    }
+    if (signal.features.vague >= 3)
+        triggered.add('vague_terms');
+    return DIRECTIVE_CATALOG.filter((d) => triggered.has(d.id)).slice(0, max);
+}

package/dist/packages/core/src/affect/index.js

@@ -0,0 +1,4 @@
+export { analyzeAffect, lexiconAnalyzer, emptyAffect, AffectBudgetError, normalizeForAffect, tokenizeForAffect, MAX_INPUT_CHARS, } from './analyze.js';
+export { SEED_LEXICON } from './seed-lexicon.js';
+export { validateLexicon, DEGREE_DELTA, NEGATORS, ABSTAIN_TERMS } from './lexicon.js';
+export { DIRECTIVE_CATALOG, selectDirectives } from './directives.js';

package/dist/packages/core/src/affect/lexicon.js

@@ -0,0 +1,62 @@
+/** Multiplicative-ish adjustment applied to a hit's intensity. */
+export const DEGREE_DELTA = {
+    weak: -1,
+    medium: 1,
+    strong: 2,
+    extreme: 3,
+};
+/** Words that flip polarity when they precede an emotion word. */
+export const NEGATORS = ['不', '没', '别', '无', '未', '不是', '没有', '不再', '不用', '不太'];
+/** Withdrawal phrases: no explicit emotion word, but the affect is negative and weak. */
+export const ABSTAIN_TERMS = ['行吧', '随便', '算了', '随你', '都行', '无所谓', '你定', '看着办', '再说吧'];
+const CATEGORIES = ['joy', 'anger', 'sadness', 'fear', 'disgust', 'surprise'];
+const POLARITIES = ['positive', 'negative', 'neutral'];
+/**
+ * Validate an externally supplied lexicon. Returns human-readable problems;
+ * an empty array means the lexicon is usable.
+ */
+export function validateLexicon(value) {
+    const errors = [];
+    if (typeof value !== 'object' || value === null)
+        return ['lexicon must be an object'];
+    const lex = value;
+    if (typeof lex.version !== 'string')
+        errors.push('version must be a string');
+    if (typeof lex.lang !== 'string')
+        errors.push('lang must be a string');
+    if (typeof lex.entries !== 'object' || lex.entries === null) {
+        errors.push('entries must be an object');
+    }
+    else {
+        for (const [word, entry] of Object.entries(lex.entries)) {
+            if (!word.trim())
+                errors.push('entries: empty word');
+            const e = entry;
+            if (!CATEGORIES.includes(e.category)) {
+                errors.push(`entries["${word}"].category is invalid`);
+            }
+            if (typeof e.intensity !== 'number' || e.intensity < 1 || e.intensity > 9) {
+                errors.push(`entries["${word}"].intensity must be 1..9`);
+            }
+            if (!POLARITIES.includes(e.polarity)) {
+                errors.push(`entries["${word}"].polarity is invalid`);
+            }
+        }
+    }
+    for (const key of ['fillers', 'hedges']) {
+        if (!Array.isArray(lex[key]))
+            errors.push(`${key} must be an array`);
+    }
+    if (typeof lex.vague !== 'object' || lex.vague === null)
+        errors.push('vague must be an object');
+    if (typeof lex.degree !== 'object' || lex.degree === null) {
+        errors.push('degree must be an object');
+    }
+    else {
+        for (const level of ['weak', 'medium', 'strong', 'extreme']) {
+            if (!Array.isArray(lex.degree[level]))
+                errors.push(`degree.${level} must be an array`);
+        }
+    }
+    return errors;
+}

package/dist/packages/core/src/affect/port.js

@@ -0,0 +1 @@
+export {};

package/dist/packages/core/src/affect/rules.js

@@ -0,0 +1,12 @@
+export const RULES = [
+    { id: 'R1', name: 'lexicon-hit', summary: '字典命中给出类别与基础强度' },
+    { id: 'R2', name: 'negation', summary: '前 3 个 token 内的否定词翻转极性/降强度' },
+    { id: 'R3', name: 'degree', summary: '前 2 个 token 内的程度词调整强度' },
+    { id: 'R4', name: 'punctuation', summary: '连续 !! ?? …… 提升 arousal' },
+    { id: 'R5', name: 'repetition', summary: '重复字符提升强调与强度' },
+    { id: 'R6', name: 'abstain', summary: '弃权短语标记为 abstain，置信度封顶 0.5，不注入' },
+    { id: 'R7', name: 'code-fence', summary: '代码围栏与 shell 行跳过分析' },
+    { id: 'R8', name: 'short-input', summary: '≤3 token 时置信度减半' },
+];
+export const RULE_BUDGET = 8;
+export const SEED_ENTRY_BUDGET = 120;

package/dist/packages/core/src/affect/seed-lexicon.js

@@ -0,0 +1,123 @@
+export const SEED_LEXICON = {
+    version: '1.0',
+    lang: 'zh',
+    entries: {
+        // joy
+        开心: { category: 'joy', intensity: 5, polarity: 'positive' },
+        高兴: { category: 'joy', intensity: 5, polarity: 'positive' },
+        快乐: { category: 'joy', intensity: 6, polarity: 'positive' },
+        愉快: { category: 'joy', intensity: 6, polarity: 'positive' },
+        欣喜: { category: 'joy', intensity: 7, polarity: 'positive' },
+        兴奋: { category: 'joy', intensity: 8, polarity: 'positive' },
+        雀跃: { category: 'joy', intensity: 8, polarity: 'positive' },
+        满足: { category: 'joy', intensity: 6, polarity: 'positive' },
+        欣慰: { category: 'joy', intensity: 6, polarity: 'positive' },
+        骄傲: { category: 'joy', intensity: 7, polarity: 'positive' },
+        自豪: { category: 'joy', intensity: 7, polarity: 'positive' },
+        踏实: { category: 'joy', intensity: 6, polarity: 'positive' },
+        安心: { category: 'joy', intensity: 5, polarity: 'positive' },
+        释然: { category: 'joy', intensity: 6, polarity: 'positive' },
+        轻松: { category: 'joy', intensity: 5, polarity: 'positive' },
+        幸福: { category: 'joy', intensity: 8, polarity: 'positive' },
+        喜欢: { category: 'joy', intensity: 6, polarity: 'positive' },
+        热爱: { category: 'joy', intensity: 8, polarity: 'positive' },
+        享受: { category: 'joy', intensity: 6, polarity: 'positive' },
+        舒畅: { category: 'joy', intensity: 6, polarity: 'positive' },
+        痛快: { category: 'joy', intensity: 7, polarity: 'positive' },
+        期待: { category: 'joy', intensity: 6, polarity: 'positive' },
+        // anger
+        生气: { category: 'anger', intensity: 5, polarity: 'negative' },
+        愤怒: { category: 'anger', intensity: 8, polarity: 'negative' },
+        恼火: { category: 'anger', intensity: 7, polarity: 'negative' },
+        烦躁: { category: 'anger', intensity: 6, polarity: 'negative' },
+        不爽: { category: 'anger', intensity: 5, polarity: 'negative' },
+        窝火: { category: 'anger', intensity: 7, polarity: 'negative' },
+        暴躁: { category: 'anger', intensity: 7, polarity: 'negative' },
+        火大: { category: 'anger', intensity: 7, polarity: 'negative' },
+        抓狂: { category: 'anger', intensity: 8, polarity: 'negative' },
+        崩溃: { category: 'anger', intensity: 9, polarity: 'negative' },
+        // sadness
+        难过: { category: 'sadness', intensity: 5, polarity: 'negative' },
+        伤心: { category: 'sadness', intensity: 6, polarity: 'negative' },
+        失落: { category: 'sadness', intensity: 6, polarity: 'negative' },
+        委屈: { category: 'sadness', intensity: 6, polarity: 'negative' },
+        沮丧: { category: 'sadness', intensity: 6, polarity: 'negative' },
+        低落: { category: 'sadness', intensity: 5, polarity: 'negative' },
+        心疼: { category: 'sadness', intensity: 7, polarity: 'negative' },
+        心累: { category: 'sadness', intensity: 7, polarity: 'negative' },
+        疲惫: { category: 'sadness', intensity: 6, polarity: 'negative' },
+        无力: { category: 'sadness', intensity: 6, polarity: 'negative' },
+        绝望: { category: 'sadness', intensity: 9, polarity: 'negative' },
+        郁闷: { category: 'sadness', intensity: 6, polarity: 'negative' },
+        烦闷: { category: 'sadness', intensity: 6, polarity: 'negative' },
+        压抑: { category: 'sadness', intensity: 7, polarity: 'negative' },
+        憋屈: { category: 'sadness', intensity: 7, polarity: 'negative' },
+        心酸: { category: 'sadness', intensity: 7, polarity: 'negative' },
+        落寞: { category: 'sadness', intensity: 7, polarity: 'negative' },
+        孤独: { category: 'sadness', intensity: 7, polarity: 'negative' },
+        // fear
+        害怕: { category: 'fear', intensity: 5, polarity: 'negative' },
+        恐惧: { category: 'fear', intensity: 8, polarity: 'negative' },
+        焦虑: { category: 'fear', intensity: 7, polarity: 'negative' },
+        紧张: { category: 'fear', intensity: 6, polarity: 'negative' },
+        担心: { category: 'fear', intensity: 6, polarity: 'negative' },
+        不安: { category: 'fear', intensity: 6, polarity: 'negative' },
+        慌张: { category: 'fear', intensity: 6, polarity: 'negative' },
+        忐忑: { category: 'fear', intensity: 6, polarity: 'negative' },
+        心慌: { category: 'fear', intensity: 6, polarity: 'negative' },
+        畏惧: { category: 'fear', intensity: 7, polarity: 'negative' },
+        惶恐: { category: 'fear', intensity: 7, polarity: 'negative' },
+        // disgust
+        讨厌: { category: 'disgust', intensity: 5, polarity: 'negative' },
+        厌恶: { category: 'disgust', intensity: 7, polarity: 'negative' },
+        反感: { category: 'disgust', intensity: 6, polarity: 'negative' },
+        恶心: { category: 'disgust', intensity: 7, polarity: 'negative' },
+        嫌弃: { category: 'disgust', intensity: 6, polarity: 'negative' },
+        鄙视: { category: 'disgust', intensity: 7, polarity: 'negative' },
+        受不了: { category: 'disgust', intensity: 6, polarity: 'negative' },
+        排斥: { category: 'disgust', intensity: 6, polarity: 'negative' },
+        // surprise
+        惊讶: { category: 'surprise', intensity: 6, polarity: 'neutral' },
+        震惊: { category: 'surprise', intensity: 8, polarity: 'neutral' },
+        吃惊: { category: 'surprise', intensity: 6, polarity: 'neutral' },
+        意外: { category: 'surprise', intensity: 5, polarity: 'neutral' },
+        诧异: { category: 'surprise', intensity: 6, polarity: 'neutral' },
+        目瞪口呆: { category: 'surprise', intensity: 8, polarity: 'neutral' },
+    },
+    fillers: [
+        '嗯', '啊', '呃', '额', '那个', '就是', '然后', '这个',
+        '对吧', '是吧', '反正', '基本上', '总之', '所以说', '其实', '说实话',
+    ],
+    hedges: [
+        '可能', '也许', '大概', '应该', '我觉得', '好像', '似乎', '或许',
+        '不一定', '差不多', '算是', '感觉', '可能吧', '不确定', '大概率', '有可能',
+    ],
+    vague: {
+        开心: ['欣喜', '雀跃', '兴奋'],
+        难过: ['心酸', '失落', '委屈'],
+        害怕: ['恐惧', '焦虑', '不安'],
+        生气: ['愤怒', '恼火', '气愤'],
+        不舒服: ['压抑', '烦躁', '疲惫'],
+        很好: ['出色', '精彩', '优秀'],
+        不好: ['糟糕', '恶劣', '拙劣'],
+        喜欢: ['热爱', '着迷', '钟爱'],
+        讨厌: ['厌恶', '反感', '排斥'],
+        问题: ['症结', '隐患', '瓶颈'],
+        东西: ['物件', '成果', '产出'],
+        方面: ['维度', '层面', '环节'],
+        觉得: ['认为', '判断', '确信'],
+        想: ['渴望', '期待', '向往'],
+        做: ['执行', '落实', '推进'],
+        看: ['观察', '审视'],
+        说: ['表达', '阐述'],
+        快: ['迅速', '飞速'],
+        大: ['巨大', '庞大'],
+        多: ['大量', '充裕'],
+    },
+    degree: {
+        weak: ['有点', '稍微', '略微', '些许', '稍稍'],
+        medium: ['比较', '挺', '相当', '蛮', '还算', '很'],
+        strong: ['非常', '特别', '十分', '格外', '越来越'],
+        extreme: ['极度', '极其', '无比', '超级', '太'],
+    },
+};

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

@@ -1,5 +1,10 @@
 import { rank } from './scoring.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. */
+export const AFFECT_BUDGET = 160;
+/** Only the most recent user turn counts; older samples are for evaluation, not injection. */
+export const AFFECT_WINDOW_MS = 30 * 60 * 1000;
 /** Emotion → concrete behavioural instruction. Values are -2..+2. */
 export function styleDirectives(emotion) {
     const out = [];
@@ -33,6 +38,21 @@ export function buildContext(store, request, now = Date.now()) {
     if (styles.length > 0) {
         sections.push(`<style>\n${styles.map((s) => `- ${s}`).join('\n')}\n</style>`);
     }
+    // Affect: newest sample only, and only when it is confident and recent enough.
+    let affectMeta;
+    const [latest] = 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 usedSoFar = sections.join('\n\n').length;
+            if (section.length <= AFFECT_BUDGET && usedSoFar + section.length + 2 <= maxChars) {
+                sections.push(section);
+                affectMeta = { confidence: latest.confidence, directives: directives.map((d) => d.id) };
+            }
+        }
+    }
     const candidates = store.query({ soulId: request.soulId, userId: request.userId });
     const ranked = rank(candidates, request.query ?? '', now);
     let chars = sections.join('\n\n').length;
@@ -55,5 +75,8 @@ export function buildContext(store, request, now = Date.now()) {
     const text = sections.join('\n\n');
     if (used.length > 0)
         store.touch(used, now);
-    return { text, used, dropped, chars: text.length };
+    const result = { text, used, dropped, chars: text.length };
+    if (affectMeta)
+        result.affect = affectMeta;
+    return result;
 }

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

@@ -5,23 +5,34 @@
  * Anything a host needs beyond this belongs in an adapter.
  */
 export * from './types.js';
-export { openSqlite } from './sqlite.js';
-export { buildContext, styleDirectives, DEFAULT_MAX_CHARS } from './context.js';
+export { openSqlite, SCHEMA_VERSION, AFFECT_RETENTION_MS, DbNewerThanBinaryError } from './sqlite.js';
+export { buildContext, styleDirectives, DEFAULT_MAX_CHARS, AFFECT_BUDGET, AFFECT_WINDOW_MS, } from './context.js';
 export { reflect, ruleExtract, nextEmotion } from './reflect.js';
 export { rank, scoreMemory, tokenize, relevance } from './scoring.js';
+export * from './affect/index.js';
+export { measureStyle } from './style/measure.js';
+export * from './storage/config.js';
+export * from './storage/merge.js';
+export * from './storage/steering.js';
+export * from './storage/transcript.js';
 import { buildContext } from './context.js';
 import { reflect, ruleExtract, nextEmotion } from './reflect.js';
 import { rank, tokenize } from './scoring.js';
+import { analyzeAffect, emptyAffect, lexiconAnalyzer } from './affect/analyze.js';
 export class Soul {
     store;
     soulId;
     userId;
     name;
+    deviceId;
+    analyzer;
     constructor(options) {
         this.store = options.store;
         this.soulId = options.soulId;
         this.userId = options.userId;
         this.name = options.name ?? '小灵';
+        this.deviceId = options.deviceId ?? 'dev_local';
+        this.analyzer = options.analyzer ?? lexiconAnalyzer;
         if (!this.store.identity(this.soulId)) {
             this.store.ensureSoul({
                 soulId: this.soulId,
@@ -46,9 +57,19 @@ export class Soul {
         this.store.touch(ranked.map((r) => r.memory.id));
         return ranked;
     }
-    /** Verb 2: after each turn. Cheap and synchronous by design. */
-    observe(turn) {
+    /** Pure analysis, no storage. Async because the analyzer may call a model. */
+    async analyze(text) {
+        return this.analyzeTurn(text);
+    }
+    /**
+     * Verb 2: after each turn.
+     *
+     * The analyzer may be async (a model); any failure degrades to the lexicon
+     * analyzer. Emotion is computed from the turn only — never from affect.
+     */
+    async observe(turn) {
         const now = turn.at ?? Date.now();
+        const affect = turn.role === 'user' ? await this.analyzeTurn(turn.content) : emptyAffect();
         const drafts = ruleExtract([turn]);
         for (const draft of drafts) {
             this.store.put({
@@ -62,14 +83,23 @@ export class Soul {
                 recallCount: 0,
                 status: 'active',
                 visibility: 'private',
-                keywords: [],
+                keywords: tokenize(draft.content),
                 createdAt: now,
+                updatedAt: now,
                 validFrom: now,
             });
         }
+        if (turn.role === 'user') {
+            try {
+                this.store.saveAffect(this.soulId, this.userId, affect, now, this.deviceId);
+            }
+            catch {
+                // Affect is an enhancement; storage trouble must not break the session.
+            }
+        }
         const emotion = nextEmotion(this.store.emotion(this.soulId, this.userId), [turn]);
-        this.store.saveEmotion(this.soulId, this.userId, emotion);
-        return { written: drafts.length, emotion };
+        this.store.saveEmotion(this.soulId, this.userId, emotion, now);
+        return { written: drafts.length, emotion, affect };
     }
     /**
      * Explicit form of `observe`: the host decided this is worth keeping.
@@ -91,6 +121,7 @@ export class Soul {
             visibility: options.visibility ?? 'private',
             keywords: tokenize(content),
             createdAt: now,
+            updatedAt: now,
             validFrom: now,
         });
         return id;
@@ -106,4 +137,18 @@ export class Soul {
             emotion: this.store.emotion(this.soulId, this.userId),
         };
     }
+    async analyzeTurn(content) {
+        try {
+            const signal = await this.analyzer.analyze(content);
+            return { ...signal, analyzer: this.analyzer.id };
+        }
+        catch {
+            try {
+                return analyzeAffect(content);
+            }
+            catch {
+                return emptyAffect();
+            }
+        }
+    }
 }