soulbridge 0.0.13 → 0.0.14

package/README.md

@@ -114,6 +114,7 @@ SQLite（默认） / Postgres（可选）
 | [适配器索引](adapters/README.md) | 各宿主适配器与接入契约 |
 | [quality](docs/quality.md) | 质量模型、九条门禁、五条评审清单 |
 | [references](docs/references.md) | 外部资料的去留与过期判断 |
+| [roadmap](docs/roadmap.md) | 下一步做什么、借鉴了什么、明确不做什么 |
 | [runbook](docs/runbook.md) | 发版流程、维护操作、已知待办 |
 
 **规则**：架构级改动必须先有 RFC 或 ADR；聊天里达成的不算决定。

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

@@ -19,7 +19,7 @@ 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';
-import { llmExtractTurn } from './reflect.js';
+import { gateDrafts, llmExtractTurn } from './reflect.js';
 export class Soul {
     store;
     soulId;
@@ -129,10 +129,13 @@ export class Soul {
                 }
             }
         }
+        // Deterministic write gates: shape -> semantics -> per-turn budget. Whatever
+        // they refuse is reported, so written: 0 always has a reason.
+        const gated = gateDrafts(drafts);
         // observe runs every turn; repeating a sentence must not create a second row.
         const seen = new Set(this.store.query({ soulId: this.soulId, userId: this.userId, limit: 10_000 }).map((m) => m.content.trim()));
         let written = 0;
