audrey 0.8.0 → 0.11.0

package/README.md

@@ -1,6 +1,6 @@
 # Audrey
 
-Biological memory architecture for AI agents. Gives agents cognitive memory that decays, consolidates, self-validates, and learns from experience — not just a database.
+Biological memory architecture for AI agents. Memory that decays, consolidates, feels, and learns — not just a database.
 
 ## Why Audrey Exists
 
@@ -19,7 +19,7 @@ Audrey fixes all of this by modeling memory the way the brain does:
 | Neocortex | Semantic Memory | Consolidated principles and patterns |
 | Sleep Replay | Consolidation Engine | Extracts patterns from episodes, promotes to principles |
 | Prefrontal Cortex | Validation Engine | Truth-checking, contradiction detection |
-| Amygdala | Salience Scorer | Importance weighting for retention priority |
+| Amygdala | Affect System | Emotional encoding, arousal-salience coupling, mood-congruent recall |
 
 ## Install
 
@@ -67,22 +67,26 @@ const brain = new Audrey({
   embedding: { provider: 'mock', dimensions: 8 },  // or 'openai' for production
 });
 
-// 2. Encode observations
+// 2. Encode observations — with optional emotional context
 await brain.encode({
   content: 'Stripe API returns 429 above 100 req/s',
   source: 'direct-observation',
   tags: ['stripe', 'rate-limit'],
+  affect: { valence: -0.4, arousal: 0.7, label: 'frustration' },
 });
 
-// 3. Recall what you know
-const memories = await brain.recall('stripe rate limits', { limit: 5 });
-// Returns: [{ content, type, confidence, score, ... }]
+// 3. Recall what you know — mood-congruent retrieval
+const memories = await brain.recall('stripe rate limits', {
+  limit: 5,
+  mood: { valence: -0.3 },  // frustrated right now? memories encoded in frustration surface first
+});
 
 // 4. Filtered recall — by tag, source, or date range
 const recent = await brain.recall('stripe', {
   tags: ['rate-limit'],
   sources: ['direct-observation'],
   after: '2026-02-01T00:00:00Z',
+  context: { task: 'debugging', domain: 'payments' },  // context-dependent retrieval
 });
 
 // 5. Consolidate episodes into principles (the "sleep" cycle)
