@yeaft/webchat-agent 0.1.660 → 0.1.661

package/package.json

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

package/unify/config.js

@@ -315,12 +315,13 @@ export function loadConfig(overrides = {}) {
     // don't pollute the flat config namespace used by chat/crew code.
     unify: normaliseUnifySection(jsonConfig.unify),
 
-    // DESIGN-v2 feature flag. When true the session wires the v2 dream
-    // pipeline (dream-v2/runner.js) and opens the FTS5 SegmentIndex used
-    // by the engine's pre-turn recall (groups/pre-flow.js →
-    // memory/preflow.js). PR-E flipped the default to true; users who
-    // need the legacy R6 paths can opt out via `"memoryV2": false` in
-    // ~/.yeaft/config.json.
+    // DESIGN-v2 feature flag. When true the session opens the FTS5
+    // SegmentIndex (used by groups/pre-flow.js → memory/preflow.js
+    // for pre-turn recall) and wires the v2 dream pipeline
+    // (dream-v2/runner.js). When false both are skipped — no recall,
+    // no dream — turns still work but without memory injection. The
+    // legacy R6 recall + dream-scheduler paths have been deleted, so
+    // `false` is now a "memory off" kill switch rather than a fallback.
     memoryV2: overrides.memoryV2 !== undefined ? !!overrides.memoryV2
       : (jsonConfig.memoryV2 !== undefined ? !!jsonConfig.memoryV2 : true),
 

package/unify/groups/pre-flow.js

@@ -158,9 +158,8 @@ export function selectRespondingVps(input) {
 /**
  * Build the heading for a single scope's formatted memory block.
  *
- * Mirrors recall-v2's formatRecallV2 heading style so the system
- * prompt looks the same to the LLM whether recall came from FTS
- * (here) or from per-scope file reads (recall-v2).
+ * Heading style is the original recall-v2 format, kept so the system
+ * prompt the LLM sees stays stable across the FTS migration.
  *
  * @param {string} scope
  * @returns {string}

package/unify/memory/keywords.js

@@ -1,9 +1,8 @@
 /**
  * keywords.js — pure-rule keyword extraction shared by memory recall paths.
  *
- * Extracted from the legacy R5 recall.js so recall-v2.js (and any future
- * recall path) can use it without dragging in the rest of the R5 module.
- * Pure CPU, no LLM, <1ms.
+ * Pure CPU, no LLM, <1ms. Used by `groups/pre-flow.js` to derive FTS
+ * query terms from the user message before hitting `memory/preflow.js`.
  */
 
 /** Common stop words filtered out before frequency counting. */

package/unify/session.js

@@ -38,9 +38,7 @@ import { Engine } from './engine.js';
 // as a follow-up.
 import { ensureDefaultGroupIfEmpty } from './groups/group-crud.js';
 import { seedDefaultVps } from './vp/seed-defaults.js';
-import { createDreamScheduler } from './memory/dream-scheduler.js';
 import { createV2DreamScheduler } from './dream-v2/session-wiring.js';
-import { getUserMemoryStore } from './memory/user-memory-store.js';
 import { openSegmentIndex } from './memory/index-db.js';
 import { syncAll as syncSegmentIndex } from './memory/segment-sync.js';
 import { migrateR6toV2 } from './memory/migrate-r6-to-v2.js';
@@ -323,47 +321,21 @@ export async function loadSession(options = {}) {
     yeaftDir,
   });
 
-  // ─── 9a. Create dream scheduler (wave-6b / DESIGN-v2) ──
-  // When config.memoryV2 is on, route through the v2 pipeline (per-scope
-  // memory.md + summary.md). Otherwise keep the legacy R6 dream-scheduler.
-  let dreamScheduler;
-  if (config.memoryV2) {
-    // Build a partial session reference so the v2 wiring can see adapter,
-    // config, yeaftDir, engine, and trace. The scheduler's `run` closure
-    // dereferences these lazily, so mutating the object after this line
-    // (e.g. attaching engine) is safe.
-    const partialSession = {
-      yeaftDir,
-      adapter,
-      config,
-      engine,
-      trace,
-    };
-    dreamScheduler = createV2DreamScheduler(partialSession);
-  } else {
-    dreamScheduler = createDreamScheduler({
-      memoryShardStore,
-      userMemoryStore: getUserMemoryStore(),
-      conversationStore,
-      adapter,
-      config,
-      onDreamStart: (vpId) => {
-        if (config.debug) console.log(`[Yeaft] Dream started for VP ${vpId}`);
-      },
-      onDreamEnd: (vpId, result) => {
-        if (config.debug) console.log(`[Yeaft] Dream ended for VP ${vpId}:`, JSON.stringify({
-          trigger: result.trigger,
-          entriesMerged: result.entriesMerged,
-          entriesPruned: result.entriesPruned,
-          bytesReclaimed: result.bytesReclaimed,
-          errors: result.errors?.length || 0,
-        }));
-      },
-      onError: (vpId, err) => {
-        console.warn(`[Yeaft] Dream error for VP ${vpId}:`, err?.message || err);
-      },
-    });
-  }
+  // ─── 9a. Create dream scheduler (DESIGN-v2) ────────────
+  // The legacy R6 dream-scheduler was retired alongside recall-r6;
+  // dream-v2 is the only active path. The `memoryV2: false` opt-out
+  // no longer leaves a usable system, so we always wire v2 here.
+  // partialSession lets the v2 scheduler dereference adapter/config/
+  // engine/trace lazily — safe because callers attach more fields
+  // after this line.
+  const partialSession = {
+    yeaftDir,
+    adapter,
+    config,
+    engine,
+    trace,
+  };
+  const dreamScheduler = createV2DreamScheduler(partialSession);
 
   // H2.f.5: thread engine registry, input queue, and dispatcher retired.
   // The session exposes a single `engine`; web-bridge calls engine.query()

package/unify/memory/dream-extract.js

@@ -1,381 +0,0 @@
-/**
- * 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

@@ -1,212 +0,0 @@
-/**
- * dream-scheduler.js — wave-6b: idle-timer dream trigger + per-VP orchestration.
- *
- * Responsibilities:
- *   1. Idle timer: fires after 30 min of no user messages if there are
- *      un-ingested (new since last dream) messages in the session.
- *   2. Per-VP dream orchestration: runs dreamShard() per VP, serial within
- *      each VP, max 2 VPs concurrently.
- *   3. Integrates the 334f recompression hook post-dream.
- *   4. Exposes `triggerDreamNow()` for manual "Run dream now" from the UI.
- *
- * Usage (from session.js / web-bridge.js):
- *   const scheduler = createDreamScheduler({ session });
- *   scheduler.noteUserMessage();          // reset idle timer on each user msg
- *   scheduler.triggerDreamNow();          // manual trigger from WS event
- *   scheduler.shutdown();                 // cleanup on session close
- *
- * References:
- *   - 334g dream-shard.js: dreamShard(), scanShards(), runCompactJob()
- *   - 334f recompression.js: checkRecompression()
- *   - PM spec: "30min 无消息 AND 有未 ingest message → 触发"
- */
-
-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
-
-/** Max concurrent VP dream runs. */
-const MAX_CONCURRENT_DREAMS = 2;
-
-/**
- * Create a dream scheduler instance.
- *
- * @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,
- *   onError?: (vpId: string, err: Error) => void,
- * }} opts
- * @returns {DreamScheduler}
- */
-export function createDreamScheduler(opts = {}) {
-  const {
-    memoryShardStore,
-    userMemoryStore,
-    conversationStore,
-    adapter,
-    config,
-    group = null,
-    memoryDir = null,
-    idleMs = DREAM_IDLE_MS,
-    onDreamStart,
-    onDreamEnd,
-    onError,
-  } = opts;
-
-  let idleTimer = null;
-  let messagesSinceLastDream = 0;
-  let dreamRunning = false;
-  let lastDreamAt = 0;
-  let destroyed = false;
-
-  // ── Idle timer management ────────────────────────────────
-
-  function resetIdleTimer() {
-    if (destroyed) return;
-    if (idleTimer) {
-      clearTimeout(idleTimer);
-      idleTimer = null;
-    }
-    if (messagesSinceLastDream > 0) {
-      idleTimer = setTimeout(() => {
-        idleTimer = null;
-        if (messagesSinceLastDream > 0 && !dreamRunning && !destroyed) {
-          runDream('idle').catch(() => {});
-        }
-      }, idleMs);
-      if (idleTimer && typeof idleTimer.unref === 'function') {
-        idleTimer.unref();
-      }
-    }
-  }
-
-  /**
-   * Call on every user message to reset the idle timer and increment
-   * the un-ingested message counter.
-   */
-  function noteUserMessage() {
-    if (destroyed) return;
-    messagesSinceLastDream++;
-    resetIdleTimer();
-  }
-
-  // ── Dream execution ──────────────────────────────────────
-
-  /**
-   * Run a dream cycle. Currently single-VP (Unify default VP), but
-   * structured for future multi-VP with maxConcurrent=2.
-   *
-   * @param {'idle'|'manual'} trigger
-   * @returns {Promise<object>} dream result
-   */
-  async function runDream(trigger = 'manual') {
-    if (dreamRunning) {
-      return { skipped: true, reason: 'already_running' };
-    }
-    if (!memoryShardStore) {
-      return { skipped: true, reason: 'no_shard_store' };
-    }
-    if (!adapter) {
-      return { skipped: true, reason: 'no_adapter' };
-    }
-
-    dreamRunning = true;
-    const vpId = 'default'; // single-VP Unify mode
-
-    try {
-      onDreamStart?.(vpId);
-
-      // Shard-based compact/merge/prune
-      const result = await dreamShard({
-        shardStore: memoryShardStore,
-        adapter,
-        config: { model: config?.primaryModel || config?.model || 'default' },
-        onPhase: (phase, data) => {
-          // Could forward to UI in future
-        },
-      });
-
-      // Post-dream: run recompression hook (334f)
-      try {
-        const recompResult = checkRecompression(memoryShardStore);
-        result.recompression = recompResult;
-      } catch {
-        // 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
-      }
-
-      // Phase 8 PR-F dream-v2 diff-gated scope-summary refresh has been
-      // removed (DESIGN-v2 §13: replaced by 12h / manual trigger model).
-      // The new v2 dream pipeline lives in dream-v2/runner.js, wired via
-      // dream-v2/session-wiring.js when config.memoryV2 is on. This
-      // legacy scheduler only runs for memoryV2=false and is itself
-      // slated for deletion alongside the rest of the R6 stack.
-
-      messagesSinceLastDream = 0;
-      lastDreamAt = Date.now();
-      onDreamEnd?.(vpId, { ...result, trigger });
-
-      return result;
-    } catch (err) {
-      onError?.(vpId, err);
-      return { error: err.message, trigger };
-    } finally {
-      dreamRunning = false;
-    }
-  }
-
-  /**
-   * Manual trigger from UI ("Run dream now" button).
-   * @returns {Promise<object>}
-   */
-  function triggerDreamNow() {
-    return runDream('manual');
-  }
-
-  /**
-   * Cleanup: clear timers, prevent further runs.
-   */
-  function shutdown() {
-    destroyed = true;
-    if (idleTimer) {
-      clearTimeout(idleTimer);
-      idleTimer = null;
-    }
-  }
-
-  return {
-    noteUserMessage,
-    triggerDreamNow,
-    shutdown,
-    get isRunning() { return dreamRunning; },
-    get messagesSinceLastDream() { return messagesSinceLastDream; },
-    get lastDreamAt() { return lastDreamAt; },
-  };
-}
-
-/**
- * @typedef {ReturnType<typeof createDreamScheduler>} DreamScheduler
- */

package/unify/memory/recall.js

@@ -1,247 +0,0 @@
-/**
- * recall.js — 3-step memory recall with fingerprint cache
- *
- * Recall flow (per design doc):
- *   Step 1: Keyword extraction (pure rules, <1ms)
- *   Step 2: Scope + Tags filter (read scopes.md, <5ms) → top 15 candidates
- *   Step 3: LLM select (side-query via adapter.call) → ≤7 most relevant
- *
- * Fingerprint cache:
- *   fingerprint = hash(scope, top 5 keywords, task_id)
- *   Same fingerprint → skip recall, reuse last result
- *
- * Reference: yeaft-unify-core-systems.md §3.2, yeaft-unify-design.md §5.1
- */
-
-import { createHash } from 'crypto';
-import { pickEffort } from '../effort.js';
-
-// ─── Constants ──────────────────────────────────────────────────
-
-/** Max entries returned by recall. */
-const MAX_RECALL_RESULTS = 7;
-
-/** Max candidates passed to LLM select (Step 2 → Step 3). */
-const MAX_CANDIDATES = 15;
-
-// ─── Step 1: Keyword Extraction (pure rules, <1ms) ──────────────
-
-/** Common stop words to filter out. */
-const STOP_WORDS = new Set([
-  'the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
-  'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could',
-  'should', 'may', 'might', 'can', 'shall', 'to', 'of', 'in', 'for',
-  'on', 'with', 'at', 'by', 'from', 'as', 'into', 'through', 'during',
-  'before', 'after', 'above', 'below', 'between', 'out', 'off', 'over',
-  'under', 'again', 'further', 'then', 'once', 'here', 'there', 'when',
-  'where', 'why', 'how', 'all', 'both', 'each', 'few', 'more', 'most',
-  'other', 'some', 'such', 'no', 'nor', 'not', 'only', 'own', 'same',
-  'so', 'than', 'too', 'very', 'just', 'because', 'but', 'and', 'or',
-  'if', 'while', 'about', 'up', 'it', 'its', 'my', 'me', 'i', 'you',
-  'your', 'we', 'our', 'they', 'them', 'their', 'this', 'that', 'what',
-  'which', 'who', 'whom', 'these', 'those',
-  // Chinese stop words
-  '的', '了', '在', '是', '我', '有', '和', '就', '不', '人', '都',
-  '一', '一个', '上', '也', '很', '到', '说', '要', '去', '你', '会',
-  '着', '没有', '看', '好', '自己', '这', '他', '她', '吗', '呢', '吧',
-  '把', '被', '那', '它', '让', '给', '可以', '什么', '怎么', '帮',
-  '帮我', '请', '能', '想',
-]);
-
-/**
- * Extract keywords from a prompt (pure rules, no LLM).
- *
- * @param {string} prompt
- * @returns {string[]} — keywords sorted by relevance (simple freq)
- */
-export function extractKeywords(prompt) {
-  if (!prompt || !prompt.trim()) return [];
-
-  // Tokenize: split on whitespace and punctuation (keep CJK chars)
-  const tokens = prompt
-    .toLowerCase()
-    .replace(/[^\w\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff]+/g, ' ')
-    .split(/\s+/)
-    .filter(t => t.length > 1 && !STOP_WORDS.has(t));
-
-  // Count frequencies
-  const freq = new Map();
-  for (const t of tokens) {
-    freq.set(t, (freq.get(t) || 0) + 1);
-  }
-
-  // Sort by frequency descending, then alphabetically
-  return [...freq.entries()]
-    .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
-    .map(([word]) => word);
-}
-
-// ─── Fingerprint Cache ──────────────────────────────────────────
-
-/**
- * Compute a recall fingerprint for cache checking.
- *
- * @param {{ scope?: string, keywords: string[], taskId?: string }} params
- * @returns {string} — hex hash
- */
-export function computeFingerprint({ scope = '', keywords, taskId = '' }) {
-  const top5 = keywords.slice(0, 5).join(',');
-  const input = `${scope}|${top5}|${taskId}`;
-  return createHash('sha256').update(input).digest('hex').slice(0, 16);
-}
-
-// ─── Step 2: Scope + Tags Filter ────────────────────────────────
-
-/**
- * Filter entries by scope and tags (in-memory, no LLM).
- * Uses MemoryStore.findByFilter internally.
- *
- * @param {import('./store.js').MemoryStore} memoryStore
- * @param {{ scope?: string, keywords: string[] }} params
- * @returns {object[]} — top MAX_CANDIDATES entries
- */
-function filterCandidates(memoryStore, { scope, keywords }) {
-  return memoryStore.findByFilter({
-    scope,
-    tags: keywords,
-    limit: MAX_CANDIDATES,
-  });
-}
-
-// ─── Step 3: LLM Select ────────────────────────────────────────
-
-/**
- * Use LLM side-query to select the most relevant entries.
- *
- * @param {object} adapter — LLM adapter with .call() method
- * @param {object} config — { model }
- * @param {string} prompt — user's prompt
- * @param {object[]} candidates — entries with frontmatter
- * @returns {Promise<string[]>} — selected entry names
- */
-async function llmSelect(adapter, config, prompt, candidates) {
-  if (candidates.length <= MAX_RECALL_RESULTS) {
-    // No need to filter if already under limit
-    return candidates.map(c => c.name);
-  }
-
-  const candidateList = candidates.map((c, i) =>
-    `${i + 1}. [${c.name}] kind=${c.kind}, scope=${c.scope}, tags=[${(c.tags || []).join(', ')}]`
-  ).join('\n');
-
-  const system = `You are a memory retrieval assistant. Given a user's prompt and a list of memory entries, select the most relevant ones (up to ${MAX_RECALL_RESULTS}).
-Return ONLY a JSON array of entry names, like: ["entry-name-1", "entry-name-2"]
-No explanation, just the JSON array.`;
-
-  const messages = [{
-    role: 'user',
-    content: `User prompt: "${prompt}"
-
-Memory entries:
-${candidateList}
-
-Select the ${MAX_RECALL_RESULTS} most relevant entries. Return a JSON array of entry names.`,
-  }];
-
-  try {
-    const result = await adapter.call({
-      model: config.model,
-      system,
-      messages,
-      maxTokens: 512,
-      // task-327c: recall step-3 is a cheap classifier pass (pick N out of
-      // 15 candidates). Flag 'low' so supported models skip deep reasoning.
-      effort: pickEffort({ scenario: 'recall' }),
-    });
-
-    // Parse the JSON array from the response
-    const text = result.text.trim();
-    const jsonMatch = text.match(/\[[\s\S]*\]/);
-    if (jsonMatch) {
-      const names = JSON.parse(jsonMatch[0]);
-      return names.filter(n => typeof n === 'string');
-    }
-  } catch {
-    // Fallback: return all candidates if LLM fails
-  }
-
-  return candidates.slice(0, MAX_RECALL_RESULTS).map(c => c.name);
-}
-
-// ─── Main Recall Function ───────────────────────────────────────
-
-/** @type {Map<string, { entries: object[], timestamp: number }>} */
-const _cache = new Map();
-
-/** Cache TTL — 5 minutes. */
-const CACHE_TTL = 5 * 60 * 1000;
-
-/**
- * Recall relevant memory entries for a given prompt.
- *
- * 3-step process:
- *   1. Extract keywords (rules, <1ms)
- *   2. Scope + Tags filter → top 15 candidates
- *   3. LLM select → ≤7 entries (skipped if ≤7 candidates)
- *
- * Uses fingerprint cache to skip repeat recalls.
- *
- * @param {{ prompt: string, adapter: object, config: object, memoryStore: import('./store.js').MemoryStore, scope?: string, taskId?: string }} params
- * @returns {Promise<{ entries: object[], keywords: string[], fingerprint: string, cached: boolean }>}
- */
-export async function recall({ prompt, adapter, config, memoryStore, scope, taskId }) {
-  // Step 1: Extract keywords
-  const keywords = extractKeywords(prompt);
-
-  if (keywords.length === 0) {
-    return { entries: [], keywords: [], fingerprint: '', cached: false };
-  }
-
-  // Check fingerprint cache
-  const fingerprint = computeFingerprint({ scope, keywords, taskId });
-
-  const cached = _cache.get(fingerprint);
-  if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
-    return { entries: cached.entries, keywords, fingerprint, cached: true };
-  }
-
-  // Step 2: Scope + Tags filter
-  const candidates = filterCandidates(memoryStore, { scope, keywords });
-
-  if (candidates.length === 0) {
-    _cache.set(fingerprint, { entries: [], timestamp: Date.now() });
-    return { entries: [], keywords, fingerprint, cached: false };
-  }
-
-  // Step 3: LLM select (only if > MAX_RECALL_RESULTS candidates)
-  let selectedNames;
-  if (candidates.length <= MAX_RECALL_RESULTS) {
-    selectedNames = candidates.map(c => c.name);
-  } else {
-    selectedNames = await llmSelect(adapter, config, prompt, candidates);
-  }
-
-  // Load full entries for selected names
-  const entries = [];
-  for (const name of selectedNames) {
-    const slug = name.toLowerCase().replace(/[^a-z0-9\u4e00-\u9fff-]+/g, '-').replace(/^-+|-+$/g, '');
-    const entry = memoryStore.readEntry(slug) || memoryStore.readEntry(name);
-    if (entry) {
-      entries.push(entry);
-      // Bump frequency
-      memoryStore.bumpFrequency(slug || name);
-    }
-  }
-
-  // Update cache
-  _cache.set(fingerprint, { entries, timestamp: Date.now() });
-
-  return { entries, keywords, fingerprint, cached: false };
-}
-
-/**
- * Clear the recall cache. Useful for testing.
- */
-export function clearRecallCache() {
-  _cache.clear();
-}

