soulbridge 0.0.7 → 0.0.9

package/dist/packages/cli/src/cli.js

@@ -303,6 +303,27 @@ async function main() {
             out({ ok: true, file: resolve(file), turns: turns.length, skipped, reflected, dryRun });
             return;
         }
+        case 'list': {
+            const { soul } = open(flags);
+            const memories = soul.list(flags.limit ? Number(flags.limit) : 20);
+            if (memories.length === 0) {
+                process.stdout.write('no memories yet\n');
+                return;
+            }
+            for (const memory of memories) {
+                const preview = memory.content.replace(/\s+/g, ' ').slice(0, 72);
+                process.stdout.write(`${memory.id}  ${memory.type.padEnd(9)} imp=${String(memory.importance).padEnd(2)} ${preview}\n`);
+            }
+            return;
+        }
+        case 'forget': {
+            const id = positional[0];
+            if (!id)
+                throw new Error('usage: soulbridge forget <memory-id>');
+            const { soul } = open(flags);
+            out({ ok: soul.forget(id), id });
+            return;
+        }
         case 'status': {
             const config = ensureConfig();
             const dbPath = resolveDbPath(flags.db);
@@ -371,6 +392,8 @@ async function main() {
                 '  import --in <file>              导入 JSONL',
                 '  import --from <steering.md>     导入 AGENTS.md / CLAUDE.md',
                 '  ingest --file <transcript.jsonl> 会话转写 → 记忆与情绪采样',
+                '  list [--limit N]                看它记住了什么',
+                '  forget <id>                     忘掉一条记忆（墓碑）',
                 '  status                          一眼看它是否在工作',
                 '  stats                           看原始状态（JSON）',
                 '  demo                            端到端演示（无需模型）',

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

@@ -17,7 +17,7 @@ export * from './storage/config.ts';
 export * from './storage/merge.ts';
 export * from './storage/steering.ts';
 export * from './storage/transcript.ts';
-import type { AffectSignal, ContextRequest, ContextResult, Emotion, LlmFn, MemoryType, ObserveResult, ReflectResult, ScoredMemory, Turn, Visibility } from './types.ts';
+import type { AffectSignal, ContextRequest, Memory, ContextResult, Emotion, LlmFn, MemoryType, ObserveResult, ReflectResult, ScoredMemory, Turn, Visibility } from './types.ts';
 import type { SoulStore } from './store.ts';
 import type { AffectAnalyzer } from './affect/port.ts';
 export interface SoulOptions {
@@ -42,6 +42,10 @@ export declare class Soul {
     constructor(options: SoulOptions);
     /** Verb 1: session start. */
     context(request?: Partial<ContextRequest>): ContextResult;
+    /** Every active memory, newest first. For `list` and for auditing injection. */
+    list(limit?: number): Memory[];
+    /** Tombstone one memory so it never reaches a prompt again. */
+    forget(id: string): boolean;
     /** Verb 3: on demand. */
     recall(query: string, limit?: number): ScoredMemory[];
     /** Pure analysis, no storage. Async because the analyzer may call a model. */
@@ -63,7 +67,10 @@ export declare class Soul {
         visibility?: Visibility;
     }): string;
     /** Verb 4: session end. */
-    reflect(turns: Turn[], llm?: LlmFn): Promise<ReflectResult>;
+    reflect(turns: Turn[], options?: {
+        llm?: LlmFn;
+        updateEmotion?: boolean;
+    }): Promise<ReflectResult>;
     stats(): {
         memories: number;
         emotion: Emotion;

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

@@ -54,6 +54,14 @@ export class Soul {
             maxItems: request.maxItems,
         });
     }
+    /** Every active memory, newest first. For `list` and for auditing injection. */
+    list(limit = 50) {
+        return this.store.query({ soulId: this.soulId, userId: this.userId, limit });
+    }
+    /** Tombstone one memory so it never reaches a prompt again. */
+    forget(id) {
+        return this.store.forget(id);
+    }
     /** Verb 3: on demand. */
     recall(query, limit = 5) {
         const memories = this.store.query({ soulId: this.soulId, userId: this.userId });
@@ -131,8 +139,14 @@ export class Soul {
         return id;
     }
     /** Verb 4: session end. */
-    async reflect(turns, llm) {
-        return reflect(this.store, { soulId: this.soulId, userId: this.userId, turns, llm });
+    async reflect(turns, options = {}) {
+        return reflect(this.store, {
+            soulId: this.soulId,
+            userId: this.userId,
+            turns,
+            llm: options.llm,
+            updateEmotion: options.updateEmotion,
+        });
     }
     stats() {
         return {

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

@@ -11,7 +11,19 @@ interface Rule {
     type: MemoryType;
     importance: number;
     match: (text: string) => boolean;
+    /** Optional rewrite: keep the instruction, drop the surrounding discussion. */
+    distill?: (text: string) => string | null;
 }
+/** Long strategies are noise in a prompt; keep the instruction, not the essay. */
+export declare const MAX_STRATEGY_CHARS = 80;
+/**
+ * Cut a standing instruction down to the clause that carries it.
+ *
+ * A user explains for two lines and states the rule once; storing the whole
+ * paragraph repeats the discussion into every future prompt. Find the trigger
+ * whose neighbourhood also carries a request, and keep from there.
+ */
+export declare function distillStrategy(text: string): string | null;
 /** Cheap, synchronous, no model. Deliberately conservative: false positives cost trust. */
 export declare const RULES: Rule[];
 export declare function ruleExtract(turns: Turn[]): Draft[];
@@ -22,6 +34,12 @@ export interface ReflectOptions {
     userId: string;
     turns: Turn[];
     now?: number;
+    /**
+     * Whether this call also advances emotion (default true). A caller that runs
+     * reflect per turn, alongside observe(), must pass false or the turn is
+     * counted twice.
+     */
+    updateEmotion?: boolean;
     /** Reserved for richer extraction; unused in v0. */
     llm?: LlmFn;
 }

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

@@ -14,6 +14,38 @@ import { tokenize } from './scoring.js';
  */
 const TIME_TRIGGER = /(以后|下次|每次|从现在起|在.{0,12}之前|from now on|always)/i;
 const DIRECTIVE = /(先|需要|要|必须|应该|请|别|不要|务必|记得|need to|should|must|please)/i;
+/** Long strategies are noise in a prompt; keep the instruction, not the essay. */
+export const MAX_STRATEGY_CHARS = 80;
+/** How far after a trigger the request may sit and still belong to it. */
+const DIRECTIVE_WINDOW = 40;
+/**
+ * Cut a standing instruction down to the clause that carries it.
+ *
+ * A user explains for two lines and states the rule once; storing the whole
+ * paragraph repeats the discussion into every future prompt. Find the trigger
+ * whose neighbourhood also carries a request, and keep from there.
+ */
+export function distillStrategy(text) {
+    const trigger = new RegExp(TIME_TRIGGER.source, 'gi');
+    let match = trigger.exec(text);
+    let start = -1;
+    // The rule usually closes the paragraph ("...比如你每次…都需要…"), so the
+    // last qualifying trigger is the instruction, not the setup.
+    while (match !== null) {
+        const rest = text.slice(match.index);
+        if (DIRECTIVE.test(rest.slice(0, DIRECTIVE_WINDOW)))
+            start = match.index;
+        match = trigger.exec(text);
+    }
+    if (start < 0)
+        return null;
+    let clause = text.slice(start).replace(/^[\s，,、：:]+/, '');
+    clause = clause.replace(/^(比如|例如|就像|也就是说|你|我)\s*/g, '');
+    if (clause.length > MAX_STRATEGY_CHARS)
+        clause = clause.slice(0, MAX_STRATEGY_CHARS);
+    clause = clause.trim();
+    return clause.length > 0 ? clause : null;
+}
 /** Cheap, synchronous, no model. Deliberately conservative: false positives cost trust. */
 export const RULES = [
     {
@@ -33,6 +65,7 @@ export const RULES = [
         type: 'strategy',
         importance: 7,
         match: (text) => TIME_TRIGGER.test(text) && DIRECTIVE.test(text),
+        distill: distillStrategy,
     },
     {
         id: 'decision',
@@ -50,10 +83,13 @@ export function ruleExtract(turns) {
         if (turn.role !== 'user')
             continue;
         for (const rule of RULES) {
-            if (rule.match(turn.content)) {
-                drafts.push({ type: rule.type, content: turn.content.trim(), importance: rule.importance });
-                break;
-            }
+            if (!rule.match(turn.content))
+                continue;
+            // A rule may rewrite the turn; a strategy we cannot phrase is not stored.
+            const content = rule.distill ? rule.distill(turn.content) : turn.content.trim();
+            if (content)
+                drafts.push({ type: rule.type, content, importance: rule.importance });
+            break;
         }
     }
     return drafts;
@@ -108,7 +144,10 @@ export async function reflect(store, options) {
         store.put(memory);
         written += 1;
     }
-    const emotion = nextEmotion(store.emotion(options.soulId, options.userId), options.turns);
-    store.saveEmotion(options.soulId, options.userId, emotion);
+    let emotion = store.emotion(options.soulId, options.userId);
+    if (options.updateEmotion !== false) {
+        emotion = nextEmotion(emotion, options.turns);
+        store.saveEmotion(options.soulId, options.userId, emotion);
+    }
     return { memories: written, superseded: 0, emotion };
 }

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

@@ -225,6 +225,12 @@ export function openSqlite(file) {
                     stmt.run(now, id);
             });
         },
+        forget(id, now = Date.now()) {
+            const result = withRetry(() => db
+                .prepare('UPDATE memories SET deleted_at = ?, updated_at = ? WHERE id = ? AND deleted_at IS NULL')
+                .run(now, now, id));
+            return Number(result.changes ?? 0) > 0;
+        },
         saveAffect(soulId, userId, signal, at, deviceId) {
             withRetry(() => {
                 db.prepare(`INSERT OR IGNORE INTO affect_samples

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

@@ -13,6 +13,11 @@ export interface SoulStore {
     query(spec: QuerySpec): Memory[];
     /** Recall bookkeeping: recallCount++, lastRecalledAt = now. */
     touch(ids: string[], now?: number): void;
+    /**
+     * Tombstone a memory so it never surfaces again (sync-safe: the row stays for
+     * merge, the deletion wins by updatedAt). Returns false when no such active row.
+     */
+    forget(id: string, now?: number): boolean;
     /** Persist one affect sample (payload only; no raw text). */
     saveAffect(soulId: string, userId: string, signal: AffectSignal, at: number, deviceId?: string): void;
     /** Samples newer than `sinceMs`, newest first. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "soulbridge",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "description": "A personality layer for any agent: continuity, forgetting, and growth across tools.",
   "license": "Apache-2.0",
   "type": "module",