@yeaft/webchat-agent 1.0.456 → 1.0.458

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.456",
+  "version": "1.0.458",
   "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/config.js

@@ -377,6 +377,7 @@ function loadLegacyConfig(dir, overrides) {
     // task-318: legacy path never had the `yeaft` section — defaults.
     yeaft: normaliseYeaftSection(null),
     telemetry: normaliseTelemetrySection(null),
+    dream: { enabled: true },
     browserRuntime: normaliseBrowserRuntimeSection(null),
     plugins: {},
     providers: null,
@@ -534,6 +535,7 @@ export function loadConfig(overrides = {}) {
     // don't pollute the flat config namespace used by chat code.
     yeaft: normaliseYeaftSection(jsonConfig.yeaft),
     telemetry: normaliseTelemetrySection(jsonConfig.telemetry),
+    dream: { enabled: jsonConfig.dream?.enabled !== false },
     browserRuntime: normaliseBrowserRuntimeSection(jsonConfig.browserRuntime),
 
     // Agent-level tools / skills / MCP server allowlists. Missing fields mean

package/yeaft/dream/segment-extract.js

@@ -1,9 +1,9 @@
 /**
  * dream/segment-extract.js.
  *
- * Extract atomic evidence segments for scopes touched by a Dream pass and
- * persist them through memory/segment-store. Dream Apply separately maintains
- * canonical content.md and the short catalog summary.md.
+ * Extract atomic evidence segments only for scopes successfully touched by a
+ * Dream pass and persist them through memory/segment-store. Dream Apply
+ * separately maintains canonical content.md and the short catalog summary.md.
  */
 
 import { readScope, writeScope } from '../memory/segment-store.js';
@@ -144,7 +144,7 @@ function templateVarsForScope(scope, sessionId) {
 }
 
 function normalizeTargetScopes(sessionId, targets) {
-  const out = new Set(['user', `sessions/${sessionId}`, `sessions/${sessionId}/user`]);
+  const out = new Set();
   for (const target of targets) {
     if (typeof target !== 'string') continue;
     const clean = target.trim();

package/yeaft/dream/session-wiring.js

@@ -668,8 +668,8 @@ export function createV2DreamScheduler(session) {
     keepAlive: !!session?.config?.serverMode,
     logger: session.config?.debug ? console : undefined,
   });
-  // Auto-start the timer.
-  v2.start();
+  let enabled = session?.config?.dream?.enabled !== false;
+  if (enabled) v2.start();
 
   // task-710: wire `noteUserMessage` to a real per-session message
   // counter. When the count crosses DREAM_NUDGE_AFTER_MESSAGES (default
@@ -685,6 +685,7 @@ export function createV2DreamScheduler(session) {
   // immediately, defeating the 50-message guarantee.
   let messagesSinceLastNudgeFire = 0;
   function nudgeOnUserMessage() {
+    if (!enabled) return;
     messagesSinceLastNudgeFire += 1;
     if (messagesSinceLastNudgeFire < DREAM_NUDGE_AFTER_MESSAGES) return;
     if (v2.isRunning()) {
@@ -709,8 +710,20 @@ export function createV2DreamScheduler(session) {
      * below threshold are skipped — same shape as the interval timer
      * tick. Used by `bootCatchUpStaleDream`.
      */
-    catchUpNudge() { return v2.nudge(); },
+    catchUpNudge() {
+      return enabled ? v2.nudge() : Promise.resolve({ skipped: true, skippedReason: 'disabled', trigger: 'auto' });
+    },
+    setEnabled(nextEnabled) {
+      enabled = nextEnabled !== false;
+      if (enabled) v2.start();
+      else {
+        messagesSinceLastNudgeFire = 0;
+        v2.stop();
+      }
+      return enabled;
+    },
     shutdown() { v2.stop(); },
+    get enabled() { return enabled; },
     get isRunning() { return v2.isRunning(); },
     // Preserve direct access for tests.
     _v2: v2,
@@ -727,12 +740,16 @@ export function createV2DreamScheduler(session) {
  * 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
+ * @param {{ yeaftDir: string, memoryIndex: import('../memory/index-db.js').SegmentIndex|null, dreamScheduler: { triggerDreamForScopes: (s:string[]) => Promise<any> }, config?: { debug?: boolean, dream?: { enabled?: boolean } } }} args
  * @returns {Promise<{ triggered: string[] }>}
  */
 export async function bootInitEmptyGroups(args) {
   const out = { triggered: [] };
   if (!args || !args.memoryIndex || !args.dreamScheduler) return out;
+  // This is automatic boot catch-up, not an explicit user trigger. The
+  // scheduler's scoped trigger intentionally remains manual-capable while
+  // disabled, so enforce the Agent toggle at this automatic entry point.
+  if (args.config?.dream?.enabled === false) return out;
   const sessionsRoot = join(args.yeaftDir, 'sessions');
   let ids;
   try { ids = listSessionMetas(sessionsRoot).map(g => g.id); }

package/yeaft/dream/triage.js

@@ -1,3 +1,5 @@
+import { inspect } from 'util';
+
 import { isValidTopic } from '../memory/store.js';
 /**
  * dream/triage.js.
@@ -6,9 +8,10 @@ import { isValidTopic } from '../memory/store.js';
  * The decision is two-staged on purpose:
  *
  *   1. **Hard rules** (this module, no LLM): everything we can determine
- *      from message metadata. Always include the active session, every VP
- *      that spoke as an assistant in the diff, and `user` (so painted-over
- *      user-profile signals can't be missed). (Feature scope was dropped
+ *      from message metadata. Always include the active session and every VP
+ *      that spoke as an assistant in the diff. User-profile scopes are not a
+ *      structural property, so they are added only when soft classification
+ *      confirms a durable profile signal. (Feature scope was dropped
  *      2026-05-13 along with the rest of the Feature system.)
  *
  *   2. **Soft classification** (LLM, two passes):
@@ -18,14 +21,15 @@ import { isValidTopic } from '../memory/store.js';
  *                              it to an exact existing path or propose
  *                              a new ≤2-level path.
  *
- *      VP / group are deliberately NOT asked of the LLM — Hard Rules
+ *      VP / Session are deliberately NOT asked of the LLM — Hard Rules
  *      already cover them, and giving the LLM a chance to drop a
  *      structurally-required scope would weaken the contract.
  *
- *      `user_profile_signals === true` does not need Pass-2 either: the
- *      Hard Rule already added `user` and Apply itself decides whether
- *      to actually rewrite anything (an UPDATE with no relevant content
- *      reads as a no-op rewrite of the existing memory).
+ *      `user_profile_signals === true` does not need Pass-2: it directly
+ *      adds the global `user` scope and, for a real collaborative Session,
+ *      the Session-local `sessions/<id>/user` scope. Keeping those scopes
+ *      out when the classifier says false avoids two Apply rewrites and two
+ *      extraction requests for ordinary task-focused conversation.
  *
  * The LLM is injected as a callable: `llm({ pass, prompt, system })` →
  * Promise<string>. Tests pass a stub; runner injects the real adapter.
@@ -63,8 +67,8 @@ export function applyHardRules({ sessionId, chatId, messages }) {
   const out = new Map();
   const add = (scope) => { if (!out.has(scope)) out.set(scope, { kind: 'update', scope }); };
 
-  // global user is always in.
-  add('user');
+  // User-profile scopes are content-dependent and are added by soft
+  // classification only when the diff contains a durable profile signal.
 
   // chat path takes precedence: chat sessions have no collaborative session context.
   if (chatId) {
@@ -84,7 +88,6 @@ export function applyHardRules({ sessionId, chatId, messages }) {
   // active collaborative session, except the virtual _no-session bucket.
   if (sessionId && sessionId !== '_no-session') {
     add(`sessions/${sessionId}`);
-    add(`sessions/${sessionId}/user`);
   }
 
   for (const m of (messages || [])) {
@@ -159,18 +162,21 @@ export async function classifySoft({ root, sessionId, messages, topicSummaries,
   const pass1Prompt = buildPass1Prompt({ sessionId, messages, topicSummaries, language, maxPromptChars });
   const pass1Raw = await llm({ pass: 'triage-pass1', prompt: pass1Prompt, system: triageSystem(language) });
   const pass1 = parseJsonSafe(pass1Raw);
+  if (!isValidPass1(pass1)) {
+    throw triageContractError('Pass-1', pass1Raw);
+  }
   const out = [];
 
-  // user_profile_signals: covered by hard rules; we only emit explicit
-  // user action here when Pass-1 says yes (idempotent if hard rules
-  // already added it).
-  if (pass1 && pass1.user_profile_signals === true) {
+  // User-profile scopes are expensive shared-memory rewrites, not structural
+  // Session scopes. Route to them only when Pass-1 finds a durable signal.
+  if (pass1.user_profile_signals) {
     out.push({ kind: 'update', scope: 'user' });
+    if (sessionId && sessionId !== '_no-session') {
+      out.push({ kind: 'update', scope: `sessions/${sessionId}/user` });
+    }
   }
 
-  const topicDescriptions = (pass1 && Array.isArray(pass1.topics)) ? pass1.topics : [];
-  for (const description of topicDescriptions) {
-    if (typeof description !== 'string' || !description.trim()) continue;
+  for (const description of pass1.topics) {
     const pass2Prompt = buildPass2Prompt({
       description: description.trim(),
       existingTopics: topicSummaries || [],
@@ -179,20 +185,18 @@ export async function classifySoft({ root, sessionId, messages, topicSummaries,
     });
     const pass2Raw = await llm({ pass: 'triage-pass2', prompt: pass2Prompt, system: triageSystem(language) });
     const pass2 = parseJsonSafe(pass2Raw);
-    if (!pass2 || !pass2.decision) continue;
+    if (!isValidPass2(pass2, { sessionId, topicSummaries })) {
+      throw triageContractError('Pass-2', pass2Raw);
+    }
     if (pass2.decision === 'none') continue;
-    const path = String(pass2.path || '').trim();
-    if (!path) continue;
-    const segs = path.split('/').filter(Boolean);
-    if (!sessionId || sessionId === '_no-session') continue;
-    if (!isValidTopic({ kind: 'session-topic', sessionId, path: segs })) continue;
+    const path = pass2.path;
     const redirected = root
-      ? resolveTopicRedirect(root, sessionId, segs.join('/'))
-      : segs.join('/');
+      ? resolveTopicRedirect(root, sessionId, path)
+      : path;
     const scope = `sessions/${sessionId}/topic/${redirected}`;
     if (pass2.decision === 'match') {
       out.push({ kind: 'update', scope });
-    } else if (pass2.decision === 'new') {
+    } else {
       out.push({ kind: 'create', scope });
     }
   }
@@ -268,6 +272,58 @@ function oneLine(s) {
   return String(s || '').replace(/\s+/g, ' ').trim().slice(0, 200);
 }
 
+function isPlainObject(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function hasExactKeys(value, expected) {
+  const keys = Object.keys(value).sort();
+  return keys.length === expected.length && keys.every((key, index) => key === expected[index]);
+}
+
+function isValidPass1(value) {
+  if (!isPlainObject(value)
+    || !hasExactKeys(value, ['topics', 'trivial_only', 'user_profile_signals'])
+    || typeof value.user_profile_signals !== 'boolean'
+    || typeof value.trivial_only !== 'boolean'
+    || !Array.isArray(value.topics)
+    || !value.topics.every(topic => typeof topic === 'string' && topic.trim().length > 0)) {
+    return false;
+  }
+  return !value.trivial_only || (!value.user_profile_signals && value.topics.length === 0);
+}
+
+function isValidPass2(value, { sessionId, topicSummaries }) {
+  if (!isPlainObject(value) || !['match', 'new', 'none'].includes(value.decision)) return false;
+  if (value.decision === 'none') {
+    return hasExactKeys(value, ['decision']);
+  }
+  if (!hasExactKeys(value, ['decision', 'path'])
+    || !sessionId
+    || sessionId === '_no-session'
+    || typeof value.path !== 'string'
+    || value.path !== value.path.trim()) {
+    return false;
+  }
+  const path = value.path;
+  const segments = path.split('/');
+  if (!isValidTopic({ kind: 'session-topic', sessionId, path: segments })) return false;
+  const pathExists = (topicSummaries || []).some(topic => topic?.path === path);
+  return value.decision === 'match' ? pathExists : !pathExists;
+}
+
+function triageContractError(pass, raw) {
+  const err = new Error(`triage: ${pass} returned malformed JSON`);
+  err.rawSnippet = rawResponseSnippet(raw);
+  return err;
+}
+
+function rawResponseSnippet(raw) {
+  if (typeof raw === 'string') return raw.slice(0, 1000);
+  if (raw == null) return String(raw);
+  return inspect(raw, { depth: 2, maxArrayLength: 10, breakLength: 120 }).slice(0, 1000);
+}
+
 /** Lenient JSON parse: tolerate fenced ```json blocks. Returns null on failure. */
 export function parseJsonSafe(raw) {
   if (typeof raw !== 'string') return null;

package/yeaft/session.js

@@ -136,6 +136,7 @@ export async function loadSession(options = {}) {
     extraTools = [],
     configOverrides = {},
     serverMode = false,
+    dreamEnabled,
     managedCliReady = null,
   } = options;
 
@@ -172,6 +173,7 @@ export async function loadSession(options = {}) {
   // can decide whether to keep its interval timer alive (server) or
   // unref it (CLI / tests). Non-persisted — set per-session by caller.
   if (serverMode) config.serverMode = true;
+  if (typeof dreamEnabled === 'boolean') config.dream.enabled = dreamEnabled;
 
   // Propagate the (clamped) cold-start replay window to the conversation
   // store. The default is 20 turns; a user wanting more recall after a