soulbridge 0.0.2 → 0.0.4

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,32 @@
  * 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';
 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 +55,24 @@ 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: useful for the CLI and for tests. */
+    analyze(text) {
+        try {
+            return this.analyzer.analyze(text);
+        }
+        catch {
+            return analyzeAffect(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 +86,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 +124,7 @@ export class Soul {
             visibility: options.visibility ?? 'private',
             keywords: tokenize(content),
             createdAt: now,
+            updatedAt: now,
             validFrom: now,
         });
         return id;
@@ -106,4 +140,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();
+            }
+        }
+    }
 }

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

@@ -1,9 +1,27 @@
 /**
  * SQLite implementation of SoulStore, using Node's built-in `node:sqlite`.
  * Zero npm dependencies on purpose: `npx soulbridge` must work offline.
+ *
+ * Schema versioning (ADR 0020): every open checks `schema_meta.schema_version`.
+ * Older databases are upgraded in place after a one-off backup; a database
+ * from a newer binary is refused instead of being silently written.
  */
+import { copyFileSync, existsSync } from 'node:fs';
 import { DatabaseSync } from 'node:sqlite';
 import { DEFAULT_EMOTION } from './types.js';
+export const SCHEMA_VERSION = 2;
+export const AFFECT_RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
+const BUSY_TIMEOUT_MS = 5000;
+const WRITE_ATTEMPTS = 3;
+export class DbNewerThanBinaryError extends Error {
+    code = 'DB_NEWER_THAN_BINARY';
+    dbVersion;
+    constructor(dbVersion) {
+        super(`database schema v${dbVersion} is newer than this binary (v${SCHEMA_VERSION})`);
+        this.name = 'DbNewerThanBinaryError';
+        this.dbVersion = dbVersion;
+    }
+}
 const SCHEMA = `
 CREATE TABLE IF NOT EXISTS schema_meta (k TEXT PRIMARY KEY, v TEXT NOT NULL);
 CREATE TABLE IF NOT EXISTS souls (
@@ -43,47 +61,111 @@ CREATE TABLE IF NOT EXISTS memories (
 );
 CREATE INDEX IF NOT EXISTS idx_memories_scope ON memories(soul_id, user_id, status);
 CREATE INDEX IF NOT EXISTS idx_memories_created ON memories(soul_id, created_at DESC);
+CREATE TABLE IF NOT EXISTS affect_samples (
+  soul_id    TEXT NOT NULL,
+  user_id    TEXT NOT NULL,
+  at         INTEGER NOT NULL,
+  analyzer   TEXT NOT NULL,
+  dominant   TEXT,
+  intensity  REAL NOT NULL,
+  valence    REAL NOT NULL,
+  arousal    REAL NOT NULL,
+  confidence REAL NOT NULL,
+  payload    TEXT NOT NULL,
+  device_id  TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_affect ON affect_samples(soul_id, user_id, at DESC);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_affect_unique ON affect_samples(soul_id, user_id, at, analyzer);
 `;
