soulbridge 0.0.16 → 0.0.18

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

@@ -40,6 +40,11 @@ export interface SoulOptions {
     llm?: LlmFn;
     /** Messages longer than this are not sent to the model. Defaults to 2000. */
     llmMaxChars?: number;
+    /**
+     * A paraphrase written this many ms after a similar memory is treated as a
+     * duplicate rather than a second row. Set 0 to disable. Defaults to 30s.
+     */
+    dedupeWindowMs?: number;
 }
 export declare class Soul {
     readonly store: SoulStore;
@@ -50,6 +55,7 @@ export declare class Soul {
     readonly analyzer: AffectAnalyzer;
     readonly llm?: LlmFn;
     readonly llmMaxChars: number;
+    readonly dedupeWindowMs: number;
     constructor(options: SoulOptions);
     /** Verb 1: session start. */
     context(request?: Partial<ContextRequest>): ContextResult;

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

@@ -30,6 +30,7 @@ export class Soul {
     analyzer;
     llm;
     llmMaxChars;
+    dedupeWindowMs;
     constructor(options) {
         this.store = options.store;
         this.soulId = options.soulId;
@@ -39,6 +40,7 @@ export class Soul {
         this.analyzer = options.analyzer ?? lexiconAnalyzer;
         this.llm = options.llm;
         this.llmMaxChars = options.llmMaxChars ?? 2000;
+        this.dedupeWindowMs = options.dedupeWindowMs ?? 30_000;
         if (!this.store.identity(this.soulId)) {
             this.store.ensureSoul({
                 soulId: this.soulId,
@@ -128,6 +130,9 @@ export class Soul {
         // a rule that already fired.
         let drafts = ruleExtract([turn]);
         let extractedBy = drafts.length > 0 ? 'rules' : 'none';
+        // A model that says "nothing to keep" and a model that answers garbage used
+        // to be indistinguishable; keep them apart for measurement.
+        let llmOutcome = 'off';
         if (drafts.length === 0 && turn.role === 'user' && this.llm) {
             if (turn.content.length <= this.llmMaxChars) {
                 try {
@@ -135,13 +140,21 @@ export class Soul {
                     if (draft) {
                         drafts = [draft];
                         extractedBy = 'llm';
+                        llmOutcome = 'stored';
+                    }
+                    else {
+                        llmOutcome = 'null';
                     }
                 }
                 catch {
                     // The model is an enhancement; a transport or parse failure leaves the
                     // rule result (nothing) in place.
+                    llmOutcome = 'failed';
                 }
             }
+            else {
+                llmOutcome = 'skipped';
+            }
         }
         // Deterministic write gates: shape -> semantics -> per-turn budget. Whatever
         // they refuse is reported, so written: 0 always has a reason.
@@ -185,6 +198,7 @@ export class Soul {
             written,
             committed: written > 0,
             rejections: gated.rejected,
+            llmOutcome,
             emotion,
             affect,
             extractedBy: written > 0 ? extractedBy : 'none',
@@ -228,17 +242,29 @@ export class Soul {
             return { ok: false, reason: rejected[0]?.reason ?? 'rejected by write gates' };
         }
         const content = accepted[0].content;
-        const existing = this.store
-            .query({
+        const now = Date.now();
+        const candidates = this.store.query({
             soulId: this.soulId,
             userId: this.userId,
             status: ['active'],
             includeExpired: true,
-            limit: 10_000,
-        })
-            .find((memory) => memory.content.trim() === content);
-        if (existing)
-            return { ok: true, id: existing.id, duplicate: true };
+            limit: 50,
+        });
+        // Same content anywhere: the exact duplicate.
+        const same = candidates.find((memory) => memory.content.trim() === content);
+        if (same)
+            return { ok: true, id: same.id, duplicate: true };
+        // A paraphrase of something just written (usually the automatic observer
+        // moments earlier) must not become a second row: a shared run of characters
+        // inside the dedupe window is treated as the same statement.
+        const window = this.dedupeWindowMs;
+        if (window > 0) {
+            const recent = candidates.filter((memory) => now - memory.createdAt <= window);
+            const overlapping = recent.find((memory) => sharesRun(memory.content, content, MIN_SHARED_RUN));
+            if (overlapping) {
+                return { ok: true, id: overlapping.id, duplicate: true, reason: 'already recorded this turn' };
+            }
+        }
         const id = this.remember(content, { type, importance });
         return { ok: true, id };
     }
@@ -274,3 +300,19 @@ export class Soul {
         }
     }
 }
+/** Shortest shared character run that means "the same statement" (RFC 0005). */
+const MIN_SHARED_RUN = 4;
+function sharesRun(a, b, minRun) {
+    const left = a.trim();
+    const right = b.trim();
+    if (left.length === 0 || right.length === 0)
+        return false;
+    const window = Math.min(left.length, right.length);
+    for (let len = window; len >= minRun; len -= 1) {
+        for (let i = 0; i + len <= right.length; i += 1) {
+            if (left.includes(right.slice(i, i + len)))
+                return true;
+        }
+    }
+    return false;
+}

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

@@ -129,6 +129,11 @@ export interface ObserveResult {
     committed: boolean;
     /** Drafts refused before writing, with the gate that refused them. */
     rejections: DraftRejection[];
+    /**
+     * What the optional model did, kept apart from `extractedBy` because a null
+     * answer and a broken answer used to look identical in the logs.
+     */
+    llmOutcome: 'off' | 'skipped' | 'stored' | 'null' | 'failed';
     emotion: Emotion;
     /** Analysis of the user turn. Empty signal for assistant turns or on failure. */
     affect: AffectSignal;

package/package.json

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