@yeaft/webchat-agent 0.1.753 → 0.1.754

package/package.json

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

package/unify/dream-v2/runner.js

@@ -44,7 +44,7 @@ import { listScopes, readSummary } from '../memory/store-v2.js';
 import {
   DEFAULT_LIMITS,
 } from './limits.js';
-import { readGroupState, writeGroupState } from './state.js';
+import { readGroupState, writeGroupState, writeDreamError } from './state.js';
 import { segmentDiff, truncateMessage, estimateMessagesTokens } from './segment.js';
 import { triageGroupSegments } from './triage.js';
 import { mergeByTarget } from './merge.js';
@@ -148,6 +148,14 @@ export async function runDream(opts) {
     } catch (err) {
       groupsReport.push({ groupId, new: newCount, status: 'error', error: err.message });
       onProgress({ phase: 'triage', groupId, status: 'error', error: err.message });
+      // Journal the failure on disk so operators can see WHY dream is
+      // not advancing without having to enable `config.debug`. Best-
+      // effort — `writeDreamError` swallows its own I/O errors.
+      await writeDreamError(opts.root, `group/${groupId}`, {
+        phase: 'triage',
+        message: err.message,
+        stack: err.stack,
+      });
       continue;
     }
 
@@ -191,6 +199,14 @@ export async function runDream(opts) {
         error: err.message,
       });
       onProgress({ phase: 'apply', target: merged.target, status: 'error', error: err.message });
+      // Journal apply-stage failures into the target scope's directory
+      // (`<root>/<merged.target>/.dream-last-error.json`). Same rationale
+      // as the triage catch above.
+      await writeDreamError(opts.root, merged.target, {
+        phase: 'apply',
+        message: err.message,
+        stack: err.stack,
+      });
     }
   }
 

package/unify/dream-v2/state.js

@@ -1,7 +1,7 @@
 /**
  * dream-v2/state.js.
  *
- * Two pieces of state, tracked separately:
+ * Three pieces of state, tracked separately:
  *
  *   1. Per-group control state (used to decide whether a group enters
  *      triage and how far to advance the cursor):
@@ -31,13 +31,25 @@
  *      control-flow decision. We update it by replacing the existing
  *      block (if any) or appending a new one to the end of the file.
  *
- * Both helpers are pure I/O; no LLM, no logic beyond parsing.
+ *   3. Per-scope dream-error sink (added v0.1.754):
+ *
+ *        ~/.yeaft/memory/<scope>/.dream-last-error.json
+ *
+ *      Most-recent-wins JSON written unconditionally on every triage
+ *      or apply failure (best-effort — never throws even when the I/O
+ *      itself fails). The runner used to swallow these exceptions and
+ *      the only sink was a `config.debug`-gated console.log; this file
+ *      gives operators on-disk evidence regardless of debug. See
+ *      `writeDreamError` / `readDreamError` below for the contract.
+ *
+ * All helpers are pure I/O; no LLM, no logic beyond parsing.
  */
 
 import { promises as fsp, existsSync } from 'fs';
 import { join, dirname } from 'path';
 
 const STATE_FILE = '.dream-state';
+const ERROR_FILE = '.dream-last-error.json';
 const DREAM_BLOCK_OPEN = '<!-- dream-state -->';
 const DREAM_BLOCK_CLOSE = '<!-- /dream-state -->';
 
@@ -101,6 +113,95 @@ function parseGroupState(raw) {
   return out;
 }
 
