@yeaft/webchat-agent 0.1.548 → 0.1.550

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.548",
+  "version": "0.1.550",
   "description": "Remote agent for Yeaft WebChat — connects worker machines to the central server",
   "main": "index.js",
   "type": "module",

package/unify/engine.js

@@ -23,6 +23,7 @@ import { LLMContextError, LLMAbortError } from './llm/adapter.js';
 import { recallR6, formatForInjection } from './memory/recall-r6.js';
 import { shouldConsolidate, consolidate } from './memory/consolidate.js';
 import { buildMemoryInjection } from './memory/layout.js';
+import { buildUserProfile } from './memory/user-memory-store.js';
 import { runStopHooks } from './stop-hooks.js';
 import { getThreadStore, MAIN_THREAD_ID } from './threads/store.js';
 import { pickEffort, parseEffortPrefix } from './effort.js';
@@ -293,9 +294,10 @@ export class Engine {
    * @param {string} [compactSummary]
    * @param {string} [prompt] — user prompt (for skill relevance matching)
    * @param {string} [memoryInjection] — task-287: prebuilt memory block (index + prefs + project)
+   * @param {string} [userProfile] — user profile from user-memory shard store
    * @returns {string}
    */
-  #buildSystemPrompt(memory, compactSummary, prompt, memoryInjection) {
+  #buildSystemPrompt(memory, compactSummary, prompt, memoryInjection, userProfile) {
     // Get relevant skill content if SkillManager is wired
     let skillContent = '';
     if (this.#skillManager && prompt) {
@@ -314,6 +316,7 @@ export class Engine {
       memoryInjection,
       compactSummary,
       skillContent,
+      userProfile,
       // task-334f: memory_trace tool is now registered (49 → 51 tools), so
       // unlock the core_memory meta-line behind 334e's feature flag.
       memoryTraceAvailable: true,
@@ -359,9 +362,20 @@ export class Engine {
   async #recallMemory(prompt) {
     const memory = { profile: '', entries: [], formatted: '' };
 
-    // Read user profile from legacy store if available
-    if (this.#memoryStore) {
-      memory.profile = this.#memoryStore.readProfile();
+    // Build user profile from user-memory shard store (R6 path),
+    // falling back to legacy readProfile if shard store unavailable.
+    try {
+      const profile = buildUserProfile(this.#memoryShardStore);
+      if (profile) {
+        memory.profile = profile;
+      } else if (this.#memoryStore) {
+        memory.profile = this.#memoryStore.readProfile();
+      }
+    } catch {
+      // Non-critical — fall through to legacy
+      if (this.#memoryStore) {
+        try { memory.profile = this.#memoryStore.readProfile(); } catch { /* */ }
+      }
     }
 
     // R6 shard-based recall (preferred path)
@@ -603,7 +617,8 @@ export class Engine {
     }
 
     const compactSummary = this.#getCompactSummary();
-    const systemPrompt = this.#buildSystemPrompt(undefined, compactSummary, prompt, memoryInjection);
+    const userProfile = recallResult?.profile || '';
+    const systemPrompt = this.#buildSystemPrompt(undefined, compactSummary, prompt, memoryInjection, userProfile);
 
     // Build conversation: existing messages + new user message
     const conversationMessages = [

package/unify/memory/dream-extract.js

@@ -0,0 +1,381 @@
+/**
+ * dream-extract.js — R6 §Δ26 Phase A: Extract memories from conversation.
+ *
+ * Reads un-ingested messages from the group coordinator JSONL log,
+ * calls the LLM to extract memory-worthy candidates, then deduplicates
+ * each candidate against the existing shard store before writing.
+ *
+ * Watermark: tracks the last-ingested message id in a JSON file
+ * at `<memoryDir>/extract-watermark.json`.
+ *
+ * Dedup classification per candidate:
+ *   - is_duplicate → skip (already exists)
+ *   - is_update    → supersede old entry with new
+ *   - is_new       → write fresh entry
+ */
+
+import { existsSync, readFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { randomUUID } from 'crypto';
+import { writeAtomic } from '../storage/index.js';
+import { pickEffort } from '../effort.js';
+import { classifyUserMemoryShard } from './user-memory-store.js';
+
+// ─── Watermark ────────────────────────────────────────────────
+
+const WATERMARK_FILE = 'extract-watermark.json';
+
+/**
+ * Read the extract watermark (last processed message id).
+ * @param {string} memoryDir
+ * @returns {{ lastMsgId: string|null, lastTs: string|null }}
+ */
+export function readWatermark(memoryDir) {
+  const p = join(memoryDir, WATERMARK_FILE);
+  if (!existsSync(p)) return { lastMsgId: null, lastTs: null };
+  try {
+    return JSON.parse(readFileSync(p, 'utf8'));
+  } catch {
+    return { lastMsgId: null, lastTs: null };
+  }
+}
+
+/**
+ * Write the extract watermark.
+ * @param {string} memoryDir
+ * @param {{ lastMsgId: string, lastTs: string }} wm
+ */
+export function writeWatermark(memoryDir, wm) {
+  if (!existsSync(memoryDir)) mkdirSync(memoryDir, { recursive: true });
+  writeAtomic(join(memoryDir, WATERMARK_FILE), JSON.stringify(wm, null, 2));
+}
+
+// ─── Message Collection ───────────────────────────────────────
+
+/**
+ * Collect messages from the group log that are newer than the watermark.
+ *
+ * @param {import('../groups/group-store.js').GroupHandle} group
+ * @param {{ lastMsgId: string|null }} watermark
+ * @param {{ maxMessages?: number }} [opts]
+ * @returns {{ messages: object[], lastMsg: object|null }}
+ */
+export function collectNewMessages(group, watermark, opts = {}) {
+  const max = opts.maxMessages || 200;
+  const messages = [];
+  let pastWatermark = !watermark.lastMsgId; // if no watermark, take all
+  let lastMsg = null;
+
+  for (const msg of group.streamMessages()) {
+    if (!pastWatermark) {
+      if (msg.id === watermark.lastMsgId) {
+        pastWatermark = true;
+      }
+      continue;
+    }
+    // Only include user and assistant messages (skip system/meta)
+    if (msg.role === 'user' || msg.role === 'assistant') {
+      messages.push(msg);
+      lastMsg = msg;
+    }
+    if (messages.length >= max) break;
+  }
+
+  return { messages, lastMsg };
+}
+
+// ─── LLM Extraction ──────────────────────────────────────────
+
+/**
+ * Build the extraction prompt for dream-extract.
+ * Reuses the pattern from extract.js but outputs R6-compatible entries.
+ */
+function buildDreamExtractionPrompt(messages) {
+  const conversation = messages.map(m => {
+    const prefix = m.role === 'user' ? 'User' : 'Assistant';
+    const text = typeof m.text === 'string' ? m.text : String(m.text || '');
+    return `[${prefix}]: ${text}`;
+  }).join('\n\n');
+
+  return `Analyze the following conversation and extract any information worth saving to long-term memory.
+
+For each memory, provide:
+- **body**: 1-3 sentences describing the memory (concise, factual)
+- **kind**: One of: fact, preference, skill, lesson, context, relation
+- **tags**: Relevant keywords as a string array
+- **importance**: "high", "normal", or "low"
+
+Memory kinds:
+- fact: Objective facts about the user or their work
+- preference: User preferences (coding style, tools, habits)
+- skill: Techniques or patterns the user uses or is learning
+- lesson: Lessons learned, pitfalls, debugging insights
+- context: Current project context, OKRs, deadlines
+- relation: People, teams, roles the user mentions
+
+Do NOT extract:
+- Specific code snippets (too large, become stale)
+- Temporary debugging info
+- Trivial greetings or small talk
+- Information already obviously known (like "user asked me a question")
+
+Return a JSON array. If nothing is worth remembering, return [].
+
+Conversation:
+${conversation}`;
+}
+
+/**
+ * Call LLM to extract memory candidates from messages.
+ *
+ * @param {{ messages: object[], adapter: object, config: object }} params
+ * @returns {Promise<object[]>} — extracted candidates
+ */
+export async function extractCandidates({ messages, adapter, config }) {
+  if (!messages || messages.length === 0) return [];
+
+  const system = 'You are a memory extraction assistant. Analyze conversations and extract important facts, preferences, and lessons. Return ONLY a valid JSON array, no other text.';
+  const prompt = buildDreamExtractionPrompt(messages);
+
+  try {
+    const result = await adapter.call({
+      model: config.model || config.primaryModel || 'default',
+      system,
+      messages: [{ role: 'user', content: prompt }],
+      maxTokens: 2048,
+      effort: pickEffort({ scenario: 'consolidate' }),
+    });
+
+    const text = (result.text || '').trim();
+    const jsonMatch = text.match(/\[[\s\S]*\]/);
+    if (!jsonMatch) return [];
+
+    const entries = JSON.parse(jsonMatch[0]);
+    return entries
+      .filter(e => e && typeof e === 'object' && e.body)
+      .map(e => ({
+        body: String(e.body).slice(0, 500),
+        kind: ['fact', 'preference', 'skill', 'lesson', 'context', 'relation'].includes(e.kind) ? e.kind : 'fact',
+        tags: Array.isArray(e.tags) ? e.tags.map(String) : [],
+        importance: ['high', 'normal', 'low'].includes(e.importance) ? e.importance : 'normal',
+      }));
+  } catch {
+    return [];
+  }
+}
+
+// ─── Dedup / Similarity ──────────────────────────────────────
+
+/**
+ * Classify a candidate against existing shard entries.
+ *
+ * Simple heuristic (no LLM): normalized text overlap.
+ *   - Exact body match → is_duplicate
+ *   - >60% word overlap with existing → is_update (supersede)
+ *   - Otherwise → is_new
+ *
+ * @param {object} candidate — { body, kind, tags }
+ * @param {object[]} existingEntries — thin entries with body loaded
+ * @returns {{ action: 'is_duplicate'|'is_update'|'is_new', matchId?: string }}
+ */
+export function classifyCandidate(candidate, existingEntries) {
+  if (!candidate || !candidate.body) return { action: 'is_new' };
+  if (!existingEntries || existingEntries.length === 0) return { action: 'is_new' };
+
+  const candWords = normalizeWords(candidate.body);
+  if (candWords.size === 0) return { action: 'is_new' };
+
+  let bestOverlap = 0;
+  let bestId = null;
+
+  for (const entry of existingEntries) {
+    const entryBody = entry.body || '';
+    if (!entryBody) continue;
+
+    // Exact match
+    if (entryBody.trim().toLowerCase() === candidate.body.trim().toLowerCase()) {
+      return { action: 'is_duplicate', matchId: entry.id };
+    }
+
+    // Word overlap
+    const entryWords = normalizeWords(entryBody);
+    if (entryWords.size === 0) continue;
+    let overlap = 0;
+    for (const w of candWords) {
+      if (entryWords.has(w)) overlap++;
+    }
+    const ratio = overlap / Math.max(candWords.size, entryWords.size);
+    if (ratio > bestOverlap) {
+      bestOverlap = ratio;
+      bestId = entry.id;
+    }
+  }
+
+  if (bestOverlap > 0.6 && bestId) {
+    return { action: 'is_update', matchId: bestId };
+  }
+  return { action: 'is_new' };
+}
+
+function normalizeWords(text) {
+  return new Set(
+    text.toLowerCase().replace(/[^\w\s]/g, '').split(/\s+/).filter(w => w.length > 2)
+  );
+}
+
+// ─── Main Entry Point ────────────────────────────────────────
+
+/**
+ * Run dream extract: read new messages, LLM extract, dedup, write.
+ *
+ * @param {{
+ *   group: import('../groups/group-store.js').GroupHandle,
+ *   shardStore: object,
+ *   adapter: object,
+ *   config: object,
+ *   memoryDir: string,
+ *   onPhase?: (phase: string, data: any) => void,
+ *   maxMessages?: number,
+ * }} opts
+ * @returns {Promise<DreamExtractResult>}
+ */
+export async function dreamExtract(opts) {
+  const { group, shardStore, adapter, config, memoryDir, onPhase, maxMessages } = opts;
+
+  const result = {
+    messagesRead: 0,
+    candidatesExtracted: 0,
+    written: 0,
+    updated: 0,
+    duplicatesSkipped: 0,
+    errors: [],
+  };
+
+  if (!group || !shardStore || !adapter) {
+    return result;
+  }
+
+  try {
+    // 1. Read watermark + collect new messages
+    onPhase?.('collect', 'starting');
+    const wm = readWatermark(memoryDir);
+    const { messages, lastMsg } = collectNewMessages(group, wm, { maxMessages });
+    result.messagesRead = messages.length;
+    onPhase?.('collect', { count: messages.length });
+
+    if (messages.length === 0) return result;
+
+    // 2. LLM extraction
+    onPhase?.('extract', 'starting');
+    const candidates = await extractCandidates({ messages, adapter, config });
+    result.candidatesExtracted = candidates.length;
+    onPhase?.('extract', { count: candidates.length });
+
+    if (candidates.length === 0) {
+      // Still advance watermark — we read the messages, just nothing to extract
+      if (lastMsg) {
+        writeWatermark(memoryDir, { lastMsgId: lastMsg.id, lastTs: lastMsg.ts || new Date().toISOString() });
+      }
+      return result;
+    }
+
+    // 3. Load existing entries for dedup comparison
+    const existingByBody = loadExistingBodies(shardStore);
+
+    // 4. Dedup + write each candidate
+    onPhase?.('dedup', 'starting');
+    for (const candidate of candidates) {
+      try {
+        const classification = classifyCandidate(candidate, existingByBody);
+
+        switch (classification.action) {
+          case 'is_duplicate':
+            result.duplicatesSkipped++;
+            break;
+
+          case 'is_update': {
+            // Supersede old entry
+            const shard = classifyUserMemoryShard(candidate.body, candidate.tags);
+            const newId = `de-${randomUUID().slice(0, 12)}`;
+            shardStore.supersede({
+              newEntry: {
+                id: newId,
+                shard,
+                kind: candidate.kind || 'fact',
+                body: candidate.body,
+                tags: candidate.tags || [],
+                sourceRef: { hint: 'dream-extract' },
+                authoredBy: 'dream:extract',
+              },
+              oldIds: [classification.matchId],
+            });
+            result.updated++;
+            break;
+          }
+
+          case 'is_new':
+          default: {
+            const shard = classifyUserMemoryShard(candidate.body, candidate.tags);
+            const newId = `de-${randomUUID().slice(0, 12)}`;
+            shardStore.put({
+              id: newId,
+              shard,
+              kind: candidate.kind || 'fact',
+              body: candidate.body,
+              tags: candidate.tags || [],
+              sourceRef: { hint: 'dream-extract' },
+              authoredBy: 'dream:extract',
+            });
+            result.written++;
+            break;
+          }
+        }
+      } catch (err) {
+        result.errors.push(`write candidate: ${err.message}`);
+      }
+    }
+    onPhase?.('dedup', { written: result.written, updated: result.updated, skipped: result.duplicatesSkipped });
+
+    // 5. Advance watermark
+    if (lastMsg) {
+      writeWatermark(memoryDir, { lastMsgId: lastMsg.id, lastTs: lastMsg.ts || new Date().toISOString() });
+    }
+
+  } catch (err) {
+    result.errors.push(err.message);
+  }
+
+  return result;
+}
+
+/**
+ * Load all existing entry bodies (for dedup comparison).
+ * Returns array of { id, body } objects.
+ */
+function loadExistingBodies(shardStore) {
+  const entries = [];
+  try {
+    const st = shardStore.stats();
+    for (const shardName of Object.keys(st.shards)) {
+      const { results } = shardStore.query({ shard: shardName });
+      for (const rec of results) {
+        if (rec.supersededBy) continue;
+        const full = shardStore.get(rec.id);
+        if (full && full.body) {
+          entries.push({ id: rec.id, body: full.body });
+        }
+      }
+    }
+  } catch { /* best effort */ }
+  return entries;
+}
+
+/**
+ * @typedef {Object} DreamExtractResult
+ * @property {number} messagesRead
+ * @property {number} candidatesExtracted
+ * @property {number} written
+ * @property {number} updated
+ * @property {number} duplicatesSkipped
+ * @property {string[]} errors
+ */

package/unify/memory/dream-scheduler.js

@@ -23,6 +23,7 @@
 
 import { dreamShard } from './dream-shard.js';
 import { checkRecompression } from './recompression.js';
+import { runUserDreamJob } from './user-memory-store.js';
 
 /** Default idle timeout before dream triggers (ms). */
 export const DREAM_IDLE_MS = 30 * 60 * 1000; // 30 min
@@ -35,8 +36,12 @@ const MAX_CONCURRENT_DREAMS = 2;
  *
  * @param {{
  *   memoryShardStore: object | null,
+ *   userMemoryStore: object | null,
+ *   conversationStore: object | null,
  *   adapter: object | null,
  *   config: object,
+ *   group?: import('../groups/group-store.js').GroupHandle | null,
+ *   memoryDir?: string | null,
  *   idleMs?: number,
  *   onDreamStart?: (vpId: string) => void,
  *   onDreamEnd?: (vpId: string, result: object) => void,
@@ -47,8 +52,12 @@ const MAX_CONCURRENT_DREAMS = 2;
 export function createDreamScheduler(opts = {}) {
   const {
     memoryShardStore,
+    userMemoryStore,
+    conversationStore,
     adapter,
     config,
+    group = null,
+    memoryDir = null,
     idleMs = DREAM_IDLE_MS,
     onDreamStart,
     onDreamEnd,
@@ -118,6 +127,7 @@ export function createDreamScheduler(opts = {}) {
     try {
       onDreamStart?.(vpId);
 
+      // Shard-based compact/merge/prune
       const result = await dreamShard({
         shardStore: memoryShardStore,
         adapter,
@@ -135,6 +145,19 @@ export function createDreamScheduler(opts = {}) {
         // Non-fatal
       }
 
+      // Post-dream: run user-memory extract + compact (334-w7b)
+      try {
+        const userDreamResult = await runUserDreamJob({
+          store: userMemoryStore || undefined,
+          conversationStore: conversationStore || undefined,
+          adapter: adapter || undefined,
+          config: { model: config?.primaryModel || config?.model || 'default' },
+        });
+        result.userDream = userDreamResult;
+      } catch {
+        // Non-fatal
+      }
+
       messagesSinceLastDream = 0;
       lastDreamAt = Date.now();
       onDreamEnd?.(vpId, { ...result, trigger });

package/unify/memory/user-memory-store.js

@@ -15,10 +15,11 @@
 import { homedir } from 'os';
 import { join } from 'path';
 import { randomUUID } from 'crypto';
-import { existsSync } from 'fs';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { openMemoryShardStore } from './shard-store.js';
 import { USER_SHARDS } from './schema.js';
 import { scanShards, runCompactJob } from './dream-shard.js';
+import { pickEffort } from '../effort.js';
 
 /** Default storage root for user memory. */
 export const USER_MEMORY_DIR = join(homedir(), '.yeaft', 'user', 'memory');
@@ -193,19 +194,45 @@ export function buildUserProfile(store, opts = {}) {
 // ─── Dream Job ───────────────────────────────────────────────
 
 /**
- * Run user-memory dream maintenance (compact low-utilization shards).
- * Reuses dream-shard.js compact framework — no LLM calls needed for
- * user-memory (user-authored entries don't need merge/prune by an LLM;
- * we only compact to reclaim superseded/removed tombstones).
+ * Run user-memory dream maintenance: extract phase + compact.
+ * Extract reads conversation messages since the last watermark, uses LLM to
+ * identify user-relevant facts, then writes them to the appropriate shards.
+ * Compact phase reclaims superseded/removed tombstones (unchanged from 334g).
  *
- * @param {{ store?: object, onPhase?: (phase:string, data:any) => void }} [opts]
- * @returns {{ scan: object, compact: object } | null}
+ * @param {{
+ *   store?: object,
+ *   conversationStore?: object,
+ *   adapter?: object,
+ *   config?: object,
+ *   onPhase?: (phase: string, data: any) => void,
+ * }} [opts]
+ * @returns {Promise<{ extract: object|null, scan: object, compact: object } | null>}
  */
-export function runUserDreamJob(opts = {}) {
+export async function runUserDreamJob(opts = {}) {
   const store = 'store' in opts ? opts.store : getUserMemoryStore();
   if (!store) return null;
 
+  let extractResult = null;
+
   try {
+    // ── Phase 1: Extract (LLM) ─────────────────────────────
+    if (opts.conversationStore && opts.adapter && opts.config) {
+      opts.onPhase?.('extract', 'starting');
+      try {
+        extractResult = await dreamExtract({
+          store,
+          conversationStore: opts.conversationStore,
+          adapter: opts.adapter,
+          config: opts.config,
+        });
+        opts.onPhase?.('extract', extractResult);
+      } catch (err) {
+        console.warn('[user-memory-store] extract phase failed:', err.message);
+        extractResult = { error: err.message, extracted: 0 };
+      }
+    }
+
+    // ── Phase 2: Compact ───────────────────────────────────
     const scan = scanShards(store);
     const compact = runCompactJob({
       shardStore: store,
@@ -214,9 +241,212 @@ export function runUserDreamJob(opts = {}) {
         ? (shard, r) => opts.onPhase('compact', { shard, ...r })
         : undefined,
     });
-    return { scan: { totalEntries: scan.totalEntries, totalBytes: scan.totalBytes }, compact };
+    return {
+      extract: extractResult,
+      scan: { totalEntries: scan.totalEntries, totalBytes: scan.totalBytes },
+      compact,
+    };
   } catch (err) {
     console.warn('[user-memory-store] dream job failed:', err.message);
     return null;
   }
 }
+
+// ─── Watermark ──────────────────────────────────────────────
+
+/**
+ * Watermark format (shared with 334-w7b):
+ *   { lastMessageId: string, lastMessageTs: number, updatedAt: string }
+ *
+ * Stored at <storeDir>/.watermark.json (alongside shard files).
+ */
+
+const WATERMARK_FILE = '.watermark.json';
+
+/**
+ * Read the extract watermark for a user-memory store.
+ * Returns null if no watermark exists yet.
+ *
+ * @param {string} dir — store directory (e.g. ~/.yeaft/user/memory)
+ * @returns {{ lastMessageId: string, lastMessageTs: number, updatedAt: string } | null}
+ */
+export function readWatermark(dir) {
+  try {
+    const p = join(dir, WATERMARK_FILE);
+    if (!existsSync(p)) return null;
+    return JSON.parse(readFileSync(p, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Write the extract watermark.
+ *
+ * @param {string} dir
+ * @param {{ lastMessageId: string, lastMessageTs: number }} wm
+ */
+export function writeWatermark(dir, wm) {
+  try {
+    const p = join(dir, WATERMARK_FILE);
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(p, JSON.stringify({
+      lastMessageId: wm.lastMessageId,
+      lastMessageTs: wm.lastMessageTs,
+      updatedAt: new Date().toISOString(),
+    }, null, 2));
+  } catch (err) {
+    console.warn('[user-memory-store] writeWatermark failed:', err.message);
+  }
+}
+
+// ─── Extract Phase ──────────────────────────────────────────
+
+/** Max messages to process in a single extract pass. */
+const EXTRACT_MAX_MESSAGES = 50;
+
+/** Min messages required to trigger an extract. */
+const EXTRACT_MIN_MESSAGES = 3;
+
+/**
+ * Build the user-memory extraction prompt.
+ * Tailored for user-relevant facts (not VP/task memory).
+ *
+ * @param {object[]} messages
+ * @returns {string}
+ */
+export function buildUserExtractPrompt(messages) {
+  const conversation = messages.map(m => {
+    const prefix = m.role === 'user' ? 'User' : m.role === 'assistant' ? 'Assistant' : 'System';
+    return `[${prefix}]: ${typeof m.content === 'string' ? m.content : JSON.stringify(m.content)}`;
+  }).join('\n\n');
+
+  return `Analyze the following conversation and extract facts about THE USER that are worth remembering long-term.
+
+Focus on these categories:
+- **profile**: Name, job title, company, location, background, expertise areas
+- **preferences**: Coding style, tool preferences, language preferences, communication style
+- **projects**: Projects they work on, tech stacks, repositories, products
+- **goals**: Current goals, objectives, what they're trying to achieve
+- **relations**: Team members, colleagues, managers, collaborators mentioned
+
+For each fact, provide:
+- **shard**: One of: profile, preferences, projects, goals, relations
+- **body**: 1-2 sentences describing the fact clearly
+- **tags**: 1-3 keyword tags as an array
+
+Do NOT extract:
+- Specific code snippets or technical instructions
+- Temporary debugging context
+- Facts about the assistant (only about the user)
+- Information already implied by the conversation being about coding
+
+Return a JSON array. If nothing about the user is worth remembering, return [].
+
+Conversation:
+${conversation}`;
+}
+
+/**
+ * Extract user-relevant facts from conversation messages and write to user-memory shards.
+ *
+ * @param {{
+ *   store: object,
+ *   conversationStore: object,
+ *   adapter: object,
+ *   config: object,
+ *   dir?: string,
+ * }} params
+ * @returns {Promise<{ extracted: number, skipped: number, watermark: object|null }>}
+ */
+export async function dreamExtract({ store, conversationStore, adapter, config, dir }) {
+  const storeDir = dir || USER_MEMORY_DIR;
+  const wm = readWatermark(storeDir);
+
+  // Load all messages and filter to those after watermark
+  const allMessages = conversationStore.loadAll();
+  let newMessages;
+
+  if (wm && wm.lastMessageId) {
+    const idx = allMessages.findIndex(m => m.id === wm.lastMessageId);
+    newMessages = idx >= 0 ? allMessages.slice(idx + 1) : allMessages;
+  } else {
+    // No watermark — process all messages (first run)
+    newMessages = allMessages;
+  }
+
+  // Filter to user + assistant messages only (skip system)
+  newMessages = newMessages.filter(m => m.role === 'user' || m.role === 'assistant');
+
+  if (newMessages.length < EXTRACT_MIN_MESSAGES) {
+    return { extracted: 0, skipped: 0, watermark: wm };
+  }
+
+  // Cap to prevent huge LLM calls
+  const batch = newMessages.slice(-EXTRACT_MAX_MESSAGES);
+
+  // LLM extraction call
+  const system = 'You are a user profile extraction assistant. Analyze conversations and extract facts about the user. Return ONLY a valid JSON array, no other text.';
+  const prompt = buildUserExtractPrompt(batch);
+
+  let candidates = [];
+  try {
+    const result = await adapter.call({
+      model: config.model || config.primaryModel || 'default',
+      system,
+      messages: [{ role: 'user', content: prompt }],
+      maxTokens: 2048,
+      effort: pickEffort({ scenario: 'dream' }),
+    });
+
+    const text = result.text.trim();
+    const jsonMatch = text.match(/\[[\s\S]*\]/);
+    if (jsonMatch) {
+      candidates = JSON.parse(jsonMatch[0]);
+    }
+  } catch {
+    return { extracted: 0, skipped: 0, watermark: wm, error: 'llm_failed' };
+  }
+
+  if (!Array.isArray(candidates)) {
+    return { extracted: 0, skipped: 0, watermark: wm };
+  }
+
+  // Validate and write candidates
+  let extracted = 0;
+  let skipped = 0;
+
+  for (const c of candidates) {
+    if (!c || typeof c !== 'object' || !c.body) { skipped++; continue; }
+
+    // Use classifyUserMemoryShard if shard not provided or invalid
+    const shard = USER_SHARDS.includes(c.shard)
+      ? c.shard
+      : classifyUserMemoryShard(c.body, c.tags);
+
+    const id = writeUserMemory(store, {
+      text: c.body,
+      tags: Array.isArray(c.tags) ? c.tags.map(String) : [],
+      sourceRef: { origin: 'dream-extract' },
+    });
+
+    if (id) {
+      extracted++;
+    } else {
+      skipped++;
+    }
+  }
+
+  // Update watermark to last processed message
+  const lastMsg = batch[batch.length - 1];
+  if (lastMsg) {
+    const newWm = {
+      lastMessageId: lastMsg.id || '',
+      lastMessageTs: lastMsg.ts || Date.now(),
+    };
+    writeWatermark(storeDir, newWm);
+    return { extracted, skipped, watermark: newWm };
+  }
+
+  return { extracted, skipped, watermark: wm };
+}

package/unify/session.js

@@ -34,6 +34,7 @@ import { initInputQueueStore } from './input-queue/store.js';
 import { createDispatcher } from './pipeline/dispatcher.js';
 import { ensureDefaultGroupIfEmpty } from './groups/group-crud.js';
 import { createDreamScheduler } from './memory/dream-scheduler.js';
+import { getUserMemoryStore } from './memory/user-memory-store.js';
 import { join } from 'path';
 import { existsSync as existsSyncSafe, readFileSync as readFileSyncSafe } from 'fs';
 
@@ -236,6 +237,8 @@ export async function loadSession(options = {}) {
   // ─── 9a. Create dream scheduler (wave-6b) ─────────────
   const dreamScheduler = createDreamScheduler({
     memoryShardStore,
+    userMemoryStore: getUserMemoryStore(),
+    conversationStore,
     adapter,
     config,
     onDreamStart: (vpId) => {