package/unify/memory/recompression.js

@@ -1,122 +0,0 @@
-/**
- * recompression.js — task-334f Re-compression hook.
- *
- * Provides `checkRecompression(memoryShardStore)` which inspects each shard's
- * utilization (live entry bytes vs total shard file bytes). When utilization
- * drops below 50% (configurable), the shard is compacted in-place.
- *
- * This is designed to be called:
- *   - After `remove()` calls (which leave tombstone gaps)
- *   - After `supersede()` chains (old entries inflate shard size)
- *   - By dream (334g) on its periodic sweep
- *
- * The hook does NOT make deletion decisions — it only reclaims dead space.
- * Dream owns the "what to delete" logic; this module owns "when to defrag".
- *
- * Reference: §Δ17.5 Compact job / §Δ26.3 soft-cap semantics.
- */
-
-/** Default utilization threshold below which a shard gets compacted. */
-export const DEFAULT_UTILIZATION_THRESHOLD = 0.5;
-
-/**
- * Inspect all shards in a memory shard store and compact any whose
- * utilization ratio (live entry bytes / total shard bytes) is below
- * the threshold.
- *
- * @param {object} store — opened via `openMemoryShardStore()`
- * @param {{ threshold?: number }} [opts]
- * @returns {{ compacted: string[], skipped: string[], stats: Record<string, { entries: number, bytes: number, liveBytes: number, utilization: number }> }}
- */
-export function checkRecompression(store, opts = {}) {
-  if (!store || typeof store.stats !== 'function') {
-    return { compacted: [], skipped: [], stats: {} };
-  }
-
-  const threshold = opts.threshold ?? DEFAULT_UTILIZATION_THRESHOLD;
-  const { shards, count } = store.stats();
-  const compacted = [];
-  const skipped = [];
-  const shardStats = {};
-
-  for (const [name, bucket] of Object.entries(shards)) {
-    const totalBytes = bucket.bytes || 0;
-    const entryCount = bucket.entries || 0;
-
-    // Estimate live bytes from the index: sum of all entry byteLen for this shard.
-    // The inner store's query returns records with meta but not byteLen directly.
-    // Use the stats bucket which tracks entry count and total file bytes.
-    // A shard with 0 entries but >0 bytes is 0% utilization → compact.
-    // A shard with entries but totalBytes=0 is fine (no file yet).
-    if (totalBytes === 0) {
-      shardStats[name] = { entries: entryCount, bytes: 0, liveBytes: 0, utilization: 1.0 };
-      skipped.push(name);
-      continue;
-    }
-
-    // For utilization, we use inner store's index to sum live entry byte lengths.
-    const inner = store._innerForTest;
-    let liveBytes = 0;
-    if (inner && typeof inner.getIndex === 'function') {
-      const index = inner.getIndex();
-      for (const rec of index.entries) {
-        if (rec.shard === name) liveBytes += (rec.byteLen || 0);
-      }
-    } else {
-      // Fallback: assume fully utilized if we can't inspect
-      liveBytes = totalBytes;
-    }
-
-    const utilization = liveBytes / totalBytes;
-    shardStats[name] = { entries: entryCount, bytes: totalBytes, liveBytes, utilization };
-
-    if (utilization < threshold && entryCount > 0) {
-      // Compact via the underlying shard store
-      if (inner && typeof inner.compact === 'function') {
-        inner.compact(name);
-        compacted.push(name);
-      }
-    } else {
-      skipped.push(name);
-    }
-  }
-
-  return { compacted, skipped, stats: shardStats };
-}
-
-/**
- * Check if any shard needs recompression without actually doing it.
- * Returns the list of shard names that would be compacted.
- *
- * @param {object} store
- * @param {{ threshold?: number }} [opts]
- * @returns {string[]} — shard names below utilization threshold
- */
-export function needsRecompression(store, opts = {}) {
-  if (!store || typeof store.stats !== 'function') return [];
-
-  const threshold = opts.threshold ?? DEFAULT_UTILIZATION_THRESHOLD;
-  const { shards } = store.stats();
-  const result = [];
-
-  const inner = store._innerForTest;
-  if (!inner || typeof inner.getIndex !== 'function') return [];
-
-  const index = inner.getIndex();
-
-  for (const [name, bucket] of Object.entries(shards)) {
-    const totalBytes = bucket.bytes || 0;
-    if (totalBytes === 0 || (bucket.entries || 0) === 0) continue;
-
-    let liveBytes = 0;
-    for (const rec of index.entries) {
-      if (rec.shard === name) liveBytes += (rec.byteLen || 0);
-    }
-
-    if (liveBytes / totalBytes < threshold) {
-      result.push(name);
-    }
-  }
-
-  return result;
-}