soulbridge 0.0.15 → 0.0.17

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

@@ -20,6 +20,7 @@ export * from './storage/transcript.ts';
 import type { AffectSignal, ContextRequest, Correction, 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 { gateDrafts } from './reflect.ts';
 export interface SoulOptions {
     store: SoulStore;
     soulId: string;
@@ -39,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;
@@ -49,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;
@@ -91,6 +98,21 @@ export declare class Soul {
         importance?: number;
         visibility?: Visibility;
     }): string;
+    /**
+     * Explicit write requested by a host or its model (RFC 0005). Unlike
+     * `remember`, it passes the same gates as `observe` and dedupes by content,
+     * so a tool cannot bypass shape/semantics or flood duplicates.
+     */
+    rememberExplicit(input: {
+        content: string;
+        type?: MemoryType;
+        importance?: number;
+    }): {
+        ok: boolean;
+        id?: string;
+        duplicate?: boolean;
+        reason?: string;
+    };
     /** Verb 4: session end. */
     reflect(turns: Turn[], options?: {
         updateEmotion?: boolean;

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

@@ -20,6 +20,7 @@ import { reflect, ruleExtract, nextEmotion } from './reflect.js';
 import { rank, tokenize } from './scoring.js';
 import { analyzeAffect, emptyAffect, lexiconAnalyzer } from './affect/analyze.js';
 import { gateDrafts, llmExtractTurn } from './reflect.js';
+export { gateDrafts } from './reflect.js';
 export class Soul {
     store;
     soulId;
@@ -29,6 +30,7 @@ export class Soul {
     analyzer;
     llm;
     llmMaxChars;
+    dedupeWindowMs;
     constructor(options) {
         this.store = options.store;
         this.soulId = options.soulId;
@@ -38,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,
@@ -214,6 +217,45 @@ export class Soul {
         });
         return id;
     }
+    /**
+     * Explicit write requested by a host or its model (RFC 0005). Unlike
+     * `remember`, it passes the same gates as `observe` and dedupes by content,
+     * so a tool cannot bypass shape/semantics or flood duplicates.
+     */
+    rememberExplicit(input) {
+        const type = input.type ?? 'fact';
+        const importance = Math.min(10, Math.max(1, input.importance ?? 7));
+        const { accepted, rejected } = gateDrafts([{ type, content: input.content, importance }]);
+        if (accepted.length === 0) {
+            return { ok: false, reason: rejected[0]?.reason ?? 'rejected by write gates' };
+        }
+        const content = accepted[0].content;
+        const now = Date.now();
+        const candidates = this.store.query({
+            soulId: this.soulId,
+            userId: this.userId,
+            status: ['active'],
+            includeExpired: 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 };
+    }
     /** Verb 4: session end. */
     async reflect(turns, options = {}) {
         return reflect(this.store, {
@@ -246,3 +288,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/package.json

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