+// ─── per-scope dream error sink ────────────────────────────────
+//
+// Why: dream-v2 silently swallowed exceptions at the triage / apply
+// catch sites — the only sink was `trace.event('dream_progress', evt)`
+// and a `config.debug`-gated `console.log` in `session-wiring.js`. With
+// `debug=false` (the default), there was no on-disk evidence that a
+// dream pass had ever failed: no `.dream-state` (because we only write
+// it on success), no log file, nothing. The Resident layer's continued
+// regurgitation of the bootstrap seed was the only symptom.
+//
+// `writeDreamError` writes `<memoryRoot>/<scope>/.dream-last-error.json`
+// unconditionally on every catch (best-effort — write failures must not
+// shadow the original error). Operators can then `ls ~/.yeaft/memory/
+// group/<id>/` and see what blew up, without having to re-enable debug.
+
+/**
+ * Resolve a memoryRoot + scope-string to the scope directory.
+ * The scope string is the same shape dream-v2 already uses internally:
+ * `'user'`, `'vp/<vpId>'`, `'group/<groupId>'`, `'feature/<id>'`, etc.
+ *
+ * Pure path-join; does NOT create the directory. The writer creates it.
+ *
+ * @param {string} root
+ * @param {string} scope
+ * @returns {string}
+ */
+export function scopeDirFor(root, scope) {
+  // Defensive: trim leading/trailing slashes so callers can pass either
+  // `'group/grp_fun'` or `/group/grp_fun/` — both land on the same dir.
+  const clean = String(scope || '').replace(/^\/+|\/+$/g, '');
+  return join(root, clean);
+}
+
+/**
+ * Best-effort write of the dream-error sink. Never throws — a failed
+ * write is silently swallowed because the caller is already in an
+ * error-handling path and we must not mask the original failure.
+ *
+ * @param {string} root         — memory root, e.g. ~/.yeaft/memory
+ * @param {string} scope        — `'group/<id>'` for triage failures,
+ *                                `merged.target` for apply failures.
+ * @param {{ phase: string, message: string, stack?: string|null, at?: string }} info
+ * @returns {Promise<void>}
+ */
+export async function writeDreamError(root, scope, info) {
+  try {
+    const dir = scopeDirFor(root, scope);
+    await fsp.mkdir(dir, { recursive: true });
+    const abs = join(dir, ERROR_FILE);
+    const at = (info && info.at) || new Date().toISOString();
+    // Trim stack to the first 5 frames — enough for diagnosis, small
+    // enough that the artifact stays human-readable. Missing/empty
+    // stack collapses to `null` rather than `""` so the artifact is
+    // cleaner for operators.
+    const rawStack = info && typeof info.stack === 'string' ? info.stack : '';
+    const stackLines = rawStack ? rawStack.split('\n').slice(0, 5) : [];
+    const body = JSON.stringify({
+      at,
+      scope,
+      phase: String(info?.phase || 'unknown'),
+      message: String(info?.message || ''),
+      stack: stackLines.length > 0 ? stackLines.join('\n') : null,
+    }, null, 2) + '\n';
+    await atomicWrite(abs, body);
+  } catch {
+    // Best-effort: swallow. The caller is already handling the real
+    // error; an inability to journal it must not shadow that.
+  }
+}
+
+/**
+ * Read the last dream error JSON for a scope, or null if absent. Used
+ * by the debug panel and by tests. Tolerates a malformed file by
+ * returning `{ raw: <body>, parseError: <message> }` instead of
+ * throwing.
+ *
+ * @param {string} root
+ * @param {string} scope
+ * @returns {Promise<object|null>}
+ */
+export async function readDreamError(root, scope) {
+  const abs = join(scopeDirFor(root, scope), ERROR_FILE);
+  let raw;
+  try { raw = await fsp.readFile(abs, 'utf8'); }
+  catch (err) { if (err && err.code === 'ENOENT') return null; throw err; }
+  try { return JSON.parse(raw); }
+  catch (e) { return { raw, parseError: e.message }; }
+}
+
 // ─── per-scope marker (memory.md tail block) ───────────────────
 
 /**

package/unify/web-bridge.js

@@ -2418,28 +2418,55 @@ export function __testGetRegisteredThreadIds() {
 export const __testRaceWithEscalation = raceWithEscalation;
 
 /**
- * Manual dream trigger from VP detail page.
+ * Manual dream trigger.
+ *
+ * Two call shapes, both routed through this single handler:
+ *
+ *   { type: 'unify_dream_trigger', vpId }     — per-VP trigger (legacy
+ *     VP-detail page button). Fires an unscoped dream pass; the result
+ *     event is tagged with `vpId` so the per-VP store row updates.
+ *
+ *   { type: 'unify_dream_trigger', groupId }  — per-GROUP trigger (new
+ *     in v0.1.754 — added so users can manually kick dream for a group
+ *     after seeing the Resident layer stuck on the bootstrap seed).
+ *     Fires a scope-filtered pass via `triggerDreamForScopes(['group/X'])`
+ *     so unrelated groups don't get processed; the result event is
+ *     tagged with `groupId` for the per-group UI row.
+ *
+ * Backwards-compat: when neither field is set, defaults to `vpId='default'`
+ * which matches the pre-v0.1.754 behavior.
  */
 export async function handleUnifyDreamTrigger(msg = {}) {
+  // Resolve tag up-front so EVERY outbound envelope (including the
+  // scheduler-uninitialised early-return below) carries `groupId` /
+  // `vpId`. Without this the frontend's `applyDreamResult` couldn't
+  // route the error event back to the right row and the per-group
+  // "Run dream now" button would stay stuck on "Running…" forever
+  // (review feedback from PR #757).
+  const groupId = typeof msg.groupId === 'string' && msg.groupId ? msg.groupId : null;
+  const vpId = !groupId ? (msg.vpId || 'default') : null;
+  const tag = groupId ? { groupId } : { vpId };
+
   if (!session?.dreamScheduler) {
     sendToServer({
       type: 'unify_dream_result',
+      ...tag,
       success: false,
       error: 'Dream scheduler not initialized — session not loaded.',
     });
     return;
   }
 
-  const vpId = msg.vpId || 'default';
-
   try {
     sendToServer({
       type: 'unify_dream_status',
-      vpId,
+      ...tag,
       status: 'running',
     });
 
-    const result = await session.dreamScheduler.triggerDreamNow();
+    const result = groupId
+      ? await session.dreamScheduler.triggerDreamForScopes([`group/${groupId}`])
+      : await session.dreamScheduler.triggerDreamNow();
 
     // fix/dream-cadence-and-ui-trigger: derive a single "entries
     // created" count for the UI bubble. The runner returns a richer
@@ -2457,7 +2484,7 @@ export async function handleUnifyDreamTrigger(msg = {}) {
     // PR #743.
     sendToServer({
       type: 'unify_dream_result',
-      vpId,
+      ...tag,
       ...result,
       success: !result.error && !result.skipped,
       entriesCreated,
@@ -2466,7 +2493,7 @@ export async function handleUnifyDreamTrigger(msg = {}) {
   } catch (err) {
     sendToServer({
       type: 'unify_dream_result',
-      vpId,
+      ...tag,
       success: false,
       error: err?.message || String(err),
     });