@@ -127,6 +131,31 @@ const brain = new Audrey({
     minEpisodes: 3,            // Minimum cluster size for principle extraction
   },
 
+  // Context-dependent retrieval (v0.8.0)
+  context: {
+    enabled: true,             // Enable encoding-specificity principle
+    weight: 0.3,               // Max 30% confidence boost on full context match
+  },
+
+  // Emotional memory (v0.9.0)
+  affect: {
+    enabled: true,             // Enable affect system
+    weight: 0.2,               // Max 20% mood-congruence boost
+    arousalWeight: 0.3,        // Yerkes-Dodson arousal-salience coupling
+    resonance: {               // Detect emotional echoes across experiences
+      enabled: true,
+      k: 5,                    // How many past episodes to check
+      threshold: 0.5,          // Semantic similarity threshold
+      affectThreshold: 0.6,    // Emotional similarity threshold
+    },
+  },
+
+  // Interference-based forgetting (v0.7.0)
+  interference: {
+    enabled: true,             // New episodes suppress similar existing memories
+    weight: 0.15,              // Suppression strength
+  },
+
   // Decay settings
   decay: {
     dormantThreshold: 0.1,     // Below this confidence = dormant
@@ -284,6 +313,12 @@ const id = await brain.encode({
   },
   tags: ['stripe', 'production'],    // Optional. Array of strings.
   supersedes: 'previous-id',         // Optional. ID of episode this corrects.
+  context: { task: 'debugging' },    // Optional. Situational context for retrieval.
+  affect: {                          // Optional. Emotional context.
+    valence: -0.5,                   //   -1 (negative) to 1 (positive)
+    arousal: 0.7,                    //   0 (calm) to 1 (activated)
+    label: 'frustration',            //   Human-readable emotion label
+  },
 });
 ```
 
@@ -316,6 +351,8 @@ const memories = await brain.recall('stripe rate limits', {
   sources: ['direct-observation'], // Only episodic memories from these sources
   after: '2026-02-01T00:00:00Z', // Only memories created after this date
   before: '2026-03-01T00:00:00Z', // Only memories created before this date
+  context: { task: 'debugging' }, // Boost memories encoded in matching context
+  mood: { valence: -0.3, arousal: 0.5 }, // Mood-congruent retrieval
 });
 ```
 
@@ -332,6 +369,8 @@ Each result:
   score: 0.74,          // similarity * confidence
   source: 'consolidation',
   state: 'active',
+  contextMatch: 0.8,   // When retrieval context provided
+  moodCongruence: 0.7, // When mood provided
   provenance: {         // When includeProvenance: true
     evidenceEpisodeIds: ['01XYZ...', '01DEF...'],
     evidenceCount: 3,
@@ -467,6 +506,8 @@ brain.on('decay', ({ totalEvaluated, transitionedToDormant }) => { ... });
 brain.on('rollback', ({ runId, rolledBackMemories }) => { ... });
 brain.on('forget', ({ id, type, purged }) => { ... });
 brain.on('purge', ({ episodes, semantics, procedures }) => { ... });
+brain.on('interference', ({ newEpisodeId, suppressedId, similarity }) => { ... });
+brain.on('resonance', ({ episodeId, resonances }) => { ... });
 brain.on('migration', ({ episodes, semantics, procedures }) => { ... });
 brain.on('error', (err) => { ... });
 ```
@@ -492,6 +533,9 @@ src/
   decay.js           Ebbinghaus forgetting curves.
   embedding.js       Pluggable providers (Mock, OpenAI). Batch embedding.
   encode.js          Immutable episodic memory creation + vec0 writes.
+  affect.js          Emotional memory: arousal-salience coupling, mood-congruent recall, resonance.
+  context.js         Context-dependent retrieval modifier (encoding specificity).
+  interference.js    Competitive memory suppression (engram competition).
   forget.js          Soft-delete, hard-delete, query-based forget, bulk purge.
   introspect.js      Health dashboard queries.
   llm.js             Pluggable LLM providers (Mock, Anthropic, OpenAI).
@@ -531,7 +575,7 @@ All mutations use SQLite transactions. CHECK constraints enforce valid states an
 ## Running Tests
 
 ```bash
-npm test          # 278 tests across 23 files
+npm test          # 379 tests across 28 files
 npm run test:watch
 ```
 
@@ -547,7 +591,29 @@ Demonstrates the full pipeline: encode 3 rate-limit observations, consolidate in
 
 ## Changelog
 
-### v0.6.0 — Filtered Recall + Forget (current)
+### v0.9.0 — Emotional Memory (current)
+
+- Valence-arousal affect model (Russell's circumplex) on every episode
+- Arousal-salience coupling via Yerkes-Dodson inverted-U curve
+- Mood-congruent recall — matching emotional state boosts retrieval confidence
+- Emotional resonance detection — new experiences that echo past emotional patterns emit events
+- MCP server: `memory_encode` accepts `affect`, `memory_recall` accepts `mood`
+- 379 tests across 28 test files
+
+### v0.8.0 — Context-Dependent Retrieval
+
+- Encoding specificity principle: context stored with memory, matching context boosts recall
+- MCP server: `memory_encode` and `memory_recall` accept `context`
+- 340 tests across 27 test files
+
+### v0.7.0 — Interference + Salience
+
+- Interference-based forgetting: new memories competitively suppress similar existing ones
+- Salience-weighted confidence: high-salience memories resist decay
+- Spaced-repetition reconsolidation: retrieval intervals affect reinforcement strength
+- 310 tests across 25 test files
+
+### v0.6.0 — Filtered Recall + Forget
 
 - Filtered recall: tag, source, and date-range filters on `recall()` and `recallStream()`
 - `forget()` — soft-delete any memory by ID
@@ -608,6 +674,8 @@ Demonstrates the full pipeline: encode 3 rate-limit observations, consolidate in
 
 **Why soft-delete by default?** Hard-deletes are irreversible. Soft-delete preserves data integrity and audit trails while excluding the memory from recall. Use `purge: true` or `brain.purge()` when you need permanent removal (GDPR, storage cleanup).
 
+**Why emotional memory?** Every memory system stores facts. Biological memory stores facts with emotional context — and that context changes how memories are retrieved. Emotional arousal modulates encoding strength (amygdala-hippocampal interaction). Current mood biases which memories surface (Bower, 1981). This isn't a novelty feature — it's the foundation for AI that remembers like it cares.
+
 ## License
 
 MIT

package/mcp-server/config.js

@@ -1,26 +1,40 @@
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 
-export const VERSION = '0.8.0';
+export const VERSION = '0.11.0';
 export const SERVER_NAME = 'audrey-memory';
 export const DEFAULT_DATA_DIR = join(homedir(), '.audrey', 'data');
 
+/**
+ * Resolves which embedding provider to use.
+ * Priority: explicit config -> gemini (if GOOGLE_API_KEY exists) -> local
+ * OpenAI is NEVER auto-selected -- must be set explicitly via AUDREY_EMBEDDING_PROVIDER=openai.
+ */
+export function resolveEmbeddingProvider(env, explicit) {
+  if (explicit && explicit !== 'auto') {
+    const dims = explicit === 'openai' ? 1536 : explicit === 'gemini' ? 768 : 384;
+    const apiKey = explicit === 'gemini'
+      ? (env.GOOGLE_API_KEY || env.GEMINI_API_KEY)
+      : explicit === 'openai'
+        ? env.OPENAI_API_KEY
+        : undefined;
+    return { provider: explicit, apiKey, dimensions: dims };
+  }
+  if (env.GOOGLE_API_KEY || env.GEMINI_API_KEY) {
+    return { provider: 'gemini', apiKey: env.GOOGLE_API_KEY || env.GEMINI_API_KEY, dimensions: 768 };
+  }
+  return { provider: 'local', dimensions: 384 };
+}
+
 export function buildAudreyConfig() {
   const dataDir = process.env.AUDREY_DATA_DIR || DEFAULT_DATA_DIR;
   const agent = process.env.AUDREY_AGENT || 'claude-code';
-  const embProvider = process.env.AUDREY_EMBEDDING_PROVIDER || 'mock';
-  const embDimensions = parseInt(process.env.AUDREY_EMBEDDING_DIMENSIONS || '8', 10);
+  const explicitProvider = process.env.AUDREY_EMBEDDING_PROVIDER;
   const llmProvider = process.env.AUDREY_LLM_PROVIDER;
 
-  const config = {
-    dataDir,
-    agent,
-    embedding: { provider: embProvider, dimensions: embDimensions },
-  };
+  const embedding = resolveEmbeddingProvider(process.env, explicitProvider);
 
-  if (embProvider === 'openai') {
-    config.embedding.apiKey = process.env.OPENAI_API_KEY;
-  }
+  const config = { dataDir, agent, embedding };
 
   if (llmProvider === 'anthropic') {
     config.llm = { provider: 'anthropic', apiKey: process.env.ANTHROPIC_API_KEY };
@@ -36,13 +50,13 @@ export function buildAudreyConfig() {
 export function buildInstallArgs(env = process.env) {
   const envPairs = [`AUDREY_DATA_DIR=${DEFAULT_DATA_DIR}`];
 
-  if (env.OPENAI_API_KEY) {
+  const embedding = resolveEmbeddingProvider(env);
+  if (embedding.provider === 'gemini') {
+    envPairs.push('AUDREY_EMBEDDING_PROVIDER=gemini');
+    envPairs.push(`GOOGLE_API_KEY=${embedding.apiKey}`);
+  } else if (embedding.provider === 'openai') {
     envPairs.push('AUDREY_EMBEDDING_PROVIDER=openai');
-    envPairs.push('AUDREY_EMBEDDING_DIMENSIONS=1536');
     envPairs.push(`OPENAI_API_KEY=${env.OPENAI_API_KEY}`);
-  } else {
-    envPairs.push('AUDREY_EMBEDDING_PROVIDER=mock');
-    envPairs.push('AUDREY_EMBEDDING_DIMENSIONS=8');
   }
 
   if (env.ANTHROPIC_API_KEY) {

package/mcp-server/index.js

@@ -8,7 +8,7 @@ import { existsSync, readFileSync } from 'node:fs';
 import { execFileSync } from 'node:child_process';
 import { Audrey } from '../src/index.js';
 import { readStoredDimensions } from '../src/db.js';
-import { VERSION, SERVER_NAME, DEFAULT_DATA_DIR, buildAudreyConfig, buildInstallArgs } from './config.js';
+import { VERSION, SERVER_NAME, DEFAULT_DATA_DIR, buildAudreyConfig, buildInstallArgs, resolveEmbeddingProvider } from './config.js';
 
 const VALID_SOURCES = ['direct-observation', 'told-by-user', 'tool-result', 'inference', 'model-generated'];
 const VALID_TYPES = ['episodic', 'semantic', 'procedural'];
@@ -19,6 +19,11 @@ if (subcommand === 'install') {
   install();
 } else if (subcommand === 'uninstall') {
   uninstall();
+} else if (subcommand === 'reembed') {
+  reembed().catch(err => {
+    console.error('[audrey] reembed failed:', err);
+    process.exit(1);
+  });
 } else if (subcommand === 'status') {
   status();
 } else {
@@ -28,6 +33,28 @@ if (subcommand === 'install') {
   });
 }
 
+
+async function reembed() {
+  const dataDir = process.env.AUDREY_DATA_DIR || DEFAULT_DATA_DIR;
+  const explicit = process.env.AUDREY_EMBEDDING_PROVIDER;
+  const embedding = resolveEmbeddingProvider(process.env, explicit);
+
+  const storedDims = readStoredDimensions(dataDir);
+  const dimensionsChanged = storedDims !== null && storedDims !== embedding.dimensions;
+
+  console.log(`Re-embedding with ${embedding.provider} (${embedding.dimensions}d)...`);
+  if (dimensionsChanged) {
+    console.log(`Dimension change: ${storedDims}d -> ${embedding.dimensions}d (will drop and recreate vec tables)`);
+  }
+
+  const audrey = new Audrey({ dataDir, agent: 'reembed', embedding });
+  const { reembedAll } = await import('../src/migrate.js');
+  const counts = await reembedAll(audrey.db, audrey.embeddingProvider, { dropAndRecreate: dimensionsChanged });
+  audrey.close();
+
+  console.log(`Done. Re-embedded: ${counts.episodes} episodes, ${counts.semantics} semantics, ${counts.procedures} procedures`);
+}
+
 function install() {
   try {
     execFileSync('claude', ['--version'], { stdio: 'ignore' });
@@ -164,11 +191,17 @@ async function main() {
       tags: z.array(z.string()).optional().describe('Optional tags for categorization'),
       salience: z.number().min(0).max(1).optional().describe('Importance weight 0-1'),
       context: z.record(z.string()).optional().describe('Situational context as key-value pairs (e.g., {task: "debugging", domain: "payments"})'),
+      affect: z.object({
+        valence: z.number().min(-1).max(1).describe('Emotional valence: -1 (very negative) to 1 (very positive)'),
+        arousal: z.number().min(0).max(1).optional().describe('Emotional arousal: 0 (calm) to 1 (highly activated)'),
+        label: z.string().optional().describe('Human-readable emotion label (e.g., "curiosity", "frustration", "relief")'),
+      }).optional().describe('Emotional affect — how this memory feels'),
+      private: z.boolean().optional().describe('If true, memory is only visible to the AI � excluded from public recall results'),
     },
-    async ({ content, source, tags, salience, context }) => {
+    async ({ content, source, tags, salience, private: isPrivate, context, affect }) => {
       try {
-        const id = await audrey.encode({ content, source, tags, salience, context });
-        return toolResult({ id, content, source });
+        const id = await audrey.encode({ content, source, tags, salience, private: isPrivate, context, affect });
+        return toolResult({ id, content, source, private: isPrivate ?? false });
       } catch (err) {
         return toolError(err);
       }
@@ -187,8 +220,12 @@ async function main() {
       after: z.string().optional().describe('Only return memories created after this ISO date'),
       before: z.string().optional().describe('Only return memories created before this ISO date'),
       context: z.record(z.string()).optional().describe('Retrieval context — memories encoded in matching context get boosted'),
+      mood: z.object({
+        valence: z.number().min(-1).max(1).describe('Current emotional valence: -1 (negative) to 1 (positive)'),
+        arousal: z.number().min(0).max(1).optional().describe('Current arousal: 0 (calm) to 1 (activated)'),
+      }).optional().describe('Current mood — boosts recall of memories encoded in similar emotional state'),
     },
-    async ({ query, limit, types, min_confidence, tags, sources, after, before, context }) => {
+    async ({ query, limit, types, min_confidence, tags, sources, after, before, context, mood }) => {
       try {
         const results = await audrey.recall(query, {
           limit: limit ?? 10,
@@ -199,6 +236,7 @@ async function main() {
           after,
           before,
           context,
+          mood,
         });
         return toolResult(results);
       } catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "audrey",
-  "version": "0.8.0",
+  "version": "0.11.0",
   "description": "Biological memory architecture for AI agents — encode, consolidate, and recall memories with confidence decay, contradiction detection, and causal graphs",
   "type": "module",
   "main": "src/index.js",
@@ -63,6 +63,7 @@
   },
   "license": "MIT",
   "dependencies": {
+    "@huggingface/transformers": "^3.8.1",
     "@modelcontextprotocol/sdk": "^1.26.0",
     "better-sqlite3": "^12.6.2",
     "sqlite-vec": "^0.1.7-alpha.2",

package/src/affect.js

@@ -0,0 +1,64 @@
+export function arousalSalienceBoost(arousal) {
+  if (arousal === undefined || arousal === null) return 0;
+  // Inverted-U (Yerkes-Dodson): peaks at 0.7, Gaussian sigma=0.3
+  return Math.exp(-Math.pow(arousal - 0.7, 2) / (2 * 0.3 * 0.3));
+}
+
+export function affectSimilarity(a, b) {
+  if (!a || !b) return 0;
+  if (a.valence === undefined || b.valence === undefined) return 0;
+  const valenceDist = Math.abs(a.valence - b.valence);
+  const valenceSim = 1.0 - (valenceDist / 2.0);
+  if (a.arousal === undefined || b.arousal === undefined) return valenceSim;
+  const arousalSim = 1.0 - Math.abs(a.arousal - b.arousal);
+  // Valence is primary (70%), arousal secondary (30%) per Bower 1981
+  return 0.7 * valenceSim + 0.3 * arousalSim;
+}
+
+export function moodCongruenceModifier(encodingAffect, retrievalMood, weight = 0.2) {
+  if (!encodingAffect || !retrievalMood) return 1.0;
+  const similarity = affectSimilarity(encodingAffect, retrievalMood);
+  if (similarity === 0) return 1.0;
+  return 1.0 + (weight * similarity);
+}
+
+export async function detectResonance(db, embeddingProvider, episodeId, { content, affect }, config = {}) {
+  const { enabled = true, k = 5, threshold = 0.5, affectThreshold = 0.6 } = config;
+  if (!enabled || !affect || affect.valence === undefined) return [];
+
+  const vector = await embeddingProvider.embed(content);
+  const buffer = embeddingProvider.vectorToBuffer(vector);
+
+  const matches = db.prepare(`
+    SELECT e.*, (1.0 - v.distance) AS similarity
+    FROM vec_episodes v
+    JOIN episodes e ON e.id = v.id
+    WHERE v.embedding MATCH ?
+      AND k = ?
+      AND e.id != ?
+      AND e.superseded_by IS NULL
+  `).all(buffer, k, episodeId);
+
+  const resonances = [];
+  for (const match of matches) {
+    if (match.similarity < threshold) continue;
+    let priorAffect;
+    try { priorAffect = JSON.parse(match.affect || '{}'); } catch { continue; }
+    if (priorAffect.valence === undefined) continue;
+
+    const emotionalSimilarity = affectSimilarity(affect, priorAffect);
+    if (emotionalSimilarity < affectThreshold) continue;
+
+    resonances.push({
+      priorEpisodeId: match.id,
+      priorContent: match.content,
+      priorAffect,
+      semanticSimilarity: match.similarity,
+      emotionalSimilarity,
+      timeDeltaDays: Math.floor((Date.now() - new Date(match.created_at).getTime()) / 86400000),
+      priorCreatedAt: match.created_at,
+    });
+  }
+
+  return resonances;
+}

package/src/audrey.js

@@ -10,12 +10,13 @@ import { applyDecay } from './decay.js';
 import { rollbackConsolidation, getConsolidationHistory } from './rollback.js';
 import { forgetMemory, forgetByQuery as forgetByQueryFn, purgeMemories } from './forget.js';
 import { introspect as introspectFn } from './introspect.js';
-import { buildContextResolutionPrompt } from './prompts.js';
+import { buildContextResolutionPrompt, buildReflectionPrompt } from './prompts.js';
 import { exportMemories } from './export.js';
 import { importMemories } from './import.js';
 import { suggestConsolidationParams as suggestParamsFn } from './adaptive.js';
 import { reembedAll } from './migrate.js';
 import { applyInterference } from './interference.js';
+import { detectResonance } from './affect.js';
 
 /**
  * @typedef {'direct-observation' | 'told-by-user' | 'tool-result' | 'inference' | 'model-generated'} SourceType
@@ -28,6 +29,8 @@ import { applyInterference } from './interference.js';
  * @property {{ trigger?: string, consequence?: string }} [causal]
  * @property {string[]} [tags]
  * @property {string} [supersedes]
+ * @property {Record<string, string>} [context]
+ * @property {{ valence?: number, arousal?: number, label?: string }} [affect]
  *
  * @typedef {Object} RecallOptions
  * @property {number} [minConfidence]
@@ -39,6 +42,8 @@ import { applyInterference } from './interference.js';
  * @property {string[]} [sources]
  * @property {string} [after]
  * @property {string} [before]
+ * @property {Record<string, string>} [context]
+ * @property {{ valence?: number, arousal?: number }} [mood]
  *
  * @typedef {Object} RecallResult
  * @property {string} id
@@ -92,6 +97,8 @@ export class Audrey extends EventEmitter {
     decay = {},
     interference = {},
     context = {},
+    affect = {},
+    autoReflect = false,
   } = {}) {
     super();
 
@@ -118,6 +125,7 @@ export class Audrey extends EventEmitter {
       sourceReliability: confidence.sourceReliability,
       interferenceWeight: interference.weight ?? 0.1,
       contextWeight: context.weight ?? 0.3,
+      affectWeight: affect.weight ?? 0.2,
     };
     this.consolidationConfig = {
       minEpisodes: consolidation.minEpisodes || 3,
@@ -134,6 +142,18 @@ export class Audrey extends EventEmitter {
       enabled: context.enabled ?? true,
       weight: context.weight ?? 0.3,
     };
+    this.affectConfig = {
+      enabled: affect.enabled ?? true,
+      weight: affect.weight ?? 0.2,
+      arousalWeight: affect.arousalWeight ?? 0.3,
+      resonance: {
+        enabled: affect.resonance?.enabled ?? true,
+        k: affect.resonance?.k ?? 5,
+        threshold: affect.resonance?.threshold ?? 0.5,
+        affectThreshold: affect.resonance?.affectThreshold ?? 0.6,
+      },
+    };
+    this.autoReflect = autoReflect;
   }
 
   async _ensureMigrated() {
@@ -173,7 +193,8 @@ export class Audrey extends EventEmitter {
    */
   async encode(params) {
     await this._ensureMigrated();
-    const id = await encodeEpisode(this.db, this.embeddingProvider, params);
+    const encodeParams = { ...params, arousalWeight: this.affectConfig.arousalWeight };
+    const id = await encodeEpisode(this.db, this.embeddingProvider, encodeParams);
     this.emit('encode', { id, ...params });
     if (this.interferenceConfig.enabled) {
       applyInterference(this.db, this.embeddingProvider, id, params, this.interferenceConfig)
@@ -184,10 +205,61 @@ export class Audrey extends EventEmitter {
         })
         .catch(err => this.emit('error', err));
     }
+    if (this.affectConfig.enabled && this.affectConfig.resonance.enabled && params.affect?.valence !== undefined) {
+      detectResonance(this.db, this.embeddingProvider, id, params, this.affectConfig.resonance)
+        .then(echoes => {
+          if (echoes.length > 0) {
+            this.emit('resonance', { episodeId: id, affect: params.affect, echoes });
+          }
+        })
+        .catch(err => this.emit('error', err));
+    }
     this._emitValidation(id, params);
     return id;
   }
 
+
+  async reflect(turns) {
+    if (!this.llmProvider) return { encoded: 0, memories: [], skipped: 'no llm provider' };
+
+    const prompt = buildReflectionPrompt(turns);
+    let raw;
+    try {
+      raw = await this.llmProvider.chat(prompt);
+    } catch (err) {
+      this.emit('error', err);
+      return { encoded: 0, memories: [], skipped: 'llm error' };
+    }
+
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      return { encoded: 0, memories: [], skipped: 'invalid llm response' };
+    }
+
+    const memories = parsed.memories ?? [];
+    let encoded = 0;
+    for (const mem of memories) {
+      if (!mem.content || !mem.source) continue;
+      try {
+        await this.encode({
+          content: mem.content,
+          source: mem.source,
+          salience: mem.salience,
+          tags: mem.tags,
+          private: mem.private ?? false,
+          affect: mem.affect ?? undefined,
+        });
+        encoded++;
+      } catch (err) {
+        this.emit('error', err);
+      }
+    }
+
+    return { encoded, memories };
+  }
+
   /**
    * @param {EncodeParams[]} paramsList
    * @returns {Promise<string[]>}
@@ -235,10 +307,14 @@ export class Audrey extends EventEmitter {
   }
 
   _recallConfig(options) {
-    const base = options.confidenceConfig ?? this.confidenceConfig;
-    return this.contextConfig.enabled && options.context
-      ? { ...base, retrievalContext: options.context }
-      : base;
+    let config = options.confidenceConfig ?? this.confidenceConfig;
+    if (this.contextConfig.enabled && options.context) {
+      config = { ...config, retrievalContext: options.context };
+    }
+    if (this.affectConfig.enabled && options.mood) {
+      config = { ...config, retrievalMood: options.mood };
+    }
+    return config;
   }
 
   /**