@yeaft/webchat-agent 1.0.90 → 1.0.94

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.90",
+  "version": "1.0.94",
   "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/dream/output-snapshot.js

@@ -10,7 +10,8 @@
 import { join } from 'node:path';
 
 import { readMemory, readSummary } from '../memory/store.js';
-import { readSessionState } from './state.js';
+import { readDreamError, readSessionState } from './state.js';
+import { buildRunDreamOpts } from './session-wiring.js';
 
 export const DREAM_SNAPSHOT_TEXT_LIMIT = 6000;
 
@@ -32,7 +33,7 @@ export async function buildDreamOutputSnapshot(sessionLike, sessionId) {
   const scope = `sessions/${sessionId}`;
   const memoryScope = { kind: 'session', id: sessionId };
   const root = join(sessionLike.yeaftDir, 'memory');
-  const [memoryRaw, summaryRaw, state] = await Promise.all([
+  const [memoryRaw, summaryRaw, state, lastError] = await Promise.all([
     readMemory(memoryScope, { root }).catch(() => ''),
     readSummary(memoryScope, { root }).catch(() => ''),
     readSessionState(root, sessionId).catch(() => ({
@@ -40,7 +41,9 @@ export async function buildDreamOutputSnapshot(sessionLike, sessionId) {
       lastDreamAt: null,
       messageCount: 0,
     })),
+    readDreamError(root, scope).catch(() => null),
   ]);
+  const totalMessageCount = await countSessionMessages(sessionLike, sessionId);
   const memory = truncateDreamText(memoryRaw);
   const summary = truncateDreamText(summaryRaw);
   return {
@@ -50,10 +53,26 @@ export async function buildDreamOutputSnapshot(sessionLike, sessionId) {
     lastDreamAt: state?.lastDreamAt || null,
     lastDreamMessageId: state?.lastDreamMessageId || null,
     messageCount: Number.isFinite(state?.messageCount) ? state.messageCount : 0,
+    totalMessageCount,
     hasOutput: !!(memoryRaw || summaryRaw),
+    lastError,
     memoryText: memory.text,
     memoryTruncated: memory.truncated,
     summaryText: summary.text,
     summaryTruncated: summary.truncated,
   };
 }
+
+async function countSessionMessages(sessionLike, sessionId) {
+  try {
+    const opts = buildRunDreamOpts({
+      yeaftDir: sessionLike.yeaftDir,
+      config: sessionLike.config || {},
+      adapter: { call: async () => ({ text: '', usage: {} }) },
+    });
+    const n = await opts.countMessages(sessionId);
+    return Number.isFinite(n) ? n : 0;
+  } catch {
+    return 0;
+  }
+}

package/yeaft/dream/runner.js

@@ -45,7 +45,7 @@ import { listScopes, readSummary } from '../memory/store.js';
 import {
   DEFAULT_LIMITS,
 } from './limits.js';
-import { readSessionState, writeSessionState, writeDreamError } from './state.js';
+import { clearDreamError, readSessionState, writeSessionState, writeDreamError } from './state.js';
 import { segmentDiff, truncateMessage, estimateMessagesTokens } from './segment.js';
 import { triageGroupSegments } from './triage.js';
 import { mergeByTarget } from './merge.js';
@@ -166,7 +166,7 @@ export async function runDream(opts) {
         sessionId,
         segments,
         topicSummaries,
-        llm: opts.llm,
+        llm: dreamLlmForSession(opts.llm, sessionId),
         onProgress,
         language: opts.language,
       });
@@ -208,13 +208,14 @@ export async function runDream(opts) {
       const r = await applyMergedTarget(merged, {
         root: opts.root,
         ts,
-        llm: opts.llm,
+        llm: dreamLlmForSession(opts.llm, sourceSessionId(merged)),
         limits,
         nowIso: opts.nowIso || (() => nowIso),
         onProgress,
         siblingTopicsFor: opts.siblingTopicsFor,
         language: opts.language,
       });
+      await clearDreamError(opts.root, merged.target);
       targetsReport.push({ ...r, sources: merged.sources.length, status: 'done' });
     } catch (err) {
       targetsReport.push({
@@ -252,11 +253,12 @@ export async function runDream(opts) {
         sessionId: triage.sessionId,
         messages: triage.diff,
         targets,
-        llm: opts.llm,
+        llm: dreamLlmForSession(opts.llm, triage.sessionId),
         language: opts.language,
         nowIso: opts.nowIso || (() => nowIso),
         segmentIndex: opts.segmentIndex || null,
       });
+      await clearDreamError(opts.root, `sessions/${triage.sessionId}`);
       segmentReports.push({ sessionId: triage.sessionId, status: 'done', ...r });
       onProgress({ phase: 'extract-segments', sessionId: triage.sessionId, status: 'done', ...r });
     } catch (err) {
@@ -335,6 +337,10 @@ function deriveSessionFilter(filter) {
   return sessions.length > 0 ? new Set(sessions) : null;
 }
 
+function dreamLlmForSession(llm, sessionId) {
+  return (req = {}) => llm({ ...req, sessionId: req.sessionId || sessionId || null });
+}
+
 function sourceSessionId(mergedTarget) {
   const src = Array.isArray(mergedTarget?.sources) ? mergedTarget.sources[0] : null;
   return src && typeof src.sessionId === 'string' ? src.sessionId : '';

package/yeaft/dream/session-wiring.js

@@ -43,6 +43,8 @@ import { join } from 'path';
 import { runDream } from './runner.js';
 import { createDreamScheduler } from './schedule.js';
 import { parseMessage, parseSeqFromId } from '../conversation/persist.js';
+import { loadSessionConfig, resolveSessionConfig } from '../sessions/session-config.js';
+import { listSessions as listSessionMetas } from '../sessions/session-store.js';
 import { readSessionState } from './state.js';
 import { DREAM_NUDGE_AFTER_MESSAGES, DREAM_INTERVAL_HOURS } from './limits.js';
 
@@ -83,7 +85,7 @@ export function buildRunDreamOpts(session, onProgress) {
     segmentIndex: session.memoryIndex || null,
     llm: makeLlm(session),
     listSessions: async () => {
-      try { return listConversationSessions([sessionConversationsRoot, legacySessionConversationsRoot]); }
+      try { return listRegisteredSessions([sessionConversationsRoot, legacySessionConversationsRoot]); }
       catch { return []; }
     },
     countMessages: async (sessionId) => {
@@ -132,15 +134,25 @@ function translateSessionConversationMessage(m) {
 }
 
 /**
- * Enumerate session ids that have persisted conversation messages. `sessions/`
- * is the primary layout; `groups/` is read-only legacy fallback.
+ * Enumerate sessions from authoritative session metadata first, then fall back
+ * to legacy transcript-only directories. Message presence is not used as the
+ * source of truth: a stale/corrupt JSONL index must not make Dream forget that
+ * a Session exists. The runner's .dream-state cursor decides whether there is
+ * anything new to process.
  *
  * @param {string[]} roots session transcript roots in priority order
  * @returns {string[]}
  */
-function listConversationSessions(roots) {
+function listRegisteredSessions(roots) {
   const out = new Set();
-  for (const root of roots) {
+  const [sessionsRoot, ...legacyRoots] = roots;
+  try {
+    for (const meta of listSessionMetas(sessionsRoot)) {
+      if (meta?.id) out.add(meta.id);
+    }
+  } catch { /* fall through to legacy fallback */ }
+
+  for (const root of legacyRoots) {
     if (!existsSync(root)) continue;
     for (const name of readdirSync(root)) {
       if (name.startsWith('.')) continue;
@@ -149,8 +161,8 @@ function listConversationSessions(roots) {
         if (!hasReadableMessages(dir)) continue;
         out.add(name);
       } catch {
-        // Ignore partial or old session directories. Dream only needs sessions
-        // with readable conversation messages.
+        // Ignore partial old directories. Canonical sessions come from
+        // sessions/<id>/session.json above; this branch is read-only legacy.
       }
     }
   }
@@ -210,14 +222,13 @@ function hasJsonlMessages(dir) {
 
 function loadSessionDiskMessages(dir, sessionId) {
   const conversationDir = join(dir, 'conversation');
-  return [
-    // Prefer the canonical ConversationStore projection when it exists: it has
-    // normalized role/content/tool metadata. The session append-only audit log
-    // is still load-bearing for sessions created before/while conversation rows
-    // were being migrated to JSONL.
-    ...loadConversationDirMessages(conversationDir),
-    ...loadSessionJsonlMessages(join(dir, 'messages'), sessionId),
-  ];
+  // Canonical conversation history is the source Dream needs: it contains the
+  // full user/assistant timeline. The session audit log under messages/ is a
+  // fallback for older or partially migrated sessions, not a second source to
+  // union in — otherwise the same user turn can appear twice with different ids.
+  const canonical = loadConversationDirMessages(conversationDir);
+  if (canonical.length > 0) return canonical;
+  return loadSessionJsonlMessages(join(dir, 'messages'), sessionId);
 }
 
 function loadConversationDirMessages(conversationDir) {
@@ -323,9 +334,13 @@ function safeDirComponent(s) {
  * @param {Object} session
  */
 function makeLlm(session) {
-  return async ({ pass, prompt, system }) => {
+  return async ({ pass, prompt, system, sessionId }) => {
     const adapter = session.adapter;
-    const model = session.config?.fastModelId || session.config?.model;
+    const effectiveConfig = resolveDreamSessionConfig(session, sessionId);
+    const model = effectiveConfig?.model || effectiveConfig?.primaryModel;
+    if (!model) {
+      throw new Error(`dream: no session model configured (pass=${pass}, sessionId=${sessionId || 'unknown'})`);
+    }
     if (!adapter || typeof adapter.call !== 'function') {
       throw new Error(`dream: no adapter.call available (pass=${pass})`);
     }
@@ -335,7 +350,7 @@ function makeLlm(session) {
     session._dreamLoopCounter = (session._dreamLoopCounter || 0) + 1;
     const loopNumber = session._dreamLoopCounter;
     const turnId = session._dreamTurnId || 'dream';
-    const effectiveSystem = system || (String(session.config?.language || '').toLowerCase().startsWith('zh')
+    const effectiveSystem = system || (String(effectiveConfig?.language || '').toLowerCase().startsWith('zh')
       ? `你是梦境流水线 — pass: ${pass}。请用中文生成自然语言内容；JSON key 保持英文。`
       : `You are the dream pipeline — pass: ${pass}.`);
 
@@ -344,6 +359,7 @@ function makeLlm(session) {
       system: effectiveSystem,
       messages: [{ role: 'user', content: prompt }],
       maxTokens: 2048,
+      modelEffort: effectiveConfig?.modelEffort || undefined,
     });
 
     // Emit complete loop event (request + response) to the debug panel.
@@ -366,6 +382,7 @@ function makeLlm(session) {
       loopNumber,
       pass,
       model: model || 'unknown',
+      sessionId: sessionId || null,
       systemPrompt: effectiveSystem,
       messages: [{ role: 'user', content: prompt }],
       response: typeof r?.text === 'string' ? r.text : '',
@@ -387,6 +404,15 @@ function makeLlm(session) {
 }
 
 
+function resolveDreamSessionConfig(session, sessionId) {
+  const base = session?.config || {};
+  if (!sessionId || !session?.yeaftDir) return { ...base };
+  const sessionConfig = loadSessionConfig(session.yeaftDir, sessionId);
+  if (!sessionConfig || Object.keys(sessionConfig).length === 0) return { ...base };
+  return resolveSessionConfig(base, sessionConfig);
+}
+
+
 function stampDreamScope(session, evt) {
   if (!evt || typeof evt !== 'object') return evt;
   if (evt.sessionId || !session?._dreamActiveGroupId) return evt;
@@ -646,7 +672,7 @@ export async function bootInitEmptyGroups(args) {
   if (!args || !args.memoryIndex || !args.dreamScheduler) return out;
   const sessionsRoot = join(args.yeaftDir, 'sessions');
   let ids;
-  try { ids = listSessions(sessionsRoot).map(g => g.id); }
+  try { ids = listSessionMetas(sessionsRoot).map(g => g.id); }
   catch { return out; }
   const empty = [];
   for (const gid of ids) {
@@ -656,11 +682,7 @@ export async function bootInitEmptyGroups(args) {
     if (segCount > 0) continue;
     let hasMessages = false;
     try {
-      const h = openSession(sessionsRoot, gid);
-      // Any message at all is enough — pull the first record off the
-      // iterator and stop.
-      const first = h.streamMessages().next();
-      hasMessages = !first.done;
+      hasMessages = loadSessionConversationMessages([sessionsRoot], gid).length > 0;
     } catch { continue; }
     if (!hasMessages) continue;
     empty.push(`sessions/${gid}`);
@@ -716,7 +738,7 @@ export async function bootCatchUpStaleDream(args) {
   const now = args.now ?? Date.now();
 
   let sessionIds;
-  try { sessionIds = listSessions(sessionsRoot).map(g => g.id); }
+  try { sessionIds = listSessionMetas(sessionsRoot).map(g => g.id); }
   catch { return out; }
 
   // Find the newest lastDreamAt across all groups.
@@ -732,9 +754,7 @@ export async function bootCatchUpStaleDream(args) {
     }
     if (!anyTraffic) {
       try {
-        const h = openSession(sessionsRoot, gid);
-        const first = h.streamMessages().next();
-        if (!first.done) anyTraffic = true;
+        if (loadSessionConversationMessages([sessionsRoot], gid).length > 0) anyTraffic = true;
       } catch { /* keep going */ }
     }
   }

package/yeaft/dream/state.js

@@ -187,6 +187,19 @@ export async function writeDreamError(root, scope, info) {
   }
 }
 
+/**
+ * Clear a scope's last Dream error after a successful pass. Best-effort: a
+ * missing file is fine and I/O failure must not turn success into failure.
+ *
+ * @param {string} root
+ * @param {string} scope
+ * @returns {Promise<void>}
+ */
+export async function clearDreamError(root, scope) {
+  try { await fsp.unlink(join(scopeDirFor(root, scope), ERROR_FILE)); }
+  catch { /* best-effort */ }
+}
+
 /**
  * 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

package/yeaft/sessions/recovery.js

@@ -0,0 +1,187 @@
+/**
+ * recovery.js — best-effort Session disk self-recovery.
+ *
+ * Instances can contain old partially migrated Session dirs where the
+ * conversation transcript still exists under conversation/messages/*.md, but
+ * session.json is missing. This module repairs Session metadata and the
+ * coordinator audit-log index only. It deliberately does not convert
+ * conversation Markdown into the audit log: the engine/UI history source is
+ * ConversationStore under conversation/, not sessions/<id>/messages/.
+ */
+
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  statSync,
+} from 'fs';
+import { join } from 'path';
+import { writeAtomic, openLog } from '../storage/index.js';
+import { parseMessage, parseSeqFromId } from '../conversation/persist.js';
+import { loadSessionMeta, SESSION_META_FILE } from './session-store.js';
+
+const SESSION_ID_RE = /^session_[A-Za-z0-9._-]+$/;
+const DEFAULT_VP_ID = 'omni';
+const AUDIT_INDEX_FILE = 'index.json';
+
+export function repairSessionStore(yeaftDir, options = {}) {
+  const root = join(yeaftDir, 'sessions');
+  if (!existsSync(root)) return { repaired: 0, sessions: [] };
+  const sessionIds = safeReadDir(root)
+    .filter(name => !name.startsWith('.') && SESSION_ID_RE.test(name))
+    .filter(name => isDirectory(join(root, name)));
+  const sessions = [];
+  for (const sessionId of sessionIds) {
+    const result = repairSessionDir(root, sessionId, options);
+    if (result.changed) sessions.push(result);
+  }
+  return { repaired: sessions.length, sessions };
+}
+
+export function repairSessionDir(sessionsRoot, sessionId, options = {}) {
+  const dir = join(sessionsRoot, sessionId);
+  const result = {
+    sessionId,
+    changed: false,
+    metaCreated: false,
+    auditIndexRebuilt: false,
+  };
+  if (!isDirectory(dir)) return result;
+
+  if (!loadSessionMeta(dir)) {
+    const meta = inferSessionMeta(dir, sessionId, options);
+    writeAtomic(join(dir, SESSION_META_FILE), JSON.stringify(meta, null, 2));
+    result.metaCreated = true;
+    result.changed = true;
+  }
+
+  if (repairAuditIndexIfNeeded(join(dir, 'messages'))) {
+    result.auditIndexRebuilt = true;
+    result.changed = true;
+  }
+
+  return result;
+}
+
+function inferSessionMeta(dir, sessionId, options = {}) {
+  const first = readFirstConversationMarkdownRow(dir, sessionId);
+  const createdAt = first?.time || safeStatTime(dir) || new Date().toISOString();
+  const name = inferSessionName(sessionId);
+  const roster = Array.isArray(options.defaultRoster)
+    ? options.defaultRoster.filter(v => typeof v === 'string' && v)
+    : [DEFAULT_VP_ID];
+  const defaultVpId = typeof options.defaultVpId === 'string'
+    ? options.defaultVpId
+    : (roster.includes(DEFAULT_VP_ID) ? DEFAULT_VP_ID : (roster[0] || null));
+  return {
+    id: sessionId,
+    name,
+    roster,
+    defaultVpId,
+    announcement: '',
+    workDir: typeof options.workDir === 'string' ? options.workDir : '',
+    createdAt,
+  };
+}
+
+function inferSessionName(sessionId) {
+  const raw = sessionId
+    .replace(/^session_/, '')
+    .replace(/_[A-Z0-9]{8}$/, '')
+    .replace(/[-_]+/g, ' ')
+    .trim();
+  return raw ? raw.replace(/\b\w/g, ch => ch.toUpperCase()) : sessionId;
+}
+
+function readFirstConversationMarkdownRow(sessionDir, sessionId) {
+  const dirs = [
+    join(sessionDir, 'conversation', 'cold'),
+    join(sessionDir, 'conversation', 'messages'),
+  ];
+  let first = null;
+  for (const dir of dirs) {
+    if (!existsSync(dir)) continue;
+    for (const file of safeReadDir(dir).filter(f => /^m\d+\.md$/.test(f)).sort()) {
+      const msg = parseMessage(safeRead(join(dir, file)));
+      if (!msg) continue;
+      if (msg.sessionId && msg.sessionId !== sessionId) continue;
+      if (!first || compareMarkdownMessages(msg, first) < 0) first = msg;
+    }
+  }
+  return first;
+}
+
+function repairAuditIndexIfNeeded(messagesDir) {
+  if (!existsSync(messagesDir)) return false;
+  const segmentFiles = safeReadDir(messagesDir).filter(f => /^\d+\.jsonl$/.test(f)).sort();
+  if (segmentFiles.length === 0) return false;
+
+  const indexPath = join(messagesDir, AUDIT_INDEX_FILE);
+  if (!auditIndexNeedsRebuild(messagesDir, indexPath, segmentFiles)) return false;
+
+  rmSync(indexPath, { force: true });
+  const log = openLog(messagesDir);
+  log.close();
+  return true;
+}
+
+function auditIndexNeedsRebuild(messagesDir, indexPath, segmentFiles) {
+  const parsed = readJson(indexPath);
+  if (!parsed || !Array.isArray(parsed.segments)) return true;
+  const indexFiles = parsed.segments.map(seg => seg && seg.file).filter(Boolean).sort();
+  if (indexFiles.length !== segmentFiles.length) return true;
+  for (let i = 0; i < segmentFiles.length; i++) {
+    if (indexFiles[i] !== segmentFiles[i]) return true;
+  }
+
+  const byFile = new Map(parsed.segments.map(seg => [seg.file, seg]));
+  for (const file of segmentFiles) {
+    const seg = byFile.get(file);
+    if (!seg) return true;
+    const bytes = safeSize(join(messagesDir, file));
+    // This catches the broken real-world case: index says an existing segment
+    // is empty even though the JSONL file has data. Full validation is left to
+    // openLog's rebuild path after we remove the stale index.
+    if (bytes > 0 && ((Number(seg.count) || 0) === 0 || (Number(seg.bytes) || 0) === 0)) return true;
+  }
+  return false;
+}
+
+function compareMarkdownMessages(a, b) {
+  const as = parseSeqFromId(a?.id);
+  const bs = parseSeqFromId(b?.id);
+  if (Number.isFinite(as) && Number.isFinite(bs) && as !== bs) return as - bs;
+  return String(a?.time || '').localeCompare(String(b?.time || ''));
+}
+
+function readJson(path) {
+  try { return JSON.parse(readFileSync(path, 'utf8')); }
+  catch { return null; }
+}
+
+function safeRead(path) {
+  try { return readFileSync(path, 'utf8'); }
+  catch { return ''; }
+}
+
+function safeReadDir(dir) {
+  try { return readdirSync(dir); }
+  catch { return []; }
+}
+
+function isDirectory(path) {
+  try { return statSync(path).isDirectory(); }
+  catch { return false; }
+}
+
+function safeSize(path) {
+  try { return statSync(path).size; }
+  catch { return 0; }
+}
+
+function safeStatTime(path) {
+  try { return statSync(path).mtime.toISOString(); }
+  catch { return null; }
+}

package/yeaft/sessions/session-crud.js

@@ -57,6 +57,7 @@ import { nextSessionId, validateVpId, isReservedVpId } from './ids.js';
 import { scanVpLibrary, DEFAULT_VP_LIB_DIR } from '../vp/vp-store.js';
 import { seedSummaryIfMissingSync, removeScopeDirSync } from '../memory/store.js';
 import { ensureSessionConfigFile, saveSessionConfig, loadSessionConfig } from './session-config.js';
+import { repairSessionStore } from './recovery.js';
 import {
   addOrUpdateManifestSession,
   ensureSessionsManifest,
@@ -185,6 +186,17 @@ function copySessionExtras(sourceYeaftDir, destYeaftDir, sessionId) {
   }
 }
 
+function repairSessionStoreAndManifest(yeaftDir, options = {}) {
+  const repaired = repairSessionStore(yeaftDir, options);
+  ensureSessionManifestReady(yeaftDir);
+  for (const row of repaired.sessions || []) {
+    const dir = join(sessionsRoot(yeaftDir), row.sessionId);
+    const meta = loadSessionMeta(dir);
+    if (meta) addOrUpdateManifestSession(yeaftDir, meta, dir);
+  }
+  return repaired;
+}
+
 /**
  * One-way compatibility migration for sessions previously stored under a
  * project `.yeaft/sessions` tree. New steady-state discovery uses
@@ -380,7 +392,9 @@ function scanSortedVpIds(libDir) {
 export function ensureDefaultSessionIfEmpty(yeaftDir, options = {}) {
   const libDir = options.libDir || DEFAULT_VP_LIB_DIR;
   const memoryRoot = options.memoryRoot || DEFAULT_MEMORY_ROOT;
-  ensureSessionManifestReady(yeaftDir);
+  repairSessionStoreAndManifest(yeaftDir, {
+    defaultRoster: scanSortedVpIds(libDir),
+  });
   const existing = listManifestSessions(yeaftDir).map(row => row.meta);
   if (existing.length > 0) {
     return { seeded: false, sessionId: existing[0].id };
@@ -718,7 +732,7 @@ export function requireSession(yeaftDir, sessionId) {
 
 /** Convenience: snapshot all non-archived groups for WS broadcast. */
 export function snapshotSessions(yeaftDir) {
-  ensureSessionManifestReady(yeaftDir);
+  repairSessionStoreAndManifest(yeaftDir);
   const byId = new Map();
   for (const row of listManifestSessions(yeaftDir)) {
     byId.set(row.meta.id, row.meta);