feat(memory): inject persistent markdown into prompt assembly + normalize Postgres DDL

Two memory-layer fixes that production wilds-ai depends on:

1. Persistent-memory injection. CognitiveMemoryManager.assemble now
   reads from an optional PersistentMemorySource and threads the
   trimmed text through to assembleStandardPrompt as
   persistentMemoryText. The source is plug-pointed via a new
   PersistentMemorySource interface on CognitiveMemoryConfig.read():
   string | Promise<string>. Working memory remains the bounded
   cognitive focus; persistent memory is durable agent/user state
   (profile notes, preferences, identity anchors). Read failures are
   caught and treated as "no persistent memory available" rather than
   crashing prompt assembly.

2. Postgres DDL dialect normalization. Brain.ts ddlStatements were
   emitted in SQLite syntax; the storage adapter executed them
   verbatim against Postgres which rejects AUTOINCREMENT and BLOB.
   New _normalizeDdlForDialect rewrites at exec time: AUTOINCREMENT
   replaced via dialect.autoIncrementPrimaryKey(), BLOB replaced by
   BYTEA. SQLite path is unchanged. New unit test
   Brain.postgres-ddl.test.ts asserts the rewrite shape via a
   recording adapter.

Plus reader-router.ts docstring updated to reflect the
single-provider-OpenAI bench design (no behavior change).

Verified: 14 memory tests pass (1 new + 13 integration).

Author: jddunn

src/memory-router/reader-router.ts

@@ -67,8 +67,9 @@ import type { MemoryQueryCategory } from './routing-tables.js';
 
 /**
  * Reader tier the router can dispatch to. Restricted to OpenAI models
- * the shipped presets were calibrated against. Future presets (e.g.
- * `claude-opus-4-7` + `gpt-5-mini`) would extend this union.
+ * the shipped presets were calibrated against. The bench is single-
+ * provider OpenAI for reader/classifier/judge by design; Cohere is
+ * allowed only at the rerank stage.
  */
 export type ReaderTier = 'gpt-4o' | 'gpt-5' | 'gpt-5-mini';
 

src/memory/CognitiveMemoryManager.ts

