@yeaft/webchat-agent 1.0.575 → 1.0.576

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.575",
+  "version": "1.0.576",
   "description": "Remote worker agent for Yeaft Web Code Agent — connects the native Yeaft engine, CLI providers, and workbench tools",
   "main": "index.js",
   "type": "module",

package/yeaft/cli-session-runner.js

@@ -115,8 +115,8 @@ export function createCliVpEngine(loaded, sessionId, vpId) {
     trace: loaded.trace,
     config: effectiveConfig,
     conversationStore: loaded.conversationStore,
-    memoryIndex: loaded.memoryIndex || null,
-    amsRegistry: loaded.amsRegistry || null,
+    memoryIndex: null,
+    amsRegistry: null,
     toolRegistry: loaded.toolRegistry,
     skillManager: loaded.skillManager,
     mcpManager: loaded.mcpManager,

package/yeaft/cli.js

@@ -480,7 +480,7 @@ async function runREPL(config, args) {
         }
 
         case 'memory': {
-          console.log('Memory commands have been retired. Memory is now managed by Dream V2; use the in-app FTS recall.');
+          console.log('Dream memory is disabled. Historical memory files are retained but are not loaded automatically.');
           break;
         }
 

package/yeaft/config.js

@@ -545,7 +545,9 @@ export function loadConfig(overrides = {}) {
     yeaft: normaliseYeaftSection(jsonConfig.yeaft),
     telemetry: normaliseTelemetrySection(jsonConfig.telemetry),
     workCenter: { enabled: jsonConfig.workCenter?.enabled === true },
-    dream: { enabled: jsonConfig.dream?.enabled === true },
+    // Dream runtime is disabled. Keep the stable shape but never honor a
+    // persisted toggle from an older client.
+    dream: { enabled: false },
     browserRuntime: normaliseBrowserRuntimeSection(jsonConfig.browserRuntime),
 
     // Agent-level tools / skills / MCP server allowlists. Missing fields mean

package/yeaft/debug-trace.js

@@ -18,12 +18,10 @@ import { createInterface } from 'readline';
 const TRACE_VERSION = 3;
 const REQUEST_RETENTION = 10;
 const MAX_HISTORY_LIMIT = 5;
-const MAX_DREAM_EVENTS = 100;
 // Debug records are diagnostic source data. They deliberately do not inherit
 // model-context or ordinary history budgets, and explicit detail transport is
 // chunked instead of truncating persisted values.
 const TRACE_APPEND_BATCH_MS = 100;
-const EVENT_FLUSH_INTERVAL_MS = 30_000;
 const MAX_SEARCH_PATTERN_CHARS = 300;
 
 function isPlainObject(value) {
@@ -924,23 +922,6 @@ export class DebugTrace {
   #appendTimer = null;
   /** @type {number} */
   #sequence = 0;
-  /**
-   * In-memory dream/event ring (authoritative copy; persisted async).
-   * @type {Array<object>}
-   */
-  #events = [];
-  /** @type {boolean} */
-  #eventsDirty = false;
-  /**
-   * Whether the on-disk events.json has been folded into #events yet. The
-   * events ring must merge prior-run history exactly once before any flush
-   * overwrites the file, or a live append landing before first hydrate would
-   * silently destroy cross-restart dream history.
-   * @type {boolean}
-   */
-  #eventsHydrated = false;
-  /** @type {NodeJS.Timeout|null} */
-  #eventFlushTimer = null;
   /**
    * One-time metadata hydrate guard. Reads/maintenance keep only bounded
    * request headers resident. Full loop/tool payloads are loaded for one
@@ -1102,32 +1083,10 @@ export class DebugTrace {
     return id;
   }
 
-  logEvent({ traceId, eventType, eventData = null } = {}) {
-    const id = randomUUID();
-    if (!this.#acceptingWrites) return id;
-    // In-memory authoritative ring; persisted async (fire-and-forget). The
-    // dream/event sink runs on the engine hot path, so it must not block on a
-    // synchronous read-modify-write of events.json.
-    this.#events.push({
-      id,
-      traceId: traceId || String(eventType || 'event'),
-      eventType: eventType || 'event',
-      eventData: cloneJsonValue(eventData),
-      createdAt: Date.now(),
-    });
-    if (this.#events.length > MAX_DREAM_EVENTS) {
-      this.#events = this.#events.slice(-MAX_DREAM_EVENTS);
-    }
-    this.#scheduleEventFlush();
-    return id;
-  }
-
-  event(eventType, eventData = null) {
-    const traceId = (eventData && typeof eventData === 'object' && (eventData.turnId || eventData.runId))
-      ? String(eventData.turnId || eventData.runId)
-      : String(eventType || 'event');
-    return this.logEvent({ traceId, eventType, eventData });
-  }
+  // The global events.json ring belonged to Dream. Keep these call shapes for
+  // compatibility, but never read, append, or rewrite its archived contents.
+  logEvent() { return 'null'; }
+  event() { return 'null'; }
 
   async queryByMessage(messageId) {
     await this.#drainWrites();
@@ -1163,7 +1122,7 @@ export class DebugTrace {
     }
   }
 
-  async fetchTurnDebug({ sessionId, turnId, dreamLimit = 0 } = {}) {
+  async fetchTurnDebug({ sessionId, turnId } = {}) {
     const requestedSessionId = typeof sessionId === 'string' && sessionId ? sessionId : null;
     const requestedTurnId = typeof turnId === 'string' && turnId ? turnId : null;
     if (!requestedSessionId || !requestedTurnId) {
@@ -1193,16 +1152,16 @@ export class DebugTrace {
         }
       }
     }
-    const dreamEvents = this.#readDreamEvents({ sessionId: requestedSessionId, dreamLimit });
+    const dreamEvents = []; // Compatibility shape; retired Dream events are not replayed.
     if (!trace) return { loops: [], turns: [], dreamEvents, detailTurnId: requestedTurnId };
     const expanded = expandTrace(trace);
     return { ...expanded, dreamEvents, detailTurnId: requestedTurnId };
   }
 
-  async fetchRecentDebugHistory({ limit = MAX_HISTORY_LIMIT, dreamLimit = 5, sessionId = null, threadId = null, indexOnly = false, detailTurnId = null, search = '' } = {}) {
+  async fetchRecentDebugHistory({ limit = MAX_HISTORY_LIMIT, sessionId = null, threadId = null, indexOnly = false, detailTurnId = null, search = '' } = {}) {
     const requestedDetailTurnId = typeof detailTurnId === 'string' && detailTurnId ? detailTurnId : null;
     if (requestedDetailTurnId && sessionId) {
-      const detail = await this.fetchTurnDebug({ sessionId, turnId: requestedDetailTurnId, dreamLimit });
+      const detail = await this.fetchTurnDebug({ sessionId, turnId: requestedDetailTurnId });
       return { ...detail, hasMore: false, limit: detail.loops.length, indexOnly: false };
     }
     await this.#drainWrites();
@@ -1212,7 +1171,7 @@ export class DebugTrace {
       .map(({ trace }) => trace)
       .filter(trace => !threadId || trace.threadId === threadId)
       .filter(trace => requestedDetailTurnId || traceMatchesRegex(trace, searchRegex));
-    const dreamEvents = this.#readDreamEvents({ sessionId, dreamLimit });
+    const dreamEvents = [];
     if (requestedDetailTurnId) {
       const trace = traces.find(t => t.requestId === requestedDetailTurnId || t.traceId === requestedDetailTurnId);
       if (!trace) return { loops: [], turns: [], dreamEvents, hasMore: false, limit: 0, indexOnly: false, detailTurnId: requestedDetailTurnId };
@@ -1308,7 +1267,7 @@ export class DebugTrace {
       turnCount += counts.loopCount;
       toolCount += counts.toolCount;
     }
-    const eventCount = this.#events.length;
+    const eventCount = 0;
     const { bytes } = await countDirFiles(this.#rootDir);
     return { turnCount, toolCount, eventCount, dbSizeBytes: bytes, fileSizeBytes: bytes, requestCount: traces.length };
   }
@@ -1343,10 +1302,8 @@ export class DebugTrace {
     this.#initializedRequestKeys.clear();
     this.#reconciledRetentionSessions.clear();
     this.#retentionIndex.clear();
-    this.#events = [];
     this.#hydrated = false;
     this.#hydratePromise = null;
-    this.#eventsHydrated = false;
     this.#acceptingWrites = true;
   }
 
@@ -1497,39 +1454,19 @@ export class DebugTrace {
     if (this.#hydrated) return;
     if (this.#hydratePromise) return this.#hydratePromise;
     this.#hydratePromise = (async () => {
-      const [headers, storedEvents] = await Promise.all([
-        readTraceHeaders(this.#rootDir, null),
-        readJson(join(this.#rootDir, 'events.json')),
-      ]);
+      const headers = await readTraceHeaders(this.#rootDir, null);
       for (const { trace } of headers) {
         if (!trace?.requestKey || this.#requestCache.has(trace.requestKey)) continue;
         this.#diskHeaders.set(trace.requestKey, trace.active
           ? { ...trace, active: false, interrupted: true }
           : trace);
       }
-      if (Array.isArray(storedEvents)) this.#mergeStoredEvents(storedEvents);
       this.#hydrated = true;
       this.#hydratePromise = null;
     })();
     return this.#hydratePromise;
   }
 
-  /**
-   * Fold on-disk events into the in-memory ring by id, preserving live order
-   * and bounding to MAX_DREAM_EVENTS. Unseen disk records are prepended (they
-   * are older); a live append therefore never erases prior-run history. Sets
-   * #eventsHydrated so this runs at most once.
-   */
-  #mergeStoredEvents(stored) {
-    if (this.#eventsHydrated) return;
-    this.#eventsHydrated = true;
-    if (!Array.isArray(stored) || stored.length === 0) return;
-    const seen = new Set(this.#events.map(e => e?.id).filter(Boolean));
-    const older = stored.filter(e => e && (!e.id || !seen.has(e.id)));
-    if (older.length === 0) return;
-    this.#events = [...older, ...this.#events].slice(-MAX_DREAM_EVENTS);
-  }
-
   #traceFile(trace) {
     return tracePathFor(this.#rootDir, trace.sessionId || null, trace.requestKey);
   }
@@ -1580,16 +1517,6 @@ export class DebugTrace {
     if (typeof this.#appendTimer.unref === 'function') this.#appendTimer.unref();
   }
 
-  #scheduleEventFlush() {
-    this.#eventsDirty = true;
-    if (this.#eventFlushTimer) return;
-    this.#eventFlushTimer = setTimeout(() => {
-      this.#eventFlushTimer = null;
-      this.#flushEvents();
-    }, EVENT_FLUSH_INTERVAL_MS);
-    if (typeof this.#eventFlushTimer.unref === 'function') this.#eventFlushTimer.unref();
-  }
-
   /** Queue append-only loop/tool records onto the single-writer chain. */
   #flushPending() {
     if (this.#appendTimer) {
@@ -1597,10 +1524,7 @@ export class DebugTrace {
       this.#appendTimer = null;
     }
     const entries = this.#pendingWrites.splice(0);
-    if (entries.length === 0) {
-      this.#flushEvents();
-      return;
-    }
+    if (entries.length === 0) return;
     this.#chain(async () => {
       const batches = new Map();
       for (const entry of entries) {
@@ -1697,7 +1621,6 @@ export class DebugTrace {
       try { await this.#pruneAll(REQUEST_RETENTION); }
       catch (err) { console.warn('[Yeaft] debug trace prune failed:', err?.message || err); }
     });
-    this.#flushEvents();
   }
 
   /**
@@ -1717,26 +1640,6 @@ export class DebugTrace {
     return this.#flushChain;
   }
 
-  #flushEvents() {
-    if (!this.#eventsDirty) return;
-    this.#eventsDirty = false;
-    if (this.#eventFlushTimer) {
-      clearTimeout(this.#eventFlushTimer);
-      this.#eventFlushTimer = null;
-    }
-    const file = join(this.#rootDir, 'events.json');
-    this.#chain(async () => {
-      // Fold in any prior-run events we haven't loaded yet BEFORE overwriting,
-      // so a write that beats #ensureHydrated can't drop cross-restart history.
-      if (!this.#eventsHydrated) {
-        this.#mergeStoredEvents(await readJson(file));
-      }
-      const text = JSON.stringify(this.#events.slice(-MAX_DREAM_EVENTS));
-      try { await atomicWriteText(file, text); }
-      catch (err) { console.warn('[Yeaft] debug trace event write failed:', err?.message || err); }
-    });
-  }
-
   /** Await every scheduled write (and prune) to settle. Used by close()/queries. */
   async #drainWrites() {
     this.#flushPending();
@@ -1757,32 +1660,6 @@ export class DebugTrace {
     return snapshot;
   }
 
-  #readDreamEvents({ sessionId = null, dreamLimit = 5 } = {}) {
-    const limit = Number.isFinite(Number(dreamLimit)) ? Math.max(0, Math.min(50, Number(dreamLimit))) : 5;
-    if (limit <= 0) return [];
-    // In-memory ring (hydrated once); no disk read on the query path.
-    const events = this.#events;
-    const out = [];
-    for (const event of events.slice().reverse()) {
-      const data = isPlainObject(event.eventData) ? event.eventData : {};
-      if (sessionId) {
-        const evtSessionId = typeof data.sessionId === 'string' && data.sessionId ? data.sessionId : null;
-        const target = typeof data.target === 'string' ? data.target : '';
-        const isBroadcast = !evtSessionId && !target;
-        const isThisSession = evtSessionId === sessionId || target === `sessions/${sessionId}` || target === `group/${sessionId}`;
-        if (!isBroadcast && !isThisSession) continue;
-      }
-      out.push({
-        type: data.type || event.eventType || 'event',
-        ...data,
-        at: event.createdAt,
-        ts: data.ts || data.at || event.createdAt,
-      });
-      if (out.length >= limit) break;
-    }
-    return out.reverse();
-  }
-
   async #pruneAll(keep) {
     const sessions = new Set();
     for (const trace of this.#diskHeaders.values()) sessions.add(trace.sessionId || null);

package/yeaft/init.js

@@ -86,7 +86,6 @@ const SUBDIRS = [
   'chat/cold',
   'chat/blobs',
   'sessions',
-  'memory/entries',
   'tasks',
   'skills',
 ];
@@ -115,19 +114,6 @@ const DEFAULT_CONFIG_JSON = `{
 }
 `;
 
-/** Default MEMORY.md content. */
-const DEFAULT_MEMORY = `# Yeaft Memory
-
-This file stores persistent memory entries. The agent will read and update this file.
-
-## Facts
-
-## Preferences
-
-## Project Context
-
-`;
-
 /** Default mcp.json example — generated as reference for MCP server configuration. */
 const DEFAULT_MCP_EXAMPLE = `{
   "_comment": "MCP server configuration. Rename to mcp.json to enable.",
@@ -160,9 +146,10 @@ This file tracks one Yeaft message-history mode.
  * Initialize the Yeaft data directory structure.
  *
  * @param {string} [dir] — Root directory path. Defaults to ~/.yeaft/
+ * @param {{ migrateMemory?: boolean }} [options] — Archived Dream migration is explicit opt-in, never part of Agent/service/Session startup.
  * @returns {{ dir: string, created: string[], writable: boolean, warnings: string[], seededSkills?: number }} — The root dir, list of created paths, writability status, any warnings, and how many bundled skills were seeded
  */
-export function initYeaftDir(dir) {
+export function initYeaftDir(dir, { migrateMemory = false } = {}) {
   const root = dir || DEFAULT_YEAFT_DIR;
   const created = [];
   const warnings = [];
@@ -211,12 +198,6 @@ export function initYeaftDir(dir) {
     }
   }
 
-  const memoryPath = join(root, 'memory', 'MEMORY.md');
-  if (!existsSync(memoryPath)) {
-    safeWriteFile(memoryPath, DEFAULT_MEMORY, warnings);
-    created.push(memoryPath);
-  }
-
   const chatIndexPath = join(root, 'chat', 'index.md');
   if (!existsSync(chatIndexPath)) {
     safeWriteFile(chatIndexPath, DEFAULT_CONVERSATION_INDEX, warnings);
@@ -252,7 +233,7 @@ export function initYeaftDir(dir) {
   // Idempotent (sentinel file) so re-running on a fully-migrated dir is a
   // no-op; on a partial-crash dir, each step is independently resumable.
   try {
-    const res = migrateSessions(root);
+    const res = migrateSessions(root, { migrateMemory });
     if (res && res.migrated) {
       console.log(`[yeaft] session migration complete (${res.moved} dirs moved, ${res.frontmatterRewrites} messages rewritten${res.warnings?.length ? `, ${res.warnings.length} warnings` : ''})`);
       if (res.warnings?.length) for (const w of res.warnings) console.warn(`[yeaft] migration: ${w}`);

package/yeaft/migrate/sessions.js

@@ -64,19 +64,21 @@ const SENTINEL_VERSION = 3;
  * @param {string} yeaftDir
  * @returns {{ migrated: boolean, moved: number, frontmatterRewrites: number, warnings: string[] }}
  */
-export function migrateSessions(yeaftDir) {
+export function migrateSessions(yeaftDir, { migrateMemory = true } = {}) {
   const warnings = [];
   if (!yeaftDir || !existsSync(yeaftDir)) {
     return { migrated: false, moved: 0, frontmatterRewrites: 0, warnings: ['yeaftDir missing'] };
   }
   const sentinel = join(yeaftDir, SENTINEL);
   if (existsSync(sentinel)) {
-    // Version-aware: ignore a sentinel from an older schema. Future v3
-    // migrations can run on v2-completed trees because they read what
-    // we wrote and decide for themselves whether to re-execute.
-    let v = 0;
-    try { v = JSON.parse(readFileSync(sentinel, 'utf8'))?.version ?? 0; } catch { /* corrupt sentinel — treat as 0 */ }
-    if (v >= SENTINEL_VERSION) {
+    // Version-aware: ignore a sentinel from an older schema. A runtime-only
+    // migration deliberately leaves memoryMigrated=false so an explicitly
+    // invoked full migration can still process the archived Dream data later.
+    let state = null;
+    try { state = JSON.parse(readFileSync(sentinel, 'utf8')); } catch { /* corrupt sentinel — treat as incomplete */ }
+    const versionComplete = (state?.version ?? 0) >= SENTINEL_VERSION;
+    const memoryComplete = state?.memoryMigrated !== false;
+    if (versionComplete && (!migrateMemory || memoryComplete)) {
       return { migrated: false, moved: 0, frontmatterRewrites: 0, warnings: [] };
     }
   }
@@ -96,8 +98,8 @@ export function migrateSessions(yeaftDir) {
   const memSessionsAmsRoot = join(memoryRoot, 'sessions');
 
   if (!existsSync(sessionsRoot)) mkdirSync(sessionsRoot, { recursive: true });
-  if (!existsSync(memSessionRoot)) mkdirSync(memSessionRoot, { recursive: true });
-  if (!existsSync(memSessionsAmsRoot)) mkdirSync(memSessionsAmsRoot, { recursive: true });
+  if (migrateMemory && !existsSync(memSessionRoot)) mkdirSync(memSessionRoot, { recursive: true });
+  if (migrateMemory && !existsSync(memSessionsAmsRoot)) mkdirSync(memSessionsAmsRoot, { recursive: true });
 
   // ID collision check
   const groupIds = listDirs(groupsRoot);
@@ -165,52 +167,52 @@ export function migrateSessions(yeaftDir) {
     moved++;
   }
 
-  // 3+4. memory/{group,chat}/<id>/ → memory/session/<id>/
-  for (const family of ['group', 'chat']) {
-    const root = join(memoryRoot, family);
-    if (!existsSync(root)) continue;
-    for (const id of listDirs(root)) {
-      const src = join(root, id);
-      const dst = join(memSessionRoot, id);
-      if (existsSync(dst)) {
-        warnings.push(`memory/session/${id} already exists; skipping memory/${family}/${id}`);
-        continue;
+  if (migrateMemory) {
+    // 3+4. memory/{group,chat}/<id>/ → memory/session/<id>/
+    for (const family of ['group', 'chat']) {
+      const root = join(memoryRoot, family);
+      if (!existsSync(root)) continue;
+      for (const id of listDirs(root)) {
+        const src = join(root, id);
+        const dst = join(memSessionRoot, id);
+        if (existsSync(dst)) {
+          warnings.push(`memory/session/${id} already exists; skipping memory/${family}/${id}`);
+          continue;
+        }
+        renameSync(src, dst);
+        rewriteSegmentScopes(dst, family, id, warnings);
       }
-      renameSync(src, dst);
-      rewriteSegmentScopes(dst, family, id, warnings);
     }
-  }
 
-  // 5. memory/groups/<g>/ams.json → memory/sessions/<g>/ams.json
-  const amsGroupRoot = join(memoryRoot, 'groups');
-  if (existsSync(amsGroupRoot)) {
-    for (const id of listDirs(amsGroupRoot)) {
-      const srcDir = join(amsGroupRoot, id);
-      const dstDir = join(memSessionsAmsRoot, id);
-      if (existsSync(dstDir)) {
-        warnings.push(`memory/sessions/${id} already exists; skipping memory/groups/${id}`);
-        continue;
+    // 5. memory/groups/<g>/ams.json → memory/sessions/<g>/ams.json
+    const amsGroupRoot = join(memoryRoot, 'groups');
+    if (existsSync(amsGroupRoot)) {
+      for (const id of listDirs(amsGroupRoot)) {
+        const srcDir = join(amsGroupRoot, id);
+        const dstDir = join(memSessionsAmsRoot, id);
+        if (existsSync(dstDir)) {
+          warnings.push(`memory/sessions/${id} already exists; skipping memory/groups/${id}`);
+          continue;
+        }
+        renameSync(srcDir, dstDir);
       }
-      renameSync(srcDir, dstDir);
     }
-  }
-  const amsChatRoot = join(memoryRoot, 'chats');
-  if (existsSync(amsChatRoot)) {
-    for (const id of listDirs(amsChatRoot)) {
-      const srcDir = join(amsChatRoot, id);
-      const dstDir = join(memSessionsAmsRoot, id);
-      if (existsSync(dstDir)) {
-        warnings.push(`memory/sessions/${id} already exists; skipping memory/chats/${id}`);
-        continue;
+    const amsChatRoot = join(memoryRoot, 'chats');
+    if (existsSync(amsChatRoot)) {
+      for (const id of listDirs(amsChatRoot)) {
+        const srcDir = join(amsChatRoot, id);
+        const dstDir = join(memSessionsAmsRoot, id);
+        if (existsSync(dstDir)) {
+          warnings.push(`memory/sessions/${id} already exists; skipping memory/chats/${id}`);
+          continue;
+        }
+        renameSync(srcDir, dstDir);
       }
-      renameSync(srcDir, dstDir);
     }
-  }
 
-  // 6. Rewrite SQLite FTS index scope strings via the shared index-db module
-  //    (which already handles ABI loading). Idempotent: WHERE clause skips
-  //    already-rewritten rows. Synchronous: better-sqlite3 has no async API.
-  rewriteFtsScopes(memoryRoot, warnings);
+    // 6. Rewrite SQLite FTS index scope strings via the shared index-db module.
+    rewriteFtsScopes(memoryRoot, warnings);
+  }
 
   // 7. Per-message frontmatter rewrite. Walks both the legacy flat
   //    conversation directory and every per-session conversation directory
@@ -224,8 +226,11 @@ export function migrateSessions(yeaftDir) {
   moved += cleanup.moved;
 
   // 9. Sentinel — version 3 = consolidated migration plus legacy cleanup.
+  // Record whether the optional archived-memory steps ran; runtime startup
+  // skips them, while explicit migration callers retain the ability to run them.
   writeFileSync(sentinel, JSON.stringify({
     version: SENTINEL_VERSION,
+    memoryMigrated: migrateMemory,
     migratedAt: new Date().toISOString(),
     moved,
     frontmatterRewrites,