soulbridge 0.0.1 → 0.0.2

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

@@ -0,0 +1,151 @@
+/**
+ * SQLite implementation of SoulStore, using Node's built-in `node:sqlite`.
+ * Zero npm dependencies on purpose: `npx soulbridge` must work offline.
+ */
+import { DatabaseSync } from 'node:sqlite';
+import { DEFAULT_EMOTION } from './types.js';
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS schema_meta (k TEXT PRIMARY KEY, v TEXT NOT NULL);
+CREATE TABLE IF NOT EXISTS souls (
+  soul_id    TEXT PRIMARY KEY,
+  name       TEXT NOT NULL,
+  creator    TEXT,
+  created_at INTEGER NOT NULL
+);
+CREATE TABLE IF NOT EXISTS emotions (
+  soul_id      TEXT NOT NULL,
+  user_id      TEXT NOT NULL,
+  passion      REAL NOT NULL,
+  bond         REAL NOT NULL,
+  tension      REAL NOT NULL,
+  self_regard  REAL NOT NULL,
+  curiosity    REAL NOT NULL,
+  contentment  REAL NOT NULL,
+  PRIMARY KEY (soul_id, user_id)
+);
+CREATE TABLE IF NOT EXISTS memories (
+  id               TEXT PRIMARY KEY,
+  soul_id          TEXT NOT NULL,
+  user_id          TEXT NOT NULL,
+  type             TEXT NOT NULL,
+  content          TEXT NOT NULL,
+  importance       REAL NOT NULL,
+  vividness        REAL NOT NULL,
+  recall_count     INTEGER NOT NULL DEFAULT 0,
+  status           TEXT NOT NULL,
+  visibility       TEXT NOT NULL,
+  keywords         TEXT NOT NULL DEFAULT '[]',
+  created_at       INTEGER NOT NULL,
+  last_recalled_at INTEGER,
+  valid_from       INTEGER,
+  valid_until      INTEGER,
+  superseded_by    TEXT
+);
+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);
+`;
+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),
+    };
+}
+export function openSqlite(file) {
+    const db = new DatabaseSync(file);
+    db.exec('PRAGMA journal_mode = WAL;');
+    db.exec(SCHEMA);
+    db.prepare('INSERT OR REPLACE INTO schema_meta (k, v) VALUES (?, ?)').run('version', '1');
+    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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(id) DO UPDATE SET
+      content = excluded.content,
+      importance = excluded.importance,
+      vividness = excluded.vividness,
+      status = excluded.status,
+      superseded_by = excluded.superseded_by
+  `);
+    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);
+        },
+        identity(soulId) {
+            const row = db.prepare('SELECT * FROM souls WHERE soul_id = ?').get(soulId);
+            if (!row)
+                return null;
+            return {
+                soulId: String(row.soul_id),
+                name: String(row.name),
+                creator: row.creator == null ? undefined : String(row.creator),
+                createdAt: Number(row.created_at),
+            };
+        },
+        emotion(soulId, userId) {
+            const row = db
+                .prepare('SELECT * FROM emotions WHERE soul_id = ? AND user_id = ?')
+                .get(soulId, userId);
+            if (!row)
+                return { ...DEFAULT_EMOTION };
+            return {
+                passion: Number(row.passion),
+                bond: Number(row.bond),
+                tension: Number(row.tension),
+                selfRegard: Number(row.self_regard),
+                curiosity: Number(row.curiosity),
+                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);
+        },
+        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);
+        },
+        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})
+           ORDER BY created_at DESC LIMIT ?`)
+                .all(spec.soulId, spec.userId, ...statuses, spec.limit ?? 500);
+            const memories = rows.map(toMemory);
+            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);
+        },
+        count(soulId, userId) {
+            const row = db
+                .prepare("SELECT COUNT(*) AS n FROM memories WHERE soul_id = ? AND (user_id = ? OR visibility = 'shared')")
+                .get(soulId, userId);
+            return Number(row.n);
+        },
+        close() {
+            db.close();
+        },
+    };
+}

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

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

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

@@ -0,0 +1,14 @@
+/**
+ * Domain model. Pure types + constants, no logic, no dependencies.
+ *
+ * Rule: if a field only makes sense for one storage engine, it does not belong here.
+ * (No `vector`, no `embeddingId`, no `rowid`.)
+ */
+export const DEFAULT_EMOTION = {
+    passion: 0.3,
+    bond: 0.3,
+    tension: 0.1,
+    selfRegard: 0.3,
+    curiosity: 0.3,
+    contentment: 0.3,
+};

package/package.json

@@ -1,15 +1,14 @@
 {
   "name": "soulbridge",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "A personality layer for any agent: continuity, forgetting, and growth across tools.",
   "license": "Apache-2.0",
   "type": "module",
   "bin": {
-    "soulbridge": "packages/cli/src/cli.ts"
+    "soulbridge": "dist/packages/cli/src/cli.js"
   },
   "files": [
-    "packages/core/src",
-    "packages/cli/src",
+    "dist",
     "README.md",
     "LICENSE",
     "NOTICE"
@@ -37,9 +36,14 @@
     "claude-code"
   ],
   "scripts": {
+    "build": "tsc -p tsconfig.build.json",
     "test": "node --test \"packages/core/test/*.test.ts\"",
     "demo": "node packages/cli/src/cli.ts demo",
     "typecheck": "tsc --noEmit",
-    "prepublishOnly": "npm test"
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "devDependencies": {
+    "@types/node": "^26.6.5",
+    "typescript": "^7.0.2"
   }
 }

package/packages/cli/src/cli.ts

@@ -1,220 +0,0 @@
-#!/usr/bin/env node
-/**
- * Minimal CLI. No framework, no dependencies.
- *
- *   soulbridge init
- *   soulbridge remember "以后提交前先跑 make check" --type strategy --importance 8
- *   soulbridge context --query "提交前要做什么"
- *   soulbridge recall "测试"
- *   soulbridge reflect --text "..."      (or --file transcript.txt)
- *   soulbridge stats
- *   soulbridge demo
- */
-import { mkdirSync, readFileSync, rmSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
-import type { MemoryType, Turn } from '../../core/src/index.ts';
-import type { Soul as SoulType } from '../../core/src/index.ts';
-
-// node:sqlite prints an ExperimentalWarning the moment it loads. Replace the default
-// printer with a filter: the CLI's own output stays clean, other warnings still show.
-// Must run before the dynamic import below, which is why that import is dynamic.
-process.removeAllListeners('warning');
-process.on('warning', (warning) => {
-  if (warning.message.includes('SQLite is an experimental feature')) return;
-  process.stderr.write(`${warning.name}: ${warning.message}\n`);
-});
-
-const { openSqlite, Soul } = await import('../../core/src/index.ts');
-
-interface Parsed {
-  cmd: string;
-  positional: string[];
-  flags: Record<string, string>;
-}
-
-function parse(argv: string[]): Parsed {
-  const [cmd = 'help', ...rest] = argv;
-  const positional: string[] = [];
-  const flags: Record<string, string> = {};
-
-  for (let i = 0; i < rest.length; i += 1) {
-    const arg = rest[i];
-    if (!arg.startsWith('--')) {
-      positional.push(arg);
-      continue;
-    }
-    const key = arg.slice(2);
-    const next = rest[i + 1];
-    if (next !== undefined && !next.startsWith('--')) {
-      flags[key] = next;
-      i += 1;
-    } else {
-      flags[key] = 'true';
-    }
-  }
-
-  return { cmd, positional, flags };
-}
-
-function dbFile(): string {
-  const file = process.env.SOULBRIDGE_DB ?? resolve(process.cwd(), '.soulbridge', 'soul.db');
-  mkdirSync(dirname(file), { recursive: true });
-  return file;
-}
-
-function open(file?: string, createdAt?: number): { soul: SoulType; file: string } {
-  const target = file ?? dbFile();
-  const store = openSqlite(target);
-  const soul = new Soul({
-    store,
-    soulId: process.env.SOULBRIDGE_SOUL ?? 'xiaoling',
-    userId: process.env.SOULBRIDGE_USER ?? 'local',
-    name: process.env.SOULBRIDGE_NAME ?? '小灵',
-    createdAt,
-  });
-  return { soul, file: target };
-}
-
-function out(value: unknown): void {
-  process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
-}
-
-async function demo(): Promise<void> {
-  const dir = resolve(process.cwd(), '.soulbridge');
-  mkdirSync(dir, { recursive: true });
-  const file = resolve(dir, 'demo.db');
-  for (const suffix of ['', '-wal', '-shm']) rmSync(`${file}${suffix}`, { force: true });
-
-  // Backdate the birthday so the demo shows a relationship that has time in it.
-  const seed = openSqlite(file);
-  seed.ensureSoul({ soulId: 'xiaoling', name: '小灵', createdAt: Date.now() - 3 * 86_400_000 });
-  seed.close();
-
-  const soul = new Soul({ store: openSqlite(file), soulId: 'xiaoling', userId: 'demo', name: '小灵' });
-
-  process.stdout.write('=== 第 1 次会话（刚认识，还没有记忆）===\n');
-  process.stdout.write(`${soul.context().text}\n\n`);
-
-  process.stdout.write('=== 会话结束，反思 ===\n');
-  const result = await soul.reflect([
-    { role: 'user', content: '以后提交前先跑 make check，别等 CI 挂了再修' },
-    { role: 'assistant', content: '好，记住了。' },
-    { role: 'user', content: '我喜欢简洁的回答，不要铺垫' },
-    { role: 'user', content: '不对，这个方案是错的' },
-  ]);
-  process.stdout.write(`写入 ${result.memories} 条记忆，情绪 ${JSON.stringify(result.emotion)}\n\n`);
-
-  process.stdout.write('=== 第 2 次会话：开场（无查询，按重要度注入全部）===\n');
-  process.stdout.write(`${soul.context().text}\n\n`);
-
-  process.stdout.write('=== 同一会话中，用户问「提交前要做什么」（有查询，只注入相关的）===\n');
-  process.stdout.write(`${soul.context({ query: '提交前要做什么' }).text}\n\n`);
-
-  process.stdout.write('=== stats ===\n');
-  out(soul.stats());
-  process.stdout.write(`\n数据库：${file}\n`);
-}
-
-async function main(): Promise<void> {
-  const { cmd, positional, flags } = parse(process.argv.slice(2));
-
-  switch (cmd) {
-    case 'init': {
-      const { soul, file } = open();
-      out({ ok: true, db: file, ...soul.stats() });
-      return;
-    }
-
-    case 'remember': {
-      const content = positional.join(' ').trim();
-      if (!content) throw new Error('usage: soulbridge remember "内容" [--type T] [--importance N]');
-      const { soul } = open();
-      const id = soul.remember(content, {
-        type: (flags.type as MemoryType | undefined) ?? 'fact',
-        importance: flags.importance ? Number(flags.importance) : undefined,
-      });
-      out({ ok: true, id });
-      return;
-    }
-
-    case 'context': {
-      const { soul } = open();
-      const result = soul.context({
-        query: flags.query,
-        maxChars: flags.max ? Number(flags.max) : undefined,
-      });
-      out(result);
-      return;
-    }
-
-    case 'recall': {
-      const query = positional.join(' ').trim();
-      if (!query) throw new Error('usage: soulbridge recall "查询" [--limit N]');
-      const { soul } = open();
-      const hits = soul.recall(query, flags.limit ? Number(flags.limit) : 5);
-      out(hits.map((h) => ({ id: h.memory.id, type: h.memory.type, content: h.memory.content, score: Number(h.score.toFixed(3)) })));
-      return;
-    }
-
-    case 'observe': {
-      const content = positional.join(' ').trim();
-      if (!content) throw new Error('usage: soulbridge observe "一句话"');
-      const { soul } = open();
-      out(soul.observe({ role: 'user', content }));
-      return;
-    }
-
-    case 'reflect': {
-      const text = flags.file ? readFileSync(flags.file, 'utf8') : (flags.text ?? '');
-      if (!text.trim()) throw new Error('usage: soulbridge reflect --text "..." | --file transcript.txt');
-      const turns: Turn[] = text
-        .split(/\r?\n/)
-        .map((line) => line.trim())
-        .filter(Boolean)
-        .map((line) => {
-          const match = line.match(/^(user|assistant|助手|用户)\s*[:：]\s*(.*)$/i);
-          if (!match) return { role: 'user', content: line } as Turn;
-          const role = /^(assistant|助手)$/i.test(match[1]) ? 'assistant' : 'user';
-          return { role, content: match[2] } as Turn;
-        });
-      const { soul } = open();
-      out(await soul.reflect(turns));
-      return;
-    }
-
-    case 'stats': {
-      const { soul, file } = open();
-      out({ db: file, ...soul.stats() });
-      return;
-    }
-
-    case 'demo':
-      await demo();
-      return;
-
-    default:
-      process.stdout.write(
-        [
-          'soulbridge — 给任何 agent 装上一个人格层',
-          '',
-          'commands:',
-          '  init                            初始化数据库',
-          '  remember <text> [--type T]      显式记住一条',
-          '  context [--query Q] [--max N]   生成注入文本',
-          '  recall <q> [--limit N]          召回',
-          '  observe <text>                  观察一轮',
-          '  reflect --text|--file           会话反思',
-          '  stats                           看状态',
-          '  demo                            端到端演示（无需模型）',
-          '',
-          'env: SOULBRIDGE_DB, SOULBRIDGE_SOUL, SOULBRIDGE_USER, SOULBRIDGE_NAME',
-          '',
-        ].join('\n'),
-      );
-  }
-}
-
-main().catch((error: unknown) => {
-  process.stderr.write(`soulbridge: ${error instanceof Error ? error.message : String(error)}\n`);
-  process.exitCode = 1;
-});

package/packages/core/src/context.ts

@@ -1,77 +0,0 @@
-/**
- * Context assembly: turn structured state into the text a host agent injects.
- *
- * Two rules:
- *  - never cut a sentence in half (drop whole memories instead)
- *  - every injected memory id is reported in `used`, so injection is auditable
- */
-import type { ContextRequest, ContextResult, Emotion } from './types.ts';
-import type { SoulStore } from './store.ts';
-import { rank } from './scoring.ts';
-
-export const DEFAULT_MAX_CHARS = 1200;
-
-/** Emotion → concrete behavioural instruction. Values are -2..+2. */
-export function styleDirectives(emotion: Emotion): string[] {
-  const out: string[] = [];
-  if (emotion.tension > 1.0) out.push('回答前先确认理解，避免草率结论');
-  if (emotion.selfRegard < -0.5) out.push('对自己的输出多检查一遍');
-  if (emotion.curiosity > 0.5) out.push('可以主动提问，探索延伸');
-  if (emotion.bond > 0.8) out.push('像朋友一样聊天，少一点客套');
-  if (emotion.contentment > 1.2) out.push('不要过度确认，直接给结论');
-  return out;
-}
-
-function timeTogether(createdAt: number, now: number): string {
-  const days = Math.floor((now - createdAt) / 86_400_000);
-  if (days <= 0) return '今天是第一次见面';
-  return `你已经和用户相处了 ${days} 天`;
-}
-
-export function buildContext(
-  store: SoulStore,
-  request: ContextRequest,
-  now: number = Date.now(),
-): ContextResult {
-  const identity = store.identity(request.soulId);
-  const name = identity?.name ?? request.soulId;
-  const emotion = store.emotion(request.soulId, request.userId);
-  const maxChars = request.maxChars ?? DEFAULT_MAX_CHARS;
-
-  const sections: string[] = [];
-
-  const since = identity ? timeTogether(identity.createdAt, now) : '你刚开始认识这个用户';
-  sections.push(`<soul name="${name}">\n你是${name}，一个持续成长的伙伴。${since}。\n</soul>`);
-
-  const styles = styleDirectives(emotion);
-  if (styles.length > 0) {
-    sections.push(`<style>\n${styles.map((s) => `- ${s}`).join('\n')}\n</style>`);
-  }
-
-  const candidates = store.query({ soulId: request.soulId, userId: request.userId });
-  const ranked = rank(candidates, request.query ?? '', now);
-
-  let chars = sections.join('\n\n').length;
-  let dropped = 0;
-  const lines: string[] = [];
-  const used: string[] = [];
-
-  for (const { memory } of ranked) {
-    const line = `- [${memory.type}] ${memory.content}`;
-    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);
-    chars += cost;
-  }
-
-  if (lines.length > 0) sections.push(`<memories>\n${lines.join('\n')}\n</memories>`);
-
-  const text = sections.join('\n\n');
-  if (used.length > 0) store.touch(used, now);
-
-  return { text, used, dropped, chars: text.length };
-}

package/packages/core/src/index.ts

@@ -1,146 +0,0 @@
-/**
- * soulbridge core — the personality layer.
- *
- * Public surface is deliberately tiny: a facade (`Soul`) over four verbs.
- * Anything a host needs beyond this belongs in an adapter.
- */
-export * from './types.ts';
-export type { SoulStore } from './store.ts';
-export { openSqlite } from './sqlite.ts';
-export { buildContext, styleDirectives, DEFAULT_MAX_CHARS } from './context.ts';
-export { reflect, ruleExtract, nextEmotion } from './reflect.ts';
-export { rank, scoreMemory, tokenize, relevance } from './scoring.ts';
-
-import type {
-  ContextRequest,
-  ContextResult,
-  Emotion,
-  LlmFn,
-  MemoryType,
-  ObserveResult,
-  ReflectResult,
-  ScoredMemory,
-  Turn,
-  Visibility,
-} from './types.ts';
-import type { SoulStore } from './store.ts';
-import { buildContext } from './context.ts';
-import { reflect, ruleExtract, nextEmotion } from './reflect.ts';
-import { rank, tokenize } from './scoring.ts';
-
-export interface SoulOptions {
-  store: SoulStore;
-  soulId: string;
-  userId: string;
-  name?: string;
-  /** When the soul was born. Defaults to now; backdate it to demo long relationships. */
-  createdAt?: number;
-}
-
-export class Soul {
-  readonly store: SoulStore;
-  readonly soulId: string;
-  readonly userId: string;
-  readonly name: string;
-
-  constructor(options: SoulOptions) {
-    this.store = options.store;
-    this.soulId = options.soulId;
-    this.userId = options.userId;
-    this.name = options.name ?? '小灵';
-
-    if (!this.store.identity(this.soulId)) {
-      this.store.ensureSoul({
-        soulId: this.soulId,
-        name: this.name,
-        createdAt: options.createdAt ?? Date.now(),
-      });
-    }
-  }
-
-  /** Verb 1: session start. */
-  context(request: Partial<ContextRequest> = {}): ContextResult {
-    return buildContext(this.store, {
-      soulId: this.soulId,
-      userId: this.userId,
-      query: request.query,
-      maxChars: request.maxChars,
-    });
-  }
-
-  /** Verb 3: on demand. */
-  recall(query: string, limit = 5): ScoredMemory[] {
-    const memories = this.store.query({ soulId: this.soulId, userId: this.userId });
-    const ranked = rank(memories, query, Date.now()).slice(0, limit);
-    this.store.touch(ranked.map((r) => r.memory.id));
-    return ranked;
-  }
-
-  /** Verb 2: after each turn. Cheap and synchronous by design. */
-  observe(turn: Turn): ObserveResult {
-    const now = turn.at ?? Date.now();
-    const drafts = ruleExtract([turn]);
-    for (const draft of drafts) {
-      this.store.put({
-        id: `mem_${now.toString(36)}_${Math.random().toString(36).slice(2, 6)}`,
-        soulId: this.soulId,
-        userId: this.userId,
-        type: draft.type,
-        content: draft.content,
-        importance: draft.importance,
-        vividness: 0.8,
-        recallCount: 0,
-        status: 'active',
-        visibility: 'private',
-        keywords: [],
-        createdAt: now,
-        validFrom: now,
-      });
-    }
-
-    const emotion = nextEmotion(this.store.emotion(this.soulId, this.userId), [turn]);
-    this.store.saveEmotion(this.soulId, this.userId, emotion);
-    return { written: drafts.length, emotion };
-  }
-
-  /**
-   * Explicit form of `observe`: the host decided this is worth keeping.
-   * Same write path, no extraction heuristics.
-   */
-  remember(
-    content: string,
-    options: { type?: MemoryType; importance?: number; visibility?: Visibility } = {},
-  ): string {
-    const now = Date.now();
-    const id = `mem_${now.toString(36)}_${Math.random().toString(36).slice(2, 6)}`;
-    this.store.put({
-      id,
-      soulId: this.soulId,
-      userId: this.userId,
-      type: options.type ?? 'fact',
-      content,
-      importance: options.importance ?? 6,
-      vividness: 0.9,
-      recallCount: 0,
-      status: 'active',
-      visibility: options.visibility ?? 'private',
-      keywords: tokenize(content),
-      createdAt: now,
-      validFrom: now,
-    });
-    return id;
-  }
-
-  /** Verb 4: session end. */
-  async reflect(turns: Turn[], llm?: LlmFn): Promise<ReflectResult> {
-    return reflect(this.store, { soulId: this.soulId, userId: this.userId, turns, llm });
-  }
-
-  stats(): { memories: number; emotion: Emotion; name: string } {
-    return {
-      name: this.name,
-      memories: this.store.count(this.soulId, this.userId),
-      emotion: this.store.emotion(this.soulId, this.userId),
-    };
-  }
-}