@yeaft/webchat-agent 0.1.711 → 0.1.712

package/package.json

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

package/unify/config.js

@@ -217,8 +217,6 @@ function loadLegacyConfig(dir, overrides) {
     maxContinueTurns: overrides.maxContinueTurns ?? fileConfig.maxContinueTurns ?? DEFAULTS.maxContinueTurns,
     // task-318: legacy path never had the `unify` section — defaults.
     unify: normaliseUnifySection(null),
-    // H2-AMS feature flag. Default true. Override wins.
-    memoryV2: overrides.memoryV2 !== undefined ? !!overrides.memoryV2 : true,
     providers: null,
     primaryModel: null,
     fastModel: null,
@@ -315,16 +313,6 @@ export function loadConfig(overrides = {}) {
     // don't pollute the flat config namespace used by chat/crew code.
     unify: normaliseUnifySection(jsonConfig.unify),
 
-    // H2-AMS 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),
-
     // Legacy fields (null when using config.json)
     apiKey: overrides.apiKey || null,
     openaiApiKey: null,

package/unify/dream-v2/limits.js

@@ -10,7 +10,7 @@
  * malformed values fall back to default.
  */
 
-export const DREAM_INTERVAL_HOURS = 12;
+export const DREAM_INTERVAL_HOURS = 1;
 export const DREAM_OVERLAP = 3;
 export const MIN_NEW_PER_GROUP = 20;
 export const MAX_SINGLE_MESSAGE_CHARS = 8000;
@@ -18,6 +18,11 @@ export const MAX_DIFF_TOKENS_PER_TRIAGE = 60000;
 export const MAX_APPLY_TOKENS = 80000;
 export const DREAM_BACKUP_KEEP = 7;
 
+// task-710: nudge dream off the 1h timer when a group has accumulated
+// this many user messages since the last successful pass. Keeps memory
+// fresh during heavy chat windows without rivalling user latency.
+export const DREAM_NUDGE_AFTER_MESSAGES = 50;
+
 export const DEFAULT_LIMITS = Object.freeze({
   DREAM_INTERVAL_HOURS,
   DREAM_OVERLAP,
@@ -26,6 +31,7 @@ export const DEFAULT_LIMITS = Object.freeze({
   MAX_DIFF_TOKENS_PER_TRIAGE,
   MAX_APPLY_TOKENS,
   DREAM_BACKUP_KEEP,
+  DREAM_NUDGE_AFTER_MESSAGES,
 });
 
 /**

package/unify/dream-v2/schedule.js

@@ -1,12 +1,15 @@
 /**
  * dream-v2/schedule.js.
  *
- * Two trigger paths:
+ * Three trigger paths:
  *
- *   1. 12-hour interval timer.
+ *   1. Interval timer (default 1 hour, see DREAM_INTERVAL_HOURS in limits.js).
  *   2. Manual trigger (UI button or `/dream` command), routed in via
  *      `triggerNow()` — sets `manual: true` so the per-group threshold
  *      is bypassed.
+ *   3. Nudge (task-710), routed in via `nudge()` — non-manual, so
+ *      MIN_NEW_PER_GROUP still applies. Used by session-wiring when
+ *      user-message traffic crosses DREAM_NUDGE_AFTER_MESSAGES.
  *
  * The scheduler is a thin wrapper around `runDream()` that prevents
  * concurrent passes (a second tick while the previous is still running
@@ -66,6 +69,14 @@ export function createDreamScheduler({ run, intervalMs = DEFAULT_INTERVAL_MS, lo
     triggerNow(scopeFilter) {
       return fire({ manual: true, scopeFilter });
     },
+    /**
+     * task-710: non-manual fire driven by user-message traffic. Unlike
+     * `triggerNow`, MIN_NEW_PER_GROUP still applies — groups below
+     * threshold are skipped exactly as on the timer path.
+     */
+    nudge() {
+      return fire({ manual: false });
+    },
     isRunning() { return !!inflight; },
     /** Test hook: fires once without scheduling a timer. */
     _fire: fire,

package/unify/dream-v2/session-wiring.js

@@ -5,14 +5,15 @@
  * to the live yeaft session: groups store, conversation log, LLM adapter,
  * and the engine's progress event sink.
  *
- * The dream pipeline only activates when `config.memoryV2 === true`. When
- * the flag is off, this module is a no-op.
+ * Memory v2 is the only path. The legacy `config.memoryV2` opt-out flag was
+ * retired (task-710) — the wiring is unconditional.
  */
 
 import { join } from 'path';
 import { runDream } from './runner.js';
 import { createDreamScheduler } from './schedule.js';
 import { listGroups, openGroup } from '../groups/group-store.js';
+import { DREAM_NUDGE_AFTER_MESSAGES } from './limits.js';
 
 /**
  * Build the per-call options for runDream. Pure: takes a session and returns
@@ -157,14 +158,91 @@ export function createV2DreamScheduler(session) {
   });
   // Auto-start the timer.
   v2.start();
+
+  // task-710: wire `noteUserMessage` to a real per-session message
+  // counter. When the count crosses DREAM_NUDGE_AFTER_MESSAGES (default
+  // 50) we kick off a non-manual dream pass and reset the counter.
+  // Non-manual still respects MIN_NEW_PER_GROUP per-group, so groups
+  // below threshold are still skipped — the nudge just frees us from
+  // waiting for the 1h timer when traffic is high.
+  //
+  // Counter resets on fire-attempt (not completion). If a pass is
+  // already in flight when we hit threshold, we CLAMP at threshold
+  // rather than letting the counter accumulate unbounded — otherwise
+  // the first message after the in-flight pass settles would fire
+  // immediately, defeating the 50-message guarantee.
+  let messagesSinceLastNudgeFire = 0;
+  function nudgeOnUserMessage() {
+    messagesSinceLastNudgeFire += 1;
+    if (messagesSinceLastNudgeFire < DREAM_NUDGE_AFTER_MESSAGES) return;
+    if (v2.isRunning()) {
+      // Clamp; don't accumulate. We want the next fire to wait another
+      // full DREAM_NUDGE_AFTER_MESSAGES once the in-flight pass clears.
+      messagesSinceLastNudgeFire = DREAM_NUDGE_AFTER_MESSAGES;
+      return;
+    }
+    messagesSinceLastNudgeFire = 0;
+    // Fire-and-forget; failure flows through the scheduler's catch.
+    v2.nudge().catch(() => {});
+  }
+
   // Adapter shim: legacy callers (web-bridge) call .noteUserMessage() and
   // .triggerDreamNow() / .shutdown(). Map them onto the v2 API.
   return {
-    noteUserMessage() { /* v2 doesn't gate on user-message count */ },
+    noteUserMessage: nudgeOnUserMessage,
     triggerDreamNow() { return v2.triggerNow(); },
+    triggerDreamForScopes(scopeFilter) { return v2.triggerNow(scopeFilter); },
     shutdown() { v2.stop(); },
     get isRunning() { return v2.isRunning(); },
     // Preserve direct access for tests.
     _v2: v2,
   };
 }
+
+/**
+ * task-710: walk every group on disk, find the ones that have user messages
+ * but zero memory segments in the FTS index, and trigger an immediate dream
+ * pass scoped to those groups. Used at session boot so a freshly opened
+ * agent doesn't have to wait an hour (or for traffic to cross the nudge
+ * threshold) before its first memory write.
+ *
+ * Pure side-effect, fire-and-forget. Failure logs at debug only — never
+ * blocks session load.
+ *
+ * @param {{ yeaftDir: string, memoryIndex: import('../memory/index-db.js').SegmentIndex|null, dreamScheduler: { triggerDreamForScopes: (s:string[]) => Promise<any> }, config?: { debug?: boolean } }} args
+ * @returns {Promise<{ triggered: string[] }>}
+ */
+export async function bootInitEmptyGroups(args) {
+  const out = { triggered: [] };
+  if (!args || !args.memoryIndex || !args.dreamScheduler) return out;
+  const groupsRoot = join(args.yeaftDir, 'groups');
+  let ids;
+  try { ids = listGroups(groupsRoot).map(g => g.id); }
+  catch { return out; }
+  const empty = [];
+  for (const gid of ids) {
+    let segCount;
+    try { segCount = args.memoryIndex.listByScope(`group/${gid}`).length; }
+    catch { continue; }
+    if (segCount > 0) continue;
+    let hasMessages = false;
+    try {
+      const h = openGroup(groupsRoot, gid);
+      // Any message at all is enough — pull the first record off the
+      // iterator and stop.
+      const first = h.streamMessages().next();
+      hasMessages = !first.done;
+    } catch { continue; }
+    if (!hasMessages) continue;
+    empty.push(`group/${gid}`);
+  }
+  if (empty.length === 0) return out;
+  if (args.config?.debug) {
+    // eslint-disable-next-line no-console
+    console.log(`[dream-v2] boot init: triggering empty-AMS dream for ${empty.length} group(s):`, empty);
+  }
+  // Fire-and-forget; the scheduler swallows its own failures.
+  Promise.resolve(args.dreamScheduler.triggerDreamForScopes(empty)).catch(() => {});
+  out.triggered = empty;
+  return out;
+}

package/unify/engine.js

@@ -574,8 +574,6 @@ export class Engine {
     try {
       const result = await runAdjust({
         trigger: {
-          newMemoryWritten: false,        // dream writes happen async; treat as false here
-          onDemandSize: ctx.ams.onDemandIds().length,
           turnTokenUsage: args.turnTokenUsage,
           totalBudget,
           adjustRanThisSession,

package/unify/memory/adjust.js

@@ -12,23 +12,25 @@
  *     manipulates AMS membership.
  *
  * Triggered conditionally — typical session shape is "hot turn skips,
- * adjust runs every 5–10 turns or on first turn":
+ * adjust runs once per session or under budget pressure":
  *
  *   shouldRunAdjust =
- *        (newMemoryWritten && onDemand.size >= 5)
- *     || (turnTokenUsage    > totalBudget * 0.9)
- *     || (!session.adjustRanThisSession)        // first-turn guarantee
+ *        (!session.adjustRanThisSession)        // first-turn guarantee
+ *     || (turnTokenUsage > totalBudget * 0.9)   // budget pressure
  *
  * The trigger lives at the call site (engine post-turn hook); this
  * module just exposes the policy + the LLM round-trip.
+ *
+ * task-710: the legacy `newMemoryWritten + onDemand >= 5` trigger was
+ * dropped — dream writes happen async on a background timer, so the
+ * caller had no good signal to pass and was hard-coding `false`. Adjust
+ * now relies on first-turn-guarantee + budget-pressure only.
  */
 
 import { approxTokens } from './budget.js';
 
 /**
  * @typedef {object} AdjustTriggerInput
- * @property {boolean} newMemoryWritten
- * @property {number}  onDemandSize
  * @property {number}  turnTokenUsage
  * @property {number}  totalBudget
  * @property {boolean} adjustRanThisSession
@@ -48,9 +50,6 @@ export function shouldRunAdjust(input) {
   if (input.turnTokenUsage > input.totalBudget * 0.9) {
     return { run: true, reason: 'budget-pressure' };
   }
-  if (input.newMemoryWritten && input.onDemandSize >= 5) {
-    return { run: true, reason: 'new-memory+onDemand-saturated' };
-  }
   return { run: false, reason: 'no-trigger' };
 }
 

package/unify/session.js

@@ -26,11 +26,12 @@ import { Engine } from './engine.js';
 // H2.f.5: threads/, pipeline/dispatcher and input-queue retired. The
 // session now exposes a single Engine.
 //
-// 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).
+// GC.1 (final): 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).
+// The `config.memoryV2` opt-out flag was retired in task-710; wiring is
+// unconditional.
 //
 // GC.1 follow-up: when memoryIndex is wired we also open an
 // AmsRegistry. The registry caches per-group ActiveMemorySet
@@ -42,7 +43,7 @@ import { Engine } from './engine.js';
 import { ensureDefaultGroupIfEmpty } from './groups/group-crud.js';
 import { seedDefaultVps } from './vp/seed-defaults.js';
 import { runSummaryBackfill } from './memory/seed-backfill.js';
-import { createV2DreamScheduler } from './dream-v2/session-wiring.js';
+import { createV2DreamScheduler, bootInitEmptyGroups } from './dream-v2/session-wiring.js';
 import { openSegmentIndex } from './memory/index-db.js';
 import { syncAll as syncSegmentIndex } from './memory/segment-sync.js';
 import { openAmsRegistry } from './memory/ams-registry.js';
@@ -169,15 +170,14 @@ export async function loadSession(options = {}) {
   const conversationStore = new ConversationStore(yeaftDir);
 
   // ─── 5-fts. (GC.1) Open SegmentIndex for FTS pre-flow ────
-  //     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.
+  //     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._readOnly) {
+  if (!config._readOnly) {
     try {
       const indexPath = join(yeaftDir, 'memory', 'index.db');
       memoryIndex = openSegmentIndex(indexPath);
@@ -300,8 +300,8 @@ export async function loadSession(options = {}) {
 
   // ─── 9a. Create dream scheduler ────────────
   // 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.
+  // dream-v2 is the only active path (the `config.memoryV2` opt-out
+  // flag was retired in task-710 — wiring is unconditional).
   // partialSession lets the v2 scheduler dereference adapter/config/
   // engine/trace lazily — safe because callers attach more fields
   // after this line.
@@ -314,6 +314,20 @@ export async function loadSession(options = {}) {
   };
   const dreamScheduler = createV2DreamScheduler(partialSession);
 
+  // task-710: kick a dream pass at boot for any group that has user
+  // messages but zero memory segments in the FTS index. Without this a
+  // freshly opened agent had to wait an hour (or for the nudge counter
+  // to cross 50) before the first segment landed and recall could find
+  // anything. Fire-and-forget; failure logs at debug only.
+  if (memoryIndex && !config._readOnly) {
+    bootInitEmptyGroups({
+      yeaftDir,
+      memoryIndex,
+      dreamScheduler,
+      config,
+    }).catch(() => { /* best-effort boot init */ });
+  }
+
   // H2.f.5: thread engine registry, input queue, and dispatcher retired.
   // The session exposes a single `engine`; web-bridge calls engine.query()
   // directly. Memory recall happens via memory/preflow.js (pre-turn) and