@yeaft/webchat-agent 0.1.659 → 0.1.661

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.659",
+  "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

@@ -219,8 +219,6 @@ function loadLegacyConfig(dir, overrides) {
     unify: normaliseUnifySection(null),
     // DESIGN-v2 feature flag. Default true (PR-E flipped). Override wins.
     memoryV2: overrides.memoryV2 !== undefined ? !!overrides.memoryV2 : true,
-    // GC.1: FTS pre-flow flag (legacy fallback config — defaults true).
-    memoryPreflow: overrides.memoryPreflow !== undefined ? !!overrides.memoryPreflow : true,
     providers: null,
     primaryModel: null,
     fastModel: null,
@@ -317,22 +315,16 @@ 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 engine routes recall through
-    // memory/recall-v2.js (per-scope memory.md + summary.md) and the
-    // session wires the v2 dream pipeline (dream-v2/runner.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),
 
-    // GC.1 feature flag — route pre-turn memory recall through
-    // memory/preflow.js (SQLite FTS5) instead of memory/recall-v2.js
-    // (per-scope file reads). When OFF the engine falls back to v2.
-    // Default ON. Users can opt out via `"memoryPreflow": false` in
-    // ~/.yeaft/config.json. Only applies when memoryV2 is also ON.
-    memoryPreflow: overrides.memoryPreflow !== undefined ? !!overrides.memoryPreflow
-      : (jsonConfig.memoryPreflow !== undefined ? !!jsonConfig.memoryPreflow : true),
-
     // Legacy fields (null when using config.json)
     apiKey: overrides.apiKey || null,
     openaiApiKey: null,

package/unify/engine.js

@@ -20,8 +20,6 @@
 import { randomUUID } from 'crypto';
 import { buildSystemPrompt, buildWorkerPrompt } from './prompts.js';
 import { LLMContextError, LLMAbortError } from './llm/adapter.js';
-import { recallR6, formatForInjection } from './memory/recall-r6.js';
-import { recallV2 } from './memory/recall-v2.js';
 import { runMemoryPreflow } from './groups/pre-flow.js';
 import { shouldConsolidate, consolidate, partitionMessages } from './memory/consolidate.js';
 import { extractMemories } from './memory/extract.js';
@@ -30,7 +28,6 @@ import { evaluateCompactTriggers } from './compact/triggers.js';
 import { archiveTurn } from './archive/turn-archive.js';
 import { archiveToolResults } from './archive/tool-results.js';
 import { buildMemoryInjection } from './memory/layout.js';
-import { buildUserProfile } from './memory/user-memory-store.js';
 import { readSummary as readScopeSummary } from './memory/store-v2.js';
 import { runStopHooks } from './stop-hooks.js';
 // H2.f.5: threads/ retired. Persisted messages still carry a `threadId`
@@ -500,9 +497,11 @@ export class Engine {
   /**
    * Perform memory recall for a given prompt.
    *
-   * Routes:
-   *   - config.memoryV2 === true → recall-v2 (per-scope memory.md + summary.md)
-   *   - else → R6 shard-based recall (legacy)
+   * Single path (GC.1 follow-up): SQLite FTS5 pre-flow via
+   * `groups/pre-flow.js` → `memory/preflow.js`. When the index isn't
+   * wired (e.g. read-only sessions or pre-FTS yeaft dirs) recall is
+   * skipped and an empty memory shape is returned — engine continues
+   * without injection.
    *
    * @param {string} prompt
    * @param {{ groupId?: string, vpId?: string, featureId?: string }} [ctx]
@@ -510,82 +509,20 @@ export class Engine {
    */
   async #recallMemory(prompt, ctx = {}) {
     const memory = { profile: '', entries: [], formatted: '' };
-
-    // ─── GC.1: FTS5 pre-flow path ──────────────────────────────
-    // When the SegmentIndex is wired and the feature flag is on,
-    // route recall through groups/pre-flow.js → memory/preflow.js
-    // (SQLite FTS5). On any failure fall through to v2.
-    if (this.#memoryIndex && this.#config && this.#config.memoryPreflow) {
-      try {
-        const result = runMemoryPreflow(this.#memoryIndex, {
-          userMsg: prompt,
-          groupId: ctx.groupId,
-          vpId: ctx.vpId,
-          featureId: ctx.featureId,
-        });
-        memory.profile = result.profile || '';
-        memory.entries = result.entries || [];
-        memory.formatted = result.formatted || '';
-        return memory;
-      } catch {
-        // Fall through to v2 / R6 paths.
-      }
-    }
-
-    // ─── v2 path (DESIGN-v2) ───────────────────────────────────
-    if (this.#config && this.#config.memoryV2 && this.#yeaftDir) {
-      try {
-        const result = await recallV2({
-          prompt,
-          root: `${this.#yeaftDir}/memory`,
-          groupId: ctx.groupId,
-          vpId: ctx.vpId,
-          featureId: ctx.featureId,
-        });
-        memory.entries = result.sections || [];
-        memory.formatted = result.formatted || '';
-        // Profile concept: in v2 the user/memory.md IS the profile.
-        const userSec = (result.sections || []).find(s => s.kind === 'user');
-        memory.profile = userSec ? (userSec.summary || '') : '';
-      } catch {
-        // Fail soft — empty injection.
-      }
-      return memory;
-    }
-
-    // ─── R6 legacy path ────────────────────────────────────────
-    // Build user profile from user-memory shard store (R6 path),
-    // falling back to legacy readProfile if shard store unavailable.
+    if (!this.#memoryIndex) return memory;
     try {
-      const profile = buildUserProfile(this.#memoryShardStore);
-      if (profile) {
-        memory.profile = profile;
-      } else if (this.#memoryStore) {
-        memory.profile = this.#memoryStore.readProfile();
-      }
+      const result = runMemoryPreflow(this.#memoryIndex, {
+        userMsg: prompt,
+        groupId: ctx.groupId,
+        vpId: ctx.vpId,
+        featureId: ctx.featureId,
+      });
+      memory.profile = result.profile || '';
+      memory.entries = result.entries || [];
+      memory.formatted = result.formatted || '';
     } catch {
-      // Non-critical — fall through to legacy
-      if (this.#memoryStore) {
-        try { memory.profile = this.#memoryStore.readProfile(); } catch { /* */ }
-      }
+      // Fail soft — empty injection.
     }
-
-    // R6 shard-based recall (preferred path)
-    if (this.#memoryShardStore) {
-      try {
-        const result = await recallR6({
-          prompt,
-          memoryShardStore: this.#memoryShardStore,
-          adapter: this.#adapter,
-          fastModel: this.#fastConfig?.model,
-        });
-        memory.entries = result.entries;
-        memory.formatted = formatForInjection(result.entries);
-      } catch {
-        // Recall failure is non-critical
-      }
-    }
-
     return memory;
   }
 
@@ -901,7 +838,8 @@ export class Engine {
     // ─── Pre-query: Memory Injection (task-287) + Compact Summary ──
     // Two-layer recall:
     //   1. Static memory index injection (buildMemoryInjection — always)
-    //   2. R6 shard-based recall (recallR6 — when memoryShardStore is wired)
+    //   2. FTS5 pre-flow recall (#recallMemory → groups/pre-flow.js →
+    //      memory/preflow.js — when memoryIndex is wired)
     // No per-turn fuzzy recall via old recall.js — LLM calls memory_load /
     // memory_query on demand (memory_search still works as a deprecated alias).
     let memoryInjection = '';

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

@@ -28,18 +28,17 @@ import { Engine } from './engine.js';
 // H2.f.5: threads/, pipeline/dispatcher and input-queue retired. The
 // session now exposes a single Engine.
 //
-// GC.1 Commit A: when config.memoryV2 && config.memoryPreflow, the
-// session opens a SegmentIndex (SQLite FTS5 over memory.md) and
-// passes it to the Engine. The Engine's #recallMemory then routes
-// pre-turn recall through groups/pre-flow.js → memory/preflow.js
-// instead of the per-scope file reader (memory/recall-v2.js).
-// Post-turn adjustMemory (memory/adjust.js) wiring lands in a later
-// commit.
+// GC.1 (final): when config.memoryV2 is on, the session opens a
+// SegmentIndex (SQLite FTS5 over memory.md) and passes it to the
+// Engine. Engine.#recallMemory routes pre-turn recall through
+// groups/pre-flow.js → memory/preflow.js (the previous per-scope
+// file reader recall-v2.js has been deleted). Post-turn AMS
+// correction (memory/adjust.js) is implemented but not yet wired —
+// requires session-level AMS instance + scope resolution. Tracked
+// 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';
@@ -223,15 +222,15 @@ export async function loadSession(options = {}) {
   }
 
   // ─── 5-fts. (GC.1) Open SegmentIndex for FTS pre-flow ────
-  //     When config.memoryV2 && config.memoryPreflow, build a SQLite
-  //     FTS5 index over ~/.yeaft/memory/<scope>/memory.md and pass it
-  //     to the Engine. Engine.#recallMemory uses it via
-  //     groups/pre-flow.js → memory/preflow.js. Disk is the source of
-  //     truth; on boot we reconcile disk → index via syncAll.
-  //     Failure to open the index is non-fatal: the Engine falls back
-  //     to recall-v2 transparently.
+  //     When config.memoryV2 is on, build a SQLite FTS5 index over
+  //     ~/.yeaft/memory/<scope>/memory.md and pass it to the Engine.
+  //     Engine.#recallMemory uses it via groups/pre-flow.js →
+  //     memory/preflow.js. Disk is the source of truth; on boot we
+  //     reconcile disk → index via syncAll. Failure to open the index
+  //     is non-fatal: #recallMemory returns an empty result and the
+  //     turn proceeds without pre-injected memory.
   let memoryIndex = null;
-  if (config.memoryV2 && config.memoryPreflow && !config._readOnly) {
+  if (config.memoryV2 && !config._readOnly) {
     try {
       const indexPath = join(yeaftDir, 'memory', 'index.db');
       memoryIndex = openSegmentIndex(indexPath);
@@ -322,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()