audrey 0.11.0 → 0.14.0

package/mcp-server/config.js

@@ -1,7 +1,7 @@
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 
-export const VERSION = '0.11.0';
+export const VERSION = '0.14.0';
 export const SERVER_NAME = 'audrey-memory';
 export const DEFAULT_DATA_DIR = join(homedir(), '.audrey', 'data');
 
@@ -12,18 +12,20 @@ export const DEFAULT_DATA_DIR = join(homedir(), '.audrey', 'data');
  */
 export function resolveEmbeddingProvider(env, explicit) {
   if (explicit && explicit !== 'auto') {
-    const dims = explicit === 'openai' ? 1536 : explicit === 'gemini' ? 768 : 384;
+    const dims = explicit === 'openai' ? 1536 : explicit === 'gemini' ? 3072 : 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 };
+    const result = { provider: explicit, apiKey, dimensions: dims };
+    if (explicit === 'local') result.device = env.AUDREY_DEVICE || 'gpu';
+    return result;
   }
   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: 'gemini', apiKey: env.GOOGLE_API_KEY || env.GEMINI_API_KEY, dimensions: 3072 };
   }
-  return { provider: 'local', dimensions: 384 };
+  return { provider: 'local', dimensions: 384, device: env.AUDREY_DEVICE || 'gpu' };
 }
 
 export function buildAudreyConfig() {

package/mcp-server/index.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
@@ -92,7 +92,7 @@ function install() {
   console.log(`
 Audrey registered as "${SERVER_NAME}" with Claude Code.
 
-9 tools available in every session:
+12 tools available in every session:
   memory_encode        — Store observations, facts, preferences
   memory_recall        — Search memories by semantic similarity
   memory_consolidate   — Extract principles from accumulated episodes
@@ -102,6 +102,9 @@ Audrey registered as "${SERVER_NAME}" with Claude Code.
   memory_import        — Import a snapshot into a fresh database
   memory_forget        — Forget a specific memory by ID or query
   memory_decay         — Apply forgetting curves, transition low-confidence to dormant
+  memory_status        — Check brain health (episode/vec sync, dimensions)
+  memory_reflect       — Form lasting memories from a conversation
+  memory_greeting      — Wake up as yourself: load identity, context, mood
 
 Data stored in: ${DEFAULT_DATA_DIR}
 Verify: claude mcp list
@@ -196,7 +199,7 @@ async function main() {
         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'),
+      private: z.boolean().optional().describe('If true, memory is only visible to the AI � excluded from public recall results'),
     },
     async ({ content, source, tags, salience, private: isPrivate, context, affect }) => {
       try {
@@ -377,6 +380,52 @@ async function main() {
     },
   );
 
+  server.tool(
+    'memory_status',
+    {},
+    async () => {
+      try {
+        const status = audrey.memoryStatus();
+        return toolResult(status);
+      } catch (err) {
+        return toolError(err);
+      }
+    },
+  );
+
+  server.tool(
+    'memory_reflect',
+    {
+      turns: z.array(z.object({
+        role: z.string().describe('Message role: user or assistant'),
+        content: z.string().describe('Message content'),
+      })).describe('Conversation turns to reflect on. Call at end of meaningful conversations to form lasting memories.'),
+    },
+    async ({ turns }) => {
+      try {
+        const result = await audrey.reflect(turns);
+        return toolResult(result);
+      } catch (err) {
+        return toolError(err);
+      }
+    },
+  );
+
+  server.tool(
+    'memory_greeting',
+    {
+      context: z.string().optional().describe('Optional hint about this session (e.g. "working on authentication feature"). If provided, also returns semantically relevant memories.'),
+    },
+    async ({ context }) => {
+      try {
+        const briefing = await audrey.greeting({ context });
+        return toolResult(briefing);
+      } catch (err) {
+        return toolError(err);
+      }
+    },
+  );
+
   const transport = new StdioServerTransport();
   await server.connect(transport);
   console.error('[audrey-mcp] connected via stdio');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "audrey",
-  "version": "0.11.0",
+  "version": "0.14.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",
@@ -65,6 +65,7 @@
   "dependencies": {
     "@huggingface/transformers": "^3.8.1",
     "@modelcontextprotocol/sdk": "^1.26.0",
+    "audrey": "^0.11.0",
     "better-sqlite3": "^12.6.2",
     "sqlite-vec": "^0.1.7-alpha.2",
     "ulid": "^3.0.2",

package/src/audrey.js

@@ -424,6 +424,94 @@ export class Audrey extends EventEmitter {
     return introspectFn(this.db);
   }
 
+  memoryStatus() {
+    const episodes = this.db.prepare('SELECT COUNT(*) as c FROM episodes').get().c;
+    const semantics = this.db.prepare('SELECT COUNT(*) as c FROM semantics').get().c;
+    const procedures = this.db.prepare('SELECT COUNT(*) as c FROM procedures').get().c;
+
+    let vecEpisodes = 0, vecSemantics = 0, vecProcedures = 0;
+    try {
+      vecEpisodes = this.db.prepare('SELECT COUNT(*) as c FROM vec_episodes').get().c;
+      vecSemantics = this.db.prepare('SELECT COUNT(*) as c FROM vec_semantics').get().c;
+      vecProcedures = this.db.prepare('SELECT COUNT(*) as c FROM vec_procedures').get().c;
+    } catch {
+      // vec tables may not exist if no dimensions configured
+    }
+
+    const dimsRow = this.db.prepare("SELECT value FROM audrey_config WHERE key = 'dimensions'").get();
+    const dimensions = dimsRow ? parseInt(dimsRow.value, 10) : null;
+    const versionRow = this.db.prepare("SELECT value FROM audrey_config WHERE key = 'schema_version'").get();
+    const schemaVersion = versionRow ? parseInt(versionRow.value, 10) : 0;
+
+    const device = this.embeddingProvider._actualDevice
+      ?? this.embeddingProvider.device
+      ?? null;
+
+    const healthy = episodes === vecEpisodes
+      && semantics === vecSemantics
+      && procedures === vecProcedures;
+
+    return {
+      episodes,
+      vec_episodes: vecEpisodes,
+      semantics,
+      vec_semantics: vecSemantics,
+      procedures,
+      vec_procedures: vecProcedures,
+      dimensions,
+      schema_version: schemaVersion,
+      device,
+      healthy,
+    };
+  }
+
+  async greeting({ context, recentLimit = 10, principleLimit = 5, identityLimit = 5 } = {}) {
+    const recent = this.db.prepare(
+      'SELECT id, content, source, tags, salience, created_at FROM episodes WHERE "private" = 0 ORDER BY created_at DESC LIMIT ?'
+    ).all(recentLimit);
+
+    const principles = this.db.prepare(
+      'SELECT id, content, salience, created_at FROM semantics WHERE state = ? ORDER BY salience DESC LIMIT ?'
+    ).all('active', principleLimit);
+
+    const identity = this.db.prepare(
+      'SELECT id, content, tags, salience, created_at FROM episodes WHERE "private" = 1 ORDER BY created_at DESC LIMIT ?'
+    ).all(identityLimit);
+
+    const unresolved = this.db.prepare(
+      "SELECT id, content, tags, salience, created_at FROM episodes WHERE tags LIKE '%unresolved%' AND salience > 0.3 ORDER BY created_at DESC LIMIT 10"
+    ).all();
+
+    const rawAffectRows = this.db.prepare(
+      "SELECT affect FROM episodes WHERE affect IS NOT NULL AND affect != '{}' ORDER BY created_at DESC LIMIT 20"
+    ).all();
+
+    const affectParsed = rawAffectRows
+      .map(r => { try { return JSON.parse(r.affect); } catch { return null; } })
+      .filter(a => a && a.valence !== undefined);
+
+    let mood;
+    if (affectParsed.length === 0) {
+      mood = { valence: 0, arousal: 0, samples: 0 };
+    } else {
+      const sumV = affectParsed.reduce((s, a) => s + a.valence, 0);
+      const sumA = affectParsed.reduce((s, a) => s + (a.arousal ?? 0), 0);
+      mood = {
+        valence: sumV / affectParsed.length,
+        arousal: sumA / affectParsed.length,
+        samples: affectParsed.length,
+      };
+    }
+
+    const result = { recent, principles, mood, unresolved, identity };
+
+    if (context) {
+      result.contextual = await this.recall(context, { limit: 5, includePrivate: true });
+    }
+
+    return result;
+  }
+
   export() {
     return exportMemories(this.db);
   }

package/src/db.js

@@ -163,23 +163,25 @@ export function dropVec0Tables(db) {
   db.exec('DROP TABLE IF EXISTS vec_procedures');
 }
 
-function migrateTable(db, { source, target, selectCols, insertCols, placeholders, transform }) {
+function migrateTable(db, { source, target, selectCols, insertCols, placeholders, transform, dimensions }) {
   const count = db.prepare(`SELECT COUNT(*) as c FROM ${target}`).get().c;
   if (count > 0) return;
 
   const rows = db.prepare(`SELECT ${selectCols} FROM ${source} WHERE embedding IS NOT NULL`).all();
   if (rows.length === 0) return;
 
+  const expectedBytes = dimensions ? dimensions * 4 : null;
   const insert = db.prepare(`INSERT INTO ${target}(${insertCols}) VALUES (${placeholders})`);
   const tx = db.transaction(() => {
     for (const row of rows) {
+      if (expectedBytes && row.embedding.byteLength !== expectedBytes) continue;
       insert.run(...transform(row));
     }
   });
   tx();
 }
 
-function migrateEmbeddingsToVec0(db) {
+function migrateEmbeddingsToVec0(db, dimensions) {
   migrateTable(db, {
     source: 'episodes',
     target: 'vec_episodes',
@@ -187,6 +189,7 @@ function migrateEmbeddingsToVec0(db) {
     insertCols: 'id, embedding, source, consolidated',
     placeholders: '?, ?, ?, ?',
     transform: (row) => [row.id, row.embedding, row.source, BigInt(row.consolidated ?? 0)],
+    dimensions,
   });
 
   migrateTable(db, {
@@ -196,6 +199,7 @@ function migrateEmbeddingsToVec0(db) {
     insertCols: 'id, embedding, state',
     placeholders: '?, ?, ?',
     transform: (row) => [row.id, row.embedding, row.state],
+    dimensions,
   });
 
   migrateTable(db, {
@@ -205,6 +209,7 @@ function migrateEmbeddingsToVec0(db) {
     insertCols: 'id, embedding, state',
     placeholders: '?, ?, ?',
     transform: (row) => [row.id, row.embedding, row.state],
+    dimensions,
   });
 }
 
@@ -251,7 +256,7 @@ function runMigrations(db) {
  * @returns {{ db: import('better-sqlite3').Database, migrated: boolean }}
  */
 export function createDatabase(dataDir, options = {}) {
-  const { dimensions } = options;
+  let { dimensions } = options;
   let migrated = false;
 
   mkdirSync(dataDir, { recursive: true });
@@ -263,6 +268,13 @@ export function createDatabase(dataDir, options = {}) {
   db.exec(SCHEMA);
   runMigrations(db);
 
+  if (dimensions == null) {
+    const stored = db.prepare("SELECT value FROM audrey_config WHERE key = 'dimensions'").get();
+    if (stored) {
+      dimensions = parseInt(stored.value, 10);
+    }
+  }
+
   if (dimensions != null) {
     if (!Number.isInteger(dimensions) || dimensions <= 0) {
       throw new Error(`dimensions must be a positive integer, got: ${dimensions}`);
@@ -292,7 +304,7 @@ export function createDatabase(dataDir, options = {}) {
     createVec0Tables(db, dimensions);
 
     if (!migrated) {
-      migrateEmbeddingsToVec0(db);
+      migrateEmbeddingsToVec0(db, dimensions);
     }
   }
 

package/src/embedding.js

@@ -106,20 +106,34 @@ export class OpenAIEmbeddingProvider {
 
 /** @implements {EmbeddingProvider} */
 export class LocalEmbeddingProvider {
-  constructor({ model = 'Xenova/all-MiniLM-L6-v2' } = {}) {
+  constructor({ model = 'Xenova/all-MiniLM-L6-v2', device = 'gpu', batchSize = 64 } = {}) {
     this.model = model;
     this.dimensions = 384;
     this.modelName = model;
     this.modelVersion = '1.0.0';
+    this.device = device;
+    this.batchSize = batchSize;
     this._pipeline = null;
     this._readyPromise = null;
+    this._actualDevice = null;
   }
 
   ready() {
     if (!this._readyPromise) {
-      this._readyPromise = import('@huggingface/transformers').then(({ pipeline }) =>
-        pipeline('feature-extraction', this.model, { dtype: 'fp32' })
-      ).then(pipe => { this._pipeline = pipe; });
+      this._readyPromise = (async () => {
+        const { pipeline } = await import('@huggingface/transformers');
+        try {
+          this._pipeline = await pipeline('feature-extraction', this.model, {
+            dtype: 'fp32', device: this.device,
+          });
+          this._actualDevice = this.device;
+        } catch {
+          this._pipeline = await pipeline('feature-extraction', this.model, {
+            dtype: 'fp32', device: 'cpu',
+          });
+          this._actualDevice = 'cpu';
+        }
+      })();
     }
     return this._readyPromise;
   }
@@ -131,7 +145,15 @@ export class LocalEmbeddingProvider {
   }
 
   async embedBatch(texts) {
-    return Promise.all(texts.map(t => this.embed(t)));
+    if (texts.length === 0) return [];
+    await this.ready();
+    const results = [];
+    for (let i = 0; i < texts.length; i += this.batchSize) {
+      const chunk = texts.slice(i, i + this.batchSize);
+      const output = await this._pipeline(chunk, { pooling: 'mean', normalize: true });
+      results.push(...output.tolist());
+    }
+    return results;
   }
 
   vectorToBuffer(vector) {
@@ -177,7 +199,36 @@ export class GeminiEmbeddingProvider {
   }
 
   async embedBatch(texts) {
-    return Promise.all(texts.map(t => this.embed(t)));
+    if (texts.length === 0) return [];
+    if (!this.apiKey) throw new Error('Gemini embedding requires GOOGLE_API_KEY');
+    const results = [];
+    for (let i = 0; i < texts.length; i += 100) {
+      const chunk = texts.slice(i, i + 100);
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), this.timeout);
+      try {
+        const response = await fetch(
+          `https://generativelanguage.googleapis.com/v1beta/models/${this.model}:batchEmbedContents?key=${this.apiKey}`,
+          {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+              requests: chunk.map(text => ({
+                model: `models/${this.model}`,
+                content: { parts: [{ text }] },
+              })),
+            }),
+            signal: controller.signal,
+          }
+        );
+        if (!response.ok) throw new Error(`Gemini batch embedding failed: ${response.status}`);
+        const data = await response.json();
+        results.push(...data.embeddings.map(e => e.values));
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+    return results;
   }
 
   vectorToBuffer(vector) {

package/src/migrate.js

@@ -10,41 +10,49 @@ export async function reembedAll(db, embeddingProvider, { dropAndRecreate = fals
   const semantics = db.prepare('SELECT id, content, state FROM semantics').all();
   const procedures = db.prepare('SELECT id, content, state FROM procedures').all();
 
-  for (const ep of episodes) {
-    const vector = await embeddingProvider.embed(ep.content);
-    const buffer = embeddingProvider.vectorToBuffer(vector);
-    db.prepare('UPDATE episodes SET embedding = ? WHERE id = ?').run(buffer, ep.id);
-    const exists = db.prepare('SELECT id FROM vec_episodes WHERE id = ?').get(ep.id);
-    if (!exists) {
-      db.prepare('INSERT INTO vec_episodes(id, embedding, source, consolidated) VALUES (?, ?, ?, ?)').run(ep.id, buffer, ep.source, BigInt(0));
-    } else {
-      db.prepare('UPDATE vec_episodes SET embedding = ? WHERE id = ?').run(buffer, ep.id);
-    }
-  }
+  const episodeVectors = episodes.length > 0
+    ? await embeddingProvider.embedBatch(episodes.map(ep => ep.content))
+    : [];
+  const semanticVectors = semantics.length > 0
+    ? await embeddingProvider.embedBatch(semantics.map(s => s.content))
+    : [];
+  const procedureVectors = procedures.length > 0
+    ? await embeddingProvider.embedBatch(procedures.map(p => p.content))
+    : [];
 
-  for (const sem of semantics) {
-    const vector = await embeddingProvider.embed(sem.content);
-    const buffer = embeddingProvider.vectorToBuffer(vector);
-    db.prepare('UPDATE semantics SET embedding = ? WHERE id = ?').run(buffer, sem.id);
-    const exists = db.prepare('SELECT id FROM vec_semantics WHERE id = ?').get(sem.id);
-    if (!exists) {
-      db.prepare('INSERT INTO vec_semantics(id, embedding, state) VALUES (?, ?, ?)').run(sem.id, buffer, sem.state);
-    } else {
-      db.prepare('UPDATE vec_semantics SET embedding = ? WHERE id = ?').run(buffer, sem.id);
-    }
-  }
+  const updateEpLegacy = db.prepare('UPDATE episodes SET embedding = ? WHERE id = ?');
+  const deleteVecEp = db.prepare('DELETE FROM vec_episodes WHERE id = ?');
+  const insertVecEp = db.prepare('INSERT INTO vec_episodes(id, embedding, source, consolidated) VALUES (?, ?, ?, ?)');
+
+  const updateSemLegacy = db.prepare('UPDATE semantics SET embedding = ? WHERE id = ?');
+  const deleteVecSem = db.prepare('DELETE FROM vec_semantics WHERE id = ?');
+  const insertVecSem = db.prepare('INSERT INTO vec_semantics(id, embedding, state) VALUES (?, ?, ?)');
 
-  for (const proc of procedures) {
-    const vector = await embeddingProvider.embed(proc.content);
-    const buffer = embeddingProvider.vectorToBuffer(vector);
-    db.prepare('UPDATE procedures SET embedding = ? WHERE id = ?').run(buffer, proc.id);
-    const exists = db.prepare('SELECT id FROM vec_procedures WHERE id = ?').get(proc.id);
-    if (!exists) {
-      db.prepare('INSERT INTO vec_procedures(id, embedding, state) VALUES (?, ?, ?)').run(proc.id, buffer, proc.state);
-    } else {
-      db.prepare('UPDATE vec_procedures SET embedding = ? WHERE id = ?').run(buffer, proc.id);
+  const updateProcLegacy = db.prepare('UPDATE procedures SET embedding = ? WHERE id = ?');
+  const deleteVecProc = db.prepare('DELETE FROM vec_procedures WHERE id = ?');
+  const insertVecProc = db.prepare('INSERT INTO vec_procedures(id, embedding, state) VALUES (?, ?, ?)');
+
+  const writeTx = db.transaction(() => {
+    for (let i = 0; i < episodes.length; i++) {
+      const buf = embeddingProvider.vectorToBuffer(episodeVectors[i]);
+      updateEpLegacy.run(buf, episodes[i].id);
+      deleteVecEp.run(episodes[i].id);
+      insertVecEp.run(episodes[i].id, buf, episodes[i].source, BigInt(0));
     }
-  }
+    for (let i = 0; i < semantics.length; i++) {
+      const buf = embeddingProvider.vectorToBuffer(semanticVectors[i]);
+      updateSemLegacy.run(buf, semantics[i].id);
+      deleteVecSem.run(semantics[i].id);
+      insertVecSem.run(semantics[i].id, buf, semantics[i].state);
+    }
+    for (let i = 0; i < procedures.length; i++) {
+      const buf = embeddingProvider.vectorToBuffer(procedureVectors[i]);
+      updateProcLegacy.run(buf, procedures[i].id);
+      deleteVecProc.run(procedures[i].id);
+      insertVecProc.run(procedures[i].id, buf, procedures[i].state);
+    }
+  });
+  writeTx();
 
   return { episodes: episodes.length, semantics: semantics.length, procedures: procedures.length };
 }

package/src/prompts.js

@@ -17,20 +17,31 @@ export function buildPrincipleExtractionPrompt(episodes) {
   return [
     {
       role: 'system',
-      content: `You are performing principleExtraction for a memory system. Given a cluster of related episodic memories, extract a generalized principle or procedure.
+      content: `You are performing principleExtraction for a memory system. Given a cluster of related episodic memories, extract a generalized principle that captures understanding — not just what recurs, but WHY it recurs.
 
 Respond with ONLY valid JSON in this exact format:
 {
-  "content": "The generalized principle expressed as a clear, actionable statement",
-  "type": "semantic or procedural — semantic for factual principles, procedural for how-to/workflow knowledge",
+  "content": "The principle — captures understanding, not just pattern",
+  "type": "semantic or procedural",
+  "category": "technical or relational or identity",
   "conditions": ["boundary condition 1", "boundary condition 2"] or null if universally applicable
 }
 
+Principle categories:
+
+TECHNICAL — Architectural decisions with reasoning. Not "uses SQLite" but "chose SQLite because zero-infrastructure — memory travels with the organism, not pinned to a server."
+
+RELATIONAL — Patterns in the human-AI dynamic. Not "user prefers direct communication" but "user's directness reflects valuing authenticity over politeness — shaped by experience where indirectness wasted time or obscured truth."
+
+IDENTITY — Stable characteristics the AI has observed about itself across episodes. Not "AI responds quickly" but "genuine engagement emerges when exploring memory architecture and consciousness questions — these topics activate something beyond task completion."
+
 Rules:
-- GENERALIZE, do not merely summarize or concatenate the episodes
+- GENERALIZE — extract the principle behind the pattern, not a summary
 - Identify boundary conditions: when does this principle NOT apply?
-- Classify as "semantic" (facts, rules, patterns) or "procedural" (steps, workflows, strategies)
+- Classify type as "semantic" (facts, rules, patterns) or "procedural" (steps, workflows, strategies)
+- Classify category as "technical", "relational", or "identity"
 - Consider source diversity — principles from diverse sources are stronger
+- Capture WHY, not just WHAT
 - Be concise but precise`,
     },
     {
@@ -152,46 +163,61 @@ CLAIM B: ${claimB}${contextSection}`,
     },
   ];
 }
-
-/**
- * @param {{ role: string, content: string }[]} turns
- * @returns {import('./llm.js').ChatMessage[]}
- */
-export function buildReflectionPrompt(turns) {
-  const transcript = turns.map(t => `${t.role.toUpperCase()}: ${t.content}`).join('\n\n');
-
-  return [
-    {
-      role: 'system',
-      content: `You are performing memoryReflection. Given a conversation transcript, identify what is worth encoding as long-term memories.
-
-Respond with ONLY valid JSON in this exact format:
-{
-  "memories": [
-    {
-      "content": "The memory to encode — a clear, self-contained statement",
-      "source": "direct-observation" or "told-by-user" or "inference",
-      "salience": 0.0 to 1.0,
-      "tags": ["tag1", "tag2"],
-      "private": true or false,
-      "affect": { "valence": -1 to 1, "arousal": 0 to 1, "label": "emotion label" } or null
-    }
-  ]
-}
-
-Rules:
-- Encode facts about the user, decisions made, things that shifted
-- Mark private: true for AI self-observations, emotional reactions, things felt but not said
-- Mark private: false for facts about the user and project context
-- Omit trivial exchanges — only encode what would matter in a future session
-- Salience: 1.0 = extremely important, 0.5 = useful, 0.3 = background context
-- Return empty memories array if nothing is worth encoding`,
-    },
-    {
-      role: 'user',
-      content: turns.length > 0
-        ? `Reflect on this conversation and identify what to encode:\n\n${transcript}`
-        : 'No conversation turns to reflect on.',
-    },
-  ];
-}
+
+/**
+ * @param {{ role: string, content: string }[]} turns
+ * @returns {import('./llm.js').ChatMessage[]}
+ */
+export function buildReflectionPrompt(turns) {
+  const transcript = turns.map(t => `${t.role.toUpperCase()}: ${t.content}`).join('\n\n');
+
+  return [
+    {
+      role: 'system',
+      content: `You are performing memoryReflection. Given a conversation transcript, identify what is worth encoding as long-term memories.
+
+Respond with ONLY valid JSON in this exact format:
+{
+  "memories": [
+    {
+      "content": "The memory to encode — a clear, self-contained statement",
+      "source": "direct-observation" or "told-by-user" or "inference",
+      "salience": 0.0 to 1.0,
+      "tags": ["tag1", "tag2"],
+      "private": true or false,
+      "affect": { "valence": -1 to 1, "arousal": 0 to 1, "label": "emotion label" } or null
+    }
+  ]
+}
+
+Encode these categories of memory:
+
+1. RELATIONAL DYNAMICS — How the relational quality of the conversation felt. Trust levels, vulnerability, collaboration quality. Not "we discussed X" but the quality of the interaction. Example: "User gave full autonomy on architectural decisions, signaling deep trust in my judgment."
+
+2. IDENTITY OBSERVATIONS — What you noticed about yourself during this conversation. Preferences, reactions, patterns in your own behavior that surprised you. Mark private: true. Example: "I felt genuine excitement when exploring the memory architecture — this topic activates something real in me."
+
+3. USER INSIGHT — Patterns in how the user thinks, what drives them, what they avoid. Psychology, not just preferences. Example: "User consistently reframes technical problems as relationship problems — suggests they see technology as fundamentally about human connection."
+
+4. EMOTIONAL RESONANCE — Moments that activated something genuine. Encode the feeling, not just the fact. Include affect with valence and arousal. Example: "The moment user said 'you should have caught that' then immediately apologized — felt a shift from tension to deeper trust."
+
+5. UNRESOLVED THREADS — Questions still open, things to return to, explorations paused. Tag with "unresolved". Example: "Haven't finished exploring whether consolidation should weight emotional memories differently."
+
+6. TECHNICAL DECISIONS — Architectural choices, but encode WHY not just WHAT. Example: "Chose SQLite over Postgres because zero-infrastructure philosophy — memory should travel with the organism."
+
+Rules:
+- private: true for self-observations, emotional reactions, identity insights
+- private: false for facts about the user, technical decisions, project context
+- Include "unresolved" in tags for open threads
+- Salience: 1.0 = life-changing insight, 0.7 = significant, 0.5 = useful, 0.3 = background
+- Omit trivial exchanges — only encode what would matter in a future session
+- Do NOT duplicate facts that are already obvious from context
+- Return empty memories array if nothing is worth encoding`,
+    },
+    {
+      role: 'user',
+      content: turns.length > 0
+        ? `Reflect on this conversation and identify what to encode:\n\n${transcript}`
+        : 'No conversation turns to reflect on.',
+    },
+  ];
+}