v0.4.0

bun.lock

@@ -5,7 +5,7 @@
     "": {
       "name": "boxbrain",
       "dependencies": {
-        "identitydb": "0.2.1",
+        "identitydb": "^0.4.0",
       },
       "devDependencies": {
         "@types/bun": "latest",
@@ -249,7 +249,7 @@
 
     "iconv-lite": ["iconv-lite@0.7.2", "", { "dependencies": { "safer-buffer": ">= 2.1.2 < 3.0.0" } }, "sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw=="],
 
-    "identitydb": ["identitydb@0.2.1", "", { "dependencies": { "kysely": "^0.28.8", "mysql2": "^3.15.3", "pg": "^8.16.0" } }, "sha512-e+caNqI7F6JaqgyIFQbdiT5/2Frs5PEJgy3mmF+qUVspHZ4z6QtFF5jonDnpYtJpZ9guPWfeQ/xteeaiwOJ5zA=="],
+    "identitydb": ["identitydb@0.4.0", "", { "dependencies": { "kysely": "^0.28.8", "mysql2": "^3.15.3", "pg": "^8.16.0" } }, "sha512-DAyipdrApjmI1HoHfhT9zuMfNLiWaYe7/k/FrUa55h7WUUASGV192AhrC6KUiMTS55dfYKDBWi0AcS7crSw+bA=="],
 
     "is-property": ["is-property@1.0.2", "", {}, "sha512-Ks/IoX00TtClbGQr4TWXemAnktAQvYB7HzcCxDGqEZU6oCmb2INHuOoKxbtR+HFkmYWBKv/dOZtGRiAjDhj92g=="],
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "boxbrain",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "Human-like persona harness framework powered by LLMs and IdentityDB.",
   "license": "MIT",
   "type": "module",
@@ -48,7 +48,7 @@
     "prepublishOnly": "bun run check && bun run test && bun run build && bun run pack:check"
   },
   "dependencies": {
-    "identitydb": "0.2.1"
+    "identitydb": "^0.4.0"
   },
   "devDependencies": {
     "@types/bun": "latest",

src/conversation.ts

@@ -20,24 +20,16 @@ export function formatMessageHistory(input: {
     .join("\n");
 }
 
-export function conversationInstruction(): string {
+export function conversationInstruction(baseSystemPrompt?: string): string {
-  return [
+  const parts = [
+    ...(baseSystemPrompt === undefined ? [] : [baseSystemPrompt]),
     "You are controlling the persona, not a generic assistant.",
     "Use the send_message tool conceptually: return one or more outgoing messages.",
     "Unless the persona strongly prefers otherwise, keep each outgoing message to at most one sentence.",
     "Prefer short, natural, chat-like wording and allow splitting one thought into multiple messages.",
     'If mandatory memory says "기억이 없음", the persona may naturally wonder about missing context instead of pretending to remember.',
-  ].join("\n");
+  ];
-}
+  return parts.join("\n");
-
-export function memoryExtractionInstruction(now: string): string {
-  return [
-    `Current objective time: ${now}.`,
-    "Read the message history and extract durable facts worth remembering.",
-    "Objectivize subjective statements before storage.",
-    'Example: "I started TypeScript in 2025" becomes "The user started TypeScript in 2025."',
-    "Prefer facts about the persona, the user, their relationship, preferences, history, schedule-relevant events, and stable traits.",
-  ].join("\n");
 }
 
 export async function buildMandatoryConversationContext(input: {

src/memory.ts

@@ -1,4 +1,4 @@
-import { IdentityDB, type Fact as IdentityFact } from 'identitydb';
+import { IdentityDB, extractFact, type Fact as IdentityFact, type FactExtractor } from 'identitydb';
 import type { BoxBrainMemoryStore, FactDraft, MemorySpace, ScheduleEntry, StoredFact } from './types';
 
 function normalizeTopics(topics: string[]): string[] {
@@ -74,6 +74,17 @@ export class InMemoryMemoryStore implements BoxBrainMemoryStore {
     this.schedules.set(spaceId, kept);
     return entries.length - kept.length;
   }
+
+  async ingestStatement(spaceId: string, statement: string, extractor: FactExtractor): Promise<StoredFact> {
+    const extracted = await extractFact(statement, extractor);
+    return this.addFact(spaceId, {
+      statement: extracted.statement ?? statement,
+      topics: extracted.topics.map((t) => t.name),
+      ...(typeof extracted.confidence === 'number' ? { confidence: extracted.confidence } : {}),
+      ...(typeof extracted.source === 'string' ? { source: extracted.source } : {}),
+      ...(extracted.metadata !== undefined && extracted.metadata !== null ? { metadata: extracted.metadata as Record<string, unknown> } : {}),
+    });
+  }
 }
 
 export interface IdentityDbMemoryStoreOptions {
@@ -172,6 +183,11 @@ export class IdentityDbMemoryStore implements BoxBrainMemoryStore {
     return 0;
   }
 
+  async ingestStatement(spaceId: string, statement: string, extractor: FactExtractor): Promise<StoredFact> {
+    const fact = await this.options.db.ingestStatement(statement, { extractor, spaceName: spaceId });
+    return this.fromIdentityFact(fact);
+  }
+
   private fromIdentityFact(fact: IdentityFact): StoredFact {
     const metadata = typeof fact.metadata === 'object' && fact.metadata !== null && !Array.isArray(fact.metadata) ? fact.metadata as Record<string, unknown> : undefined;
     return {

src/persona.ts

@@ -10,11 +10,11 @@ import {
   startOfUtcDay,
   toIso,
 } from "./schedule";
+import { extractFact } from "identitydb";
 import {
   buildMandatoryConversationContext,
   conversationInstruction,
   formatMessageHistory,
-  memoryExtractionInstruction,
 } from "./conversation";
 import type {
   BoxBrainMemoryStore,
@@ -68,6 +68,7 @@ export class Persona {
   private readonly mode: Mode;
   private readonly readyPromise: Promise<MemorySpace>;
   private availabilitySnapshot?: ScheduledAvailabilitySnapshot;
+  readonly baseSystemPrompt: string | undefined;
 
   constructor(
     displayName: string,
@@ -88,6 +89,7 @@ export class Persona {
       this.options = second ?? {};
     }
     this.memory = this.options.memory ?? new InMemoryMemoryStore();
+    this.baseSystemPrompt = this.options.baseSystemPrompt;
     this.readyPromise = this.initialize();
   }
 
@@ -247,7 +249,7 @@ export class Persona {
         mode: "reply",
         context,
         ...(userMessage === undefined ? {} : { userMessage }),
-        instruction: conversationInstruction(),
+        instruction: conversationInstruction(this.baseSystemPrompt),
       }),
     );
 
@@ -281,7 +283,7 @@ export class Persona {
                 now: toIso(input.datetime),
                 mode: "reply",
                 context: latestContext,
-                instruction: conversationInstruction(),
+                instruction: conversationInstruction(this.baseSystemPrompt),
               })),
           );
         }
@@ -320,7 +322,7 @@ export class Persona {
         now: toIso(input.datetime),
         mode: "start-conversation",
         context,
-        instruction: conversationInstruction(),
+        instruction: conversationInstruction(this.baseSystemPrompt),
       }),
     );
     await this.emit("persona.conversation.started", {
@@ -334,35 +336,50 @@ export class Persona {
     messageHistory: PersonaMessage[];
   }): Promise<FactDraft[]> {
     const persona = await this.ready();
-    if (!this.options.models?.memoryExtraction) {
+    if (!this.options.models?.factExtractor) {
-      throw new Error("sleepMemory requires options.models.memoryExtraction.");
+      throw new Error("sleepMemory requires options.models.factExtractor.");
     }
     const contextFacts = await this.memory.findFacts(persona.id, [
       "persona",
       persona.displayName,
       "user",
     ]);
-    const drafts = await this.options.models.memoryExtraction.extract({
+    const statement = [
-      persona,
+      `Current objective time: ${toIso(input.datetime)}.`,
-      now: toIso(input.datetime),
+      "Read the message history and extract durable facts worth remembering.",
-      formattedMessageHistory: formatMessageHistory({
+      "Objectivize subjective statements before storage.",
+      'Example: "I started TypeScript in 2025" becomes "The user started TypeScript in 2025."',
+      "Prefer facts about the persona, the user, their relationship, preferences, history, schedule-relevant events, and stable traits.",
+      "",
+      "Context facts:",
+      ...contextFacts.map((f) => `- ${f.statement}`),
+      "",
+      "Message history:",
+      formatMessageHistory({
         personaName: persona.displayName,
         messages: input.messageHistory,
       }),
-      contextFacts,
+    ].join("\n");
-      instruction: memoryExtractionInstruction(toIso(input.datetime)),
+    const extracted = await extractFact(
-    });
+      statement,
-    for (const draft of drafts) {
+      this.options.models.factExtractor,
-      await this.memory.addFact(persona.id, {
+    );
-        ...draft,
+    const draft: FactDraft = {
-        topics: [...draft.topics, "sleepMemory"],
+      statement: extracted.statement ?? statement,
-        source: draft.source ?? "boxbrain.sleepMemory",
+      topics: [...extracted.topics.map((t) => t.name), "sleepMemory"],
-      });
+      source: extracted.source ?? "boxbrain.sleepMemory",
-    }
+      ...(typeof extracted.confidence === 'number'
+        ? { confidence: extracted.confidence }
+        : {}),
+      ...(extracted.metadata !== undefined && extracted.metadata !== null
+        ? { metadata: extracted.metadata as Record<string, unknown> }
+        : {}),
+    };
+    await this.memory.addFact(persona.id, draft);
     await this.emit("persona.memory.sleep.persisted", {
-      factCount: drafts.length,
+      factCount: 1,
     });
-    return drafts;
+    return [draft];
   }
 
   private async initialize(): Promise<MemorySpace> {
@@ -381,24 +398,38 @@ export class Persona {
       seedMessage: this.mode.seedMessage,
       now,
     });
-    const modelFacts = this.options.models?.initialization
+    if (this.options.models?.factExtractor) {
-      ? await this.options.models.initialization.extractInitialFacts({
+      const statement = `Persona: ${this.mode.displayName}\nSeed: ${this.mode.seedMessage}`;
-          displayName: this.mode.displayName,
+      const extracted = await extractFact(
-          seedMessage: this.mode.seedMessage,
+        statement,
-          now,
+        this.options.models.factExtractor,
-        })
+      );
-      : undefined;
+      const draft: FactDraft = {
-    const facts = modelFacts ?? [
+        statement: extracted.statement ?? statement,
-      defaultInitialFact(this.mode.displayName, this.mode.seedMessage),
+        topics: extracted.topics.map((t) => t.name),
-    ];
+        source: extracted.source ?? "boxbrain.persona.initialization",
-    for (const fact of facts) {
+        ...(typeof extracted.confidence === 'number'
-      await this.memory.addFact(space.id, fact);
+          ? { confidence: extracted.confidence }
-    }
+          : {}),
+        ...(extracted.metadata !== undefined && extracted.metadata !== null
+          ? { metadata: extracted.metadata as Record<string, unknown> }
+          : {}),
+      };
+      await this.memory.addFact(space.id, draft);
       await this.emit(
         "persona.initialized",
-      { displayName: space.displayName, factCount: facts.length },
+        { displayName: space.displayName, factCount: 1 },
         space.id,
       );
+    } else {
+      const fact = defaultInitialFact(this.mode.displayName, this.mode.seedMessage);
+      await this.memory.addFact(space.id, fact);
+      await this.emit(
+        "persona.initialized",
+        { displayName: space.displayName, factCount: 1 },
+        space.id,
+      );
+    }
     await this.refreshAvailability(now, space);
     return space;
   }

src/types.ts

@@ -1,3 +1,5 @@
+import type { FactExtractor } from 'identitydb';
+
 export type DateTimeInput = Date | string | number;
 
 export type PersonaConstructorMode = 'create' | 'load';
@@ -117,18 +119,6 @@ export interface RewriteModel {
   decide(input: RewriteDecisionInput): Promise<RewriteDecision>;
 }
 
-export interface MemoryExtractionInput {
-  persona: MemorySpace;
-  now: string;
-  formattedMessageHistory: string;
-  contextFacts: StoredFact[];
-  instruction: string;
-}
-
-export interface MemoryExtractionModel {
-  extract(input: MemoryExtractionInput): Promise<FactDraft[]>;
-}
-
 export interface ScheduleBlock {
   startTime: string;
   endTime: string;
@@ -158,19 +148,10 @@ export interface ScheduleModel {
   generateMonthlySchedule(input: MonthlyScheduleGenerationInput): Promise<ScheduleBlock[]>;
 }
 
-export interface PersonaInitializationModel {
-  extractInitialFacts(input: {
-    displayName: string;
-    seedMessage: string;
-    now: string;
-  }): Promise<FactDraft[]>;
-}
-
 export interface PersonaModels {
-  initialization?: PersonaInitializationModel;
+  factExtractor?: FactExtractor;
   conversation?: ConversationModel;
   rewrite?: RewriteModel;
-  memoryExtraction?: MemoryExtractionModel;
   schedule?: ScheduleModel;
 }
 
@@ -179,6 +160,7 @@ export interface PersonaOptions {
   models?: PersonaModels;
   debug?: DebugHook;
   now?: DateTimeInput;
+  baseSystemPrompt?: string;
 }
 
 export interface BoxBrainMemoryStore {
@@ -190,4 +172,5 @@ export interface BoxBrainMemoryStore {
   saveScheduleEntries(spaceId: string, entries: ScheduleEntry[]): Promise<void>;
   listScheduleEntries(spaceId: string, fromInclusive: string, toExclusive: string): Promise<ScheduleEntry[]>;
   deleteScheduleEntriesBefore(spaceId: string, cutoffExclusive: string): Promise<number>;
+  ingestStatement(spaceId: string, statement: string, extractor: FactExtractor): Promise<StoredFact>;
 }

tests/conversation.test.ts

@@ -55,7 +55,6 @@ describe('Conversation API', () => {
       memory,
       now: '2026-05-01T10:00:00.000Z',
       models: {
-        initialization: { async extractInitialFacts() { return []; } },
         conversation: {
           async generateReply(input) {
             memorySummary = input.context.memorySummary;
@@ -64,7 +63,8 @@ describe('Conversation API', () => {
         },
       },
     });
-    await persona.ready();
+    const space = await persona.ready();
+    memory.facts.set(space.id, []);
 
     await persona.sendMessage({
       datetime: '2026-05-01T12:00:00.000Z',
@@ -124,4 +124,30 @@ describe('Conversation API', () => {
     expect(mode).toBe('start-conversation');
     expect(started.messages).toEqual(['오늘 좀 조용하네.']);
   });
+
+  it('includes baseSystemPrompt at the start of the instruction when provided', async () => {
+    const memory = new InMemoryMemoryStore();
+    let captured: ReplyGenerationInput | undefined;
+    const persona = new Persona('Mina', 'Mina likes quiet cafes.', {
+      memory,
+      now: '2026-05-01T10:00:00.000Z',
+      baseSystemPrompt: 'You are a helpful assistant. Always be kind.',
+      models: {
+        conversation: {
+          async generateReply(input) {
+            captured = input;
+            return { messages: ['Hello!'] };
+          },
+        },
+      },
+    });
+    await persona.ready();
+
+    await persona.sendMessage({
+      datetime: '2026-05-01T12:00:00.000Z',
+      messageHistory: [{ sender: 'user', time: '2026-05-01T12:00:00.000Z', content: 'Hi' }],
+    });
+
+    expect(captured?.instruction.startsWith('You are a helpful assistant. Always be kind.')).toBe(true);
+  });
 });

tests/persona.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { InMemoryMemoryStore, Persona, type FactDraft } from '../src';
+import { InMemoryMemoryStore, Persona } from '../src';
 
 describe('Persona initialization', () => {
   it('creates a new isolated persona space from displayName and seed message', async () => {
@@ -10,15 +10,13 @@ describe('Persona initialization', () => {
       now: '2026-05-01T10:00:00.000Z',
       debug: (event) => { debug.push(event.name); },
       models: {
-        initialization: {
+        factExtractor: {
-          async extractInitialFacts(input): Promise<FactDraft[]> {
+          async extract(input) {
-            return [
+            return {
-              {
+              statement: 'Mina likes quiet cafes.',
-                statement: `${input.displayName} likes quiet cafes.`,
+              topics: [{ name: 'persona' }, { name: 'Mina' }],
-                topics: ['persona', input.displayName],
               source: 'test',
-              },
+            };
-            ];
           },
         },
       },
@@ -31,6 +29,18 @@ describe('Persona initialization', () => {
     expect(debug).toContain('persona.initialized');
   });
 
+  it('exposes baseSystemPrompt on the persona instance when provided', async () => {
+    const memory = new InMemoryMemoryStore();
+    const persona = new Persona('Hana', 'Hana is a cheerful barista.', {
+      memory,
+      now: '2026-05-01T10:00:00.000Z',
+      baseSystemPrompt: 'You are a helpful assistant. Always be kind.',
+    });
+
+    await persona.ready();
+    expect(persona.baseSystemPrompt).toBe('You are a helpful assistant. Always be kind.');
+  });
+
   it('loads an existing persona space by space id without creating another space', async () => {
     const memory = new InMemoryMemoryStore();
     const created = new Persona('Joon', 'Joon is a freelance designer.', { memory, now: '2026-05-01T10:00:00.000Z' });

tests/sleep-memory.test.ts

@@ -8,17 +8,18 @@ describe('sleepMemory', () => {
       memory,
       now: '2026-05-01T10:00:00.000Z',
       models: {
-        memoryExtraction: {
+        factExtractor: {
           async extract(input) {
-            expect(input.formattedMessageHistory).toContain('user@2026-05-01T15:00:00.000Z: 나는 타입스크립트를 2025년부터 시작했어');
+            if (input.includes('Seed:')) {
-            expect(input.instruction).toContain('Objectivize');
+              return { statement: 'Mina remembers stable details.', topics: [{ name: 'persona' }, { name: 'Mina' }] };
-            return [
+            }
-              {
+            expect(input).toContain('user@2026-05-01T15:00:00.000Z: 나는 타입스크립트를 2025년부터 시작했어');
+            expect(input).toContain('Objectivize');
+            return {
               statement: 'The user started TypeScript in 2025.',
-                topics: ['user', 'TypeScript', '2025'],
+              topics: [{ name: 'user' }, { name: 'TypeScript' }, { name: '2025' }],
               confidence: 0.9,
-              },
+            };
-            ];
           },
         },
       },