-        for (const draft of drafts) {
+        for (const draft of gated.accepted) {
             if (seen.has(draft.content.trim()))
                 continue;
             seen.add(draft.content.trim());
@@ -164,7 +167,14 @@ export class Soul {
         }
         const emotion = nextEmotion(this.store.emotion(this.soulId, this.userId), [turn]);
         this.store.saveEmotion(this.soulId, this.userId, emotion, now);
-        return { written, emotion, affect, extractedBy: written > 0 ? extractedBy : 'none' };
+        return {
+            written,
+            committed: written > 0,
+            rejections: gated.rejected,
+            emotion,
+            affect,
+            extractedBy: written > 0 ? extractedBy : 'none',
+        };
     }
     /**
      * Explicit form of `observe`: the host decided this is worth keeping.

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

@@ -1,4 +1,4 @@
-import type { Emotion, LlmFn, MemoryType, ReflectResult, Turn } from './types.ts';
+import type { DraftRejection, Emotion, LlmFn, MemoryType, ReflectResult, Turn } from './types.ts';
 import type { SoulStore } from './store.ts';
 interface Draft {
     type: MemoryType;
@@ -30,6 +30,20 @@ export declare const RULES: Rule[];
 export declare function isCorrection(text: string): boolean;
 /** Which marker matched, for statistics; null when the turn is not a correction. */
 export declare function correctionRule(text: string): string | null;
+/** Types an extractor may produce; episodic/relationship are host-local. */
+export declare const EXTRACTABLE_TYPES: MemoryType[];
+export declare const MAX_CONTENT_CHARS = 500;
+/** A single turn should not flood the store. */
+export declare const MAX_DRAFTS_PER_TURN = 3;
+/**
+ * Deterministic write gates. A draft must pass shape, then semantics, then the
+ * per-turn budget; anything refused is reported with the gate that refused it,
+ * so a "written: 0" is explainable rather than mysterious.
+ */
+export declare function gateDrafts(drafts: Draft[]): {
+    accepted: Draft[];
+    rejected: DraftRejection[];
+};
 export declare function ruleExtract(turns: Turn[]): Draft[];
 /** Corrections raise tension and lower passion; an ordinary session lets tension decay. */
 export declare function nextEmotion(current: Emotion, turns: Turn[]): Emotion;

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

@@ -86,6 +86,41 @@ export function correctionRule(text) {
 }
 const clamp = (n, lo, hi) => Math.min(hi, Math.max(lo, n));
 const round2 = (n) => Math.round(n * 100) / 100;
+/** Types an extractor may produce; episodic/relationship are host-local. */
+export const EXTRACTABLE_TYPES = ['strategy', 'trait', 'fact', 'cognition'];
+export const MAX_CONTENT_CHARS = 500;
+/** A single turn should not flood the store. */
+export const MAX_DRAFTS_PER_TURN = 3;
+/**
+ * Deterministic write gates. A draft must pass shape, then semantics, then the
+ * per-turn budget; anything refused is reported with the gate that refused it,
+ * so a "written: 0" is explainable rather than mysterious.
+ */
+export function gateDrafts(drafts) {
+    const accepted = [];
+    const rejected = [];
+    for (const draft of drafts) {
+        const content = draft.content.trim();
+        if (!EXTRACTABLE_TYPES.includes(draft.type)) {
+            rejected.push({ gate: 'shape', reason: `type ${draft.type} is not extractable`, content });
+            continue;
+        }
+        if (content.length < 2 || content.length > MAX_CONTENT_CHARS) {
+            rejected.push({ gate: 'shape', reason: `length ${content.length} (2..${MAX_CONTENT_CHARS})`, content });
+            continue;
+        }
+        if (content.replace(/[\s\p{P}\p{S}]/gu, '').length < 2) {
+            rejected.push({ gate: 'semantic', reason: 'no word characters', content });
+            continue;
+        }
+        if (accepted.length >= MAX_DRAFTS_PER_TURN) {
+            rejected.push({ gate: 'budget', reason: `more than ${MAX_DRAFTS_PER_TURN} drafts in one turn`, content });
+            continue;
+        }
+        accepted.push({ ...draft, content });
+    }
+    return { accepted, rejected };
+}
 export function ruleExtract(turns) {
     const drafts = [];
     for (const turn of turns) {
@@ -149,8 +184,9 @@ export async function reflect(store, options) {
     }
     const existing = store.query({ soulId: options.soulId, userId: options.userId });
     const seen = new Set(existing.map((m) => m.content));
+    const { accepted, rejected } = gateDrafts(drafts);
     let written = 0;
-    for (const draft of drafts) {
+    for (const draft of accepted) {
         if (seen.has(draft.content))
             continue;
         seen.add(draft.content);
@@ -177,7 +213,7 @@ export async function reflect(store, options) {
         emotion = nextEmotion(emotion, options.turns);
         store.saveEmotion(options.soulId, options.userId, emotion);
     }
-    return { memories: written, superseded: 0, emotion };
+    return { memories: written, superseded: null, emotion, committed: written > 0, rejections: rejected };
 }
 /* ------------------------------------------------------------------ *
  * LLM distillation port (optional)

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

@@ -100,11 +100,30 @@ export interface QuerySpec {
 }
 export interface ReflectResult {
     memories: number;
-    superseded: number;
+    /**
+     * How many older memories were replaced by a newer conflicting one.
+     * `null` means this build does not track supersession yet — it used to report
+     * a hardcoded 0, which claimed a capability that did not exist.
+     */
+    superseded: number | null;
     emotion: Emotion;
+    /** True when at least one memory was durably written by this call. */
+    committed: boolean;
+    /** Drafts refused before writing, with the gate that refused them. */
+    rejections: DraftRejection[];
+}
+export type GateName = 'shape' | 'semantic' | 'budget';
+export interface DraftRejection {
+    gate: GateName;
+    reason: string;
+    content: string;
 }
 export interface ObserveResult {
     written: number;
+    /** True when at least one memory was durably written by this call. */
+    committed: boolean;
+    /** Drafts refused before writing, with the gate that refused them. */
+    rejections: DraftRejection[];
     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.13",
+  "version": "0.0.14",
   "description": "A personality layer for any agent: continuity, forgetting, and growth across tools.",
   "license": "Apache-2.0",
   "type": "module",