@@ -892,6 +892,17 @@ export class CognitiveMemoryManager implements ICognitiveMemoryManager {
     // Get working memory state
     const wmText = this.workingMemory.formatForPrompt();
 
+    let persistentMemoryText: string | undefined;
+    if (this.config.persistentMemory) {
+      try {
+        const text = await this.config.persistentMemory.read();
+        const trimmed = typeof text === 'string' ? text.trim() : '';
+        persistentMemoryText = trimmed.length > 0 ? trimmed : undefined;
+      } catch {
+        /* non-critical */
+      }
+    }
+
     // --- Batch 2: Check prospective memory ---
     const prospectiveAlerts: string[] = [];
     if (this.prospective) {
@@ -936,6 +947,7 @@ export class CognitiveMemoryManager implements ICognitiveMemoryManager {
       allocation: this.config.tokenBudget,
       traits: this.config.traits,
       workingMemoryText: wmText,
+      persistentMemoryText,
       retrievedTraces: result.retrieved,
       prospectiveAlerts,
       graphContext,

src/memory/core/config.ts

@@ -78,6 +78,15 @@ export interface ReflectorConfig {
   llmInvoker?: (systemPrompt: string, userPrompt: string) => Promise<string>;
 }
 
+export interface PersistentMemorySource {
+  /**
+   * Read markdown memory that should be injected into every assembled prompt.
+   * Implementations are expected to handle missing/unreadable backing stores
+   * and return an empty string when no persistent memory is available.
+   */
+  read: () => string | Promise<string>;
+}
+
 /**
  * Configuration for the memory graph subsystem.
  *
@@ -253,6 +262,15 @@ export interface CognitiveMemoryConfig {
   graph?: Partial<MemoryGraphConfig>;
   consolidation?: Partial<ConsolidationConfig>;
 
+  /**
+   * Optional persistent markdown memory source injected into every prompt.
+   *
+   * This is separate from active working memory: working memory is the
+   * bounded cognitive focus, while persistent memory is durable agent/user
+   * state such as profile notes, preferences, and identity anchors.
+   */
+  persistentMemory?: PersistentMemorySource;
+
   // --- Cognitive Mechanisms (optional, no-op when absent) ---
   /** Optional per-mechanism cognitive science extensions (reconsolidation, RIF, FOK, etc.). */
   cognitiveMechanisms?: import('../mechanisms/types.js').CognitiveMechanismsConfig;

src/memory/retrieval/store/Brain.ts

@@ -706,7 +706,7 @@ export class Brain {
     ];
 
     for (const statement of ddlStatements) {
-      await this._adapter.exec(statement);
+      await this._adapter.exec(this._normalizeDdlForDialect(statement));
     }
 
     // FTS index via feature abstraction (FTS5 on SQLite, tsvector/GIN on Postgres).
@@ -727,6 +727,16 @@ export class Brain {
     }
   }
 
+  private _normalizeDdlForDialect(statement: string): string {
+    if (this._features.dialect.name !== 'postgres') {
+      return statement;
+    }
+
+    return statement
+      .replace(/\bINTEGER\s+PRIMARY\s+KEY\s+AUTOINCREMENT\b/g, this._features.dialect.autoIncrementPrimaryKey())
+      .replace(/\bBLOB\b/g, 'BYTEA');
+  }
+
   /**
    * Seed `brain_meta` with mandatory keys on first creation.
    * Uses INSERT OR IGNORE to be idempotent on subsequent opens.

src/memory/retrieval/store/__tests__/Brain.postgres-ddl.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, it } from 'vitest';
+import type {
+  StorageAdapter,
+  StorageParameters,
+  StorageRunResult,
+} from '@framers/sql-storage-adapter';
+import { Brain } from '../Brain.js';
+
+class RecordingPostgresAdapter implements StorageAdapter {
+  readonly kind = 'postgres' as const;
+  readonly execStatements: string[] = [];
+
+  async open(): Promise<void> {}
+
+  async close(): Promise<void> {}
+
+  async run(_sql: string, _params?: StorageParameters): Promise<StorageRunResult> {
+    return { changes: 1 };
+  }
+
+  async get<T = unknown>(sql: string, _params?: StorageParameters): Promise<T | null> {
+    if (sql.includes('information_schema.tables') || sql.includes('information_schema.columns')) {
+      return { exists: false } as T;
+    }
+    return null;
+  }
+
+  async all<T = unknown>(_sql: string, _params?: StorageParameters): Promise<T[]> {
+    return [];
+  }
+
+  async exec(sql: string): Promise<void> {
+    this.execStatements.push(sql);
+  }
+
+  async transaction<T>(fn: (trx: StorageAdapter) => Promise<T>): Promise<T> {
+    return fn(this);
+  }
+}
+
+describe('Brain Postgres schema initialization', () => {
+  it('emits Postgres-compatible DDL for fresh brain schemas', async () => {
+    const adapter = new RecordingPostgresAdapter();
+
+    await Brain.openWithAdapter(adapter, { brainId: 'pg-brain' });
+
+    const ddl = adapter.execStatements.join('\n');
+    expect(ddl).not.toContain('AUTOINCREMENT');
+    expect(ddl).not.toMatch(/\bBLOB\b/);
+    expect(ddl).toContain('GENERATED ALWAYS AS IDENTITY PRIMARY KEY');
+    expect(ddl).toContain('BYTEA');
+  });
+});

tests/memory/CognitiveMemoryManager.integration.spec.ts

@@ -201,6 +201,33 @@ describe('CognitiveMemoryManager (integration)', () => {
       expect(assembled.contextText.length).toBeGreaterThan(0);
       expect(assembled.includedMemoryIds.length).toBeGreaterThan(0);
     });
+
+    it('injects configured persistent markdown memory into prompt context', async () => {
+      const managerWithPersistentMemory = new CognitiveMemoryManager();
+      await managerWithPersistentMemory.initialize({
+        vectorStore: createMockVectorStore(),
+        embeddingManager: createMockEmbeddingManager(),
+        knowledgeGraph: createMockKnowledgeGraph(),
+        workingMemory: createMockWorkingMemory(),
+        agentId: 'test-agent-persistent',
+        traits: { openness: 0.7, conscientiousness: 0.6, emotionality: 0.5 },
+        moodProvider: () => neutralMood,
+        featureDetectionStrategy: 'keyword',
+        collectionPrefix: 'test-persistent',
+        persistentMemory: {
+          read: () => '# Persistent Self\n- User prefers compact, direct answers.',
+        },
+      });
+
+      const assembled = await managerWithPersistentMemory.assembleForPrompt(
+        'answer style',
+        1000,
+        neutralMood,
+      );
+
+      expect(assembled.contextText).toContain('## Persistent Memory');
+      expect(assembled.contextText).toContain('User prefers compact, direct answers.');
+    });
   });
 
   describe('getMemoryHealth', () => {