-function toMemory(row) {
-    return {
-        id: String(row.id),
-        soulId: String(row.soul_id),
-        userId: String(row.user_id),
-        type: row.type,
-        content: String(row.content),
-        importance: Number(row.importance),
-        vividness: Number(row.vividness),
-        recallCount: Number(row.recall_count),
-        status: row.status,
-        visibility: row.visibility,
-        keywords: JSON.parse(String(row.keywords ?? '[]')),
-        createdAt: Number(row.created_at),
-        lastRecalledAt: row.last_recalled_at == null ? undefined : Number(row.last_recalled_at),
-        validFrom: row.valid_from == null ? undefined : Number(row.valid_from),
-        validUntil: row.valid_until == null ? undefined : Number(row.valid_until),
-        supersededBy: row.superseded_by == null ? undefined : String(row.superseded_by),
-    };
+const sleepSync = (ms) => {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+};
+function withRetry(fn) {
+    let lastError;
+    for (let attempt = 0; attempt < WRITE_ATTEMPTS; attempt += 1) {
+        try {
+            return fn();
+        }
+        catch (error) {
+            lastError = error;
+            const message = error instanceof Error ? error.message : String(error);
+            if (!/locked|busy/i.test(message))
+                throw error;
+            if (attempt < WRITE_ATTEMPTS - 1)
+                sleepSync(50 * 3 ** attempt);
+        }
+    }
+    throw lastError;
+}
+function readVersion(db) {
+    const row = db.prepare("SELECT v FROM schema_meta WHERE k = 'schema_version'").get();
+    if (!row)
+        return 1;
+    const version = Number(row.v);
+    return Number.isFinite(version) ? version : 1;
+}
+function setVersion(db, version) {
+    db.prepare('INSERT OR REPLACE INTO schema_meta (k, v) VALUES (?, ?)').run('schema_version', String(version));
+}
+function columnExists(db, table, column) {
+    const rows = db.prepare(`PRAGMA table_info(${table})`).all();
+    return rows.some((row) => String(row.name) === column);
+}
+function ensureColumn(db, table, column, ddl) {
+    if (!columnExists(db, table, column))
+        db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${ddl}`);
+}
+/** v1 → v2: sync-ready columns (updated_at / deleted_at / device_id). */
+function upgradeToV2(db) {
+    ensureColumn(db, 'memories', 'updated_at', 'INTEGER');
+    ensureColumn(db, 'memories', 'deleted_at', 'INTEGER');
+    ensureColumn(db, 'emotions', 'updated_at', 'INTEGER');
+    db.exec('UPDATE memories SET updated_at = created_at WHERE updated_at IS NULL');
+    db.exec('UPDATE emotions SET updated_at = 0 WHERE updated_at IS NULL');
+}
+function backupBeforeUpgrade(file, from) {
+    if (file === ':memory:' || !existsSync(file))
+        return;
+    const backup = `${file}.bak-v${from}`;
+    if (!existsSync(backup))
+        copyFileSync(file, backup);
 }
 export function openSqlite(file) {
     const db = new DatabaseSync(file);
     db.exec('PRAGMA journal_mode = WAL;');
+    db.exec(`PRAGMA busy_timeout = ${BUSY_TIMEOUT_MS};`);
     db.exec(SCHEMA);
-    db.prepare('INSERT OR REPLACE INTO schema_meta (k, v) VALUES (?, ?)').run('version', '1');
+    const version = readVersion(db);
+    if (version > SCHEMA_VERSION) {
+        db.close();
+        throw new DbNewerThanBinaryError(version);
+    }
+    if (version < SCHEMA_VERSION) {
+        backupBeforeUpgrade(file, version);
+        if (version < 2)
+            upgradeToV2(db);
+        setVersion(db, SCHEMA_VERSION);
+    }
     const stmtPut = db.prepare(`
     INSERT INTO memories (
       id, soul_id, user_id, type, content, importance, vividness, recall_count,
-      status, visibility, keywords, created_at, last_recalled_at, valid_from, valid_until, superseded_by
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      status, visibility, keywords, created_at, last_recalled_at, valid_from, valid_until,
+      superseded_by, updated_at, deleted_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     ON CONFLICT(id) DO UPDATE SET
       content = excluded.content,
       importance = excluded.importance,
       vividness = excluded.vividness,
       status = excluded.status,
-      superseded_by = excluded.superseded_by
+      superseded_by = excluded.superseded_by,
+      updated_at = excluded.updated_at,
+      deleted_at = excluded.deleted_at
   `);
     return {
         ensureSoul(identity) {
-            db.prepare('INSERT INTO souls (soul_id, name, creator, created_at) VALUES (?, ?, ?, ?) ON CONFLICT(soul_id) DO NOTHING').run(identity.soulId, identity.name, identity.creator ?? null, identity.createdAt);
+            withRetry(() => db
+                .prepare('INSERT INTO souls (soul_id, name, creator, created_at) VALUES (?, ?, ?, ?) ON CONFLICT(soul_id) DO NOTHING')
+                .run(identity.soulId, identity.name, identity.creator ?? null, identity.createdAt));
         },
         identity(soulId) {
             const row = db.prepare('SELECT * FROM souls WHERE soul_id = ?').get(soulId);
@@ -111,36 +193,71 @@ export function openSqlite(file) {
                 contentment: Number(row.contentment),
             };
         },
-        saveEmotion(soulId, userId, emotion) {
-            db.prepare(`INSERT INTO emotions (soul_id, user_id, passion, bond, tension, self_regard, curiosity, contentment)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-         ON CONFLICT(soul_id, user_id) DO UPDATE SET
-           passion = excluded.passion, bond = excluded.bond, tension = excluded.tension,
-           self_regard = excluded.self_regard, curiosity = excluded.curiosity,
-           contentment = excluded.contentment`).run(soulId, userId, emotion.passion, emotion.bond, emotion.tension, emotion.selfRegard, emotion.curiosity, emotion.contentment);
+        saveEmotion(soulId, userId, emotion, now = Date.now()) {
+            withRetry(() => db
+                .prepare(`INSERT INTO emotions (soul_id, user_id, passion, bond, tension, self_regard, curiosity, contentment, updated_at)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+             ON CONFLICT(soul_id, user_id) DO UPDATE SET
+               passion = excluded.passion, bond = excluded.bond, tension = excluded.tension,
+               self_regard = excluded.self_regard, curiosity = excluded.curiosity,
+               contentment = excluded.contentment, updated_at = excluded.updated_at`)
+                .run(soulId, userId, emotion.passion, emotion.bond, emotion.tension, emotion.selfRegard, emotion.curiosity, emotion.contentment, now));
         },
         put(memory) {
-            stmtPut.run(memory.id, memory.soulId, memory.userId, memory.type, memory.content, memory.importance, memory.vividness, memory.recallCount, memory.status, memory.visibility, JSON.stringify(memory.keywords), memory.createdAt, memory.lastRecalledAt ?? null, memory.validFrom ?? null, memory.validUntil ?? null, memory.supersededBy ?? null);
+            withRetry(() => stmtPut.run(memory.id, memory.soulId, memory.userId, memory.type, memory.content, memory.importance, memory.vividness, memory.recallCount, memory.status, memory.visibility, JSON.stringify(memory.keywords), memory.createdAt, memory.lastRecalledAt ?? null, memory.validFrom ?? null, memory.validUntil ?? null, memory.supersededBy ?? null, memory.updatedAt ?? memory.createdAt, memory.deletedAt ?? null));
         },
         query(spec) {
             const statuses = spec.status ?? ['active'];
             const placeholders = statuses.map(() => '?').join(', ');
             const rows = db
                 .prepare(`SELECT * FROM memories
-           WHERE soul_id = ? AND (user_id = ? OR visibility = 'shared') AND status IN (${placeholders})
+           WHERE soul_id = ? AND (user_id = ? OR visibility = 'shared')
+             AND status IN (${placeholders}) AND deleted_at IS NULL
            ORDER BY created_at DESC LIMIT ?`)
                 .all(spec.soulId, spec.userId, ...statuses, spec.limit ?? 500);
-            const memories = rows.map(toMemory);
+            const memories = rows.map(rowToMemory);
             return spec.types ? memories.filter((m) => spec.types.includes(m.type)) : memories;
         },
         touch(ids, now = Date.now()) {
             const stmt = db.prepare('UPDATE memories SET recall_count = recall_count + 1, last_recalled_at = ? WHERE id = ?');
-            for (const id of ids)
-                stmt.run(now, id);
+            withRetry(() => {
+                for (const id of ids)
+                    stmt.run(now, id);
+            });
+        },
+        saveAffect(soulId, userId, signal, at, deviceId) {
+            withRetry(() => {
+                db.prepare(`INSERT OR IGNORE INTO affect_samples
+             (soul_id, user_id, at, analyzer, dominant, intensity, valence, arousal, confidence, payload, device_id)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(soulId, userId, at, signal.analyzer, signal.dominant ?? null, signal.intensity, signal.valence, signal.arousal, signal.confidence, JSON.stringify({ ...signal, at }), deviceId ?? null);
+                db.prepare('DELETE FROM affect_samples WHERE at < ?').run(at - AFFECT_RETENTION_MS);
+            });
+        },
+        recentAffect(soulId, userId, sinceMs) {
+            const rows = db
+                .prepare(`SELECT payload FROM affect_samples
+           WHERE soul_id = ? AND user_id = ? AND at >= ?
+           ORDER BY at DESC LIMIT 1000`)
+                .all(soulId, userId, sinceMs);
+            return rows
+                .map((row) => {
+                try {
+                    return JSON.parse(String(row.payload));
+                }
+                catch {
+                    return null;
+                }
+            })
+                .filter((signal) => signal !== null);
+        },
+        purgeAffect(beforeMs) {
+            const result = withRetry(() => db.prepare('DELETE FROM affect_samples WHERE at < ?').run(beforeMs));
+            return Number(result.changes ?? 0);
         },
         count(soulId, userId) {
             const row = db
-                .prepare("SELECT COUNT(*) AS n FROM memories WHERE soul_id = ? AND (user_id = ? OR visibility = 'shared')")
+                .prepare(`SELECT COUNT(*) AS n FROM memories
+           WHERE soul_id = ? AND (user_id = ? OR visibility = 'shared') AND deleted_at IS NULL`)
                 .get(soulId, userId);
             return Number(row.n);
         },
@@ -149,3 +266,25 @@ export function openSqlite(file) {
         },
     };
 }
+function rowToMemory(row) {
+    return {
+        id: String(row.id),
+        soulId: String(row.soul_id),
+        userId: String(row.user_id),
+        type: row.type,
+        content: String(row.content),
+        importance: Number(row.importance),
+        vividness: Number(row.vividness),
+        recallCount: Number(row.recall_count),
+        status: row.status,
+        visibility: row.visibility,
+        keywords: JSON.parse(String(row.keywords ?? '[]')),
+        createdAt: Number(row.created_at),
+        lastRecalledAt: row.last_recalled_at == null ? undefined : Number(row.last_recalled_at),
+        validFrom: row.valid_from == null ? undefined : Number(row.valid_from),
+        validUntil: row.valid_until == null ? undefined : Number(row.valid_until),
+        supersededBy: row.superseded_by == null ? undefined : String(row.superseded_by),
+        updatedAt: row.updated_at == null ? undefined : Number(row.updated_at),
+        deletedAt: row.deleted_at == null ? undefined : Number(row.deleted_at),
+    };
+}