@yeaft/webchat-agent 1.0.450 → 1.0.453

package/local-runtime/web/index.html

@@ -16,6 +16,6 @@
 </head>
 <body>
   <div id="app"></div>
-  <script type="module" src="app.bundle.js?v=0117a18d"></script>
+  <script type="module" src="app.bundle.js?v=1ef42512"></script>
 </body>
 </html>

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.450",
+  "version": "1.0.453",
   "description": "Remote worker agent for Yeaft Web Code Agent — connects the native Yeaft engine, CLI providers, and workbench tools",
   "main": "index.js",
   "type": "module",
   "bin": {
-    "yeaft-agent": "./cli.js",
-    "yeaft-agent-container": "./container-cli.js",
-    "yeaft": "./yeaft/cli.js",
-    "yeaft-stats": "./bin/yeaft-stats.js"
+    "yeaft-agent": "cli.js",
+    "yeaft-agent-container": "container-cli.js",
+    "yeaft": "yeaft/cli.js",
+    "yeaft-stats": "bin/yeaft-stats.js"
   },
   "scripts": {
     "start": "node index.js",

package/yeaft/debug-trace.js

@@ -754,8 +754,13 @@ function summarizeTrace(trace, detailsLoaded = false) {
     summaryInputTokens: loops.length > 0 ? usage.summaryInputTokens : Number(trace?.summaryInputTokens || 0),
     summaryOutputTokens: loops.length > 0 ? usage.summaryOutputTokens : Number(trace?.summaryOutputTokens || 0),
     loopCount: loops.length > 0 ? loops.length : Number(trace?.loopCount || 0),
-    memoryLoaded: null,
-    memoryAdjust: null,
+    memoryLoaded: Array.isArray(trace?.memoryLoaded) ? cloneJsonValue(trace.memoryLoaded) : null,
+    memoryLoadedMeta: trace?.memoryLoadedMeta && typeof trace.memoryLoadedMeta === 'object'
+      ? cloneJsonValue(trace.memoryLoadedMeta)
+      : null,
+    memoryAdjust: trace?.memoryAdjust && typeof trace.memoryAdjust === 'object'
+      ? cloneJsonValue(trace.memoryAdjust)
+      : null,
     tools: Array.isArray(trace?.tools) ? trace.tools.map(t => ({
       loopNumber: t.loopNumber || 0,
       callId: t.toolCallId || t.id || null,
@@ -910,7 +915,7 @@ export function projectDebugDetailForWire(detail, maxBytes = DEBUG_DETAIL_WIRE_M
   }
   for (const [turnIndex, turn] of (Array.isArray(wire.turns) ? wire.turns : []).entries()) {
     if (!turn || typeof turn !== 'object') continue;
-    for (const field of ['userPrompt', 'memoryLoaded', 'memoryAdjust']) {
+    for (const field of ['userPrompt', 'memoryLoaded', 'memoryLoadedMeta', 'memoryAdjust']) {
       addCandidate(turn, field, `turns[${turnIndex}].${field}`);
     }
     for (const [toolIndex, tool] of (Array.isArray(turn.tools) ? turn.tools : []).entries()) {
@@ -1212,7 +1217,7 @@ export class DebugTrace {
     this.#textMaxBytes = normalizeTextMaxBytes(nextValue, this.#textMaxBytes);
   }
 
-  startTurn({ traceId, messageId = null, mode = null, turnNumber = null, sessionId = null, vpId = null, threadId = null, userPrompt = null } = {}) {
+  startTurn({ traceId, messageId = null, mode = null, turnNumber = null, sessionId = null, vpId = null, threadId = null, userPrompt = null, memoryLoaded = null, memoryLoadedMeta = null } = {}) {
     if (!this.#acceptingWrites) return 'null';
     const turnRowId = randomUUID();
     const now = Date.now();
@@ -1225,6 +1230,8 @@ export class DebugTrace {
       vpId,
       threadId,
       userPrompt,
+      memoryLoaded,
+      memoryLoadedMeta,
       now,
       turnRowId,
     });
@@ -1584,7 +1591,7 @@ export class DebugTrace {
     await this.#drainWrites();
   }
 
-  #getOrCreateRequest({ traceId, turnNumber, messageId, mode, sessionId, vpId, threadId, userPrompt, now, turnRowId }) {
+  #getOrCreateRequest({ traceId, turnNumber, messageId, mode, sessionId, vpId, threadId, userPrompt, memoryLoaded, memoryLoadedMeta, now, turnRowId }) {
     const normalizedSessionId = sessionId || null;
     const isUsableExisting = (t) => (
       t?.sessionId === normalizedSessionId
@@ -1604,6 +1611,12 @@ export class DebugTrace {
       .at(-1) || null;
     if (existing) {
       existing.updatedAt = now;
+      if (!Array.isArray(existing.memoryLoaded) && Array.isArray(memoryLoaded)) {
+        existing.memoryLoaded = cloneJsonValue(memoryLoaded);
+      }
+      if (!existing.memoryLoadedMeta && memoryLoadedMeta && typeof memoryLoadedMeta === 'object') {
+        existing.memoryLoadedMeta = cloneJsonValue(memoryLoadedMeta);
+      }
       this.#requestCache.set(existing.requestKey, existing);
       return existing;
     }
@@ -1621,6 +1634,11 @@ export class DebugTrace {
       vpId: vpId || null,
       threadId: threadId || null,
       userPrompt: truncateText(userPrompt || '', this.#textMaxBytes),
+      memoryLoaded: Array.isArray(memoryLoaded) ? cloneJsonValue(memoryLoaded) : null,
+      memoryLoadedMeta: memoryLoadedMeta && typeof memoryLoadedMeta === 'object'
+        ? cloneJsonValue(memoryLoadedMeta)
+        : null,
+      memoryAdjust: null,
       openedAt: now,
       closedAt: null,
       updatedAt: now,

package/yeaft/dream/limits.js

@@ -20,6 +20,11 @@ export const MAX_SINGLE_MESSAGE_CHARS = 8000;
 export const MAX_DREAM_PROMPT_CHARS = 96000;
 export const MAX_DIFF_TOKENS_PER_TRIAGE = 60000;
 export const MAX_APPLY_TOKENS = 80000;
+// Dream writes compact canonical memory, not long-form user output. Keep the
+// response large enough for structured updates while bounding runaway cost.
+export const MAX_DREAM_OUTPUT_TOKENS = 8192;
+export const DREAM_FAILURE_BACKOFF_HOURS = 2;
+export const DREAM_FAILURE_BACKOFF_MAX_HOURS = 24;
 export const DREAM_BACKUP_KEEP = 7;
 
 // task-710: nudge dream off the 1h timer when a group has accumulated
@@ -35,6 +40,9 @@ export const DEFAULT_LIMITS = Object.freeze({
   MAX_DREAM_PROMPT_CHARS,
   MAX_DIFF_TOKENS_PER_TRIAGE,
   MAX_APPLY_TOKENS,
+  MAX_DREAM_OUTPUT_TOKENS,
+  DREAM_FAILURE_BACKOFF_HOURS,
+  DREAM_FAILURE_BACKOFF_MAX_HOURS,
   DREAM_BACKUP_KEEP,
   DREAM_NUDGE_AFTER_MESSAGES,
 });

package/yeaft/dream/runner.js

@@ -150,6 +150,17 @@ export async function runDream(opts) {
       sessionsReport.push({ sessionId, new: newCount, status: 'skipped', reason: 'below-threshold' });
       continue;
     }
+    const retryAt = dreamRetryAt(state, limits);
+    if (!opts.manual && retryAt && Date.parse(nowIso) < retryAt) {
+      sessionsReport.push({
+        sessionId,
+        new: newCount,
+        status: 'skipped',
+        reason: 'failure-backoff',
+        retryAt: new Date(retryAt).toISOString(),
+      });
+      continue;
+    }
 
     onProgress({ phase: 'load-diff', sessionId });
     const diffCursor = state.lastDreamMessageId;
@@ -182,6 +193,8 @@ export async function runDream(opts) {
           lastDreamMessageId: tailId,
           lastDreamAt: nowIso,
           messageCount: beforeCount,
+          failureCount: 0,
+          lastFailureAt: null,
         });
       }
       sessionsReport.push({ sessionId, new: newCount, status: 'skipped', reason: 'no-durable-new-messages' });
@@ -221,6 +234,7 @@ export async function runDream(opts) {
         stack: err.stack,
         rawSnippet: err.rawSnippet,
       });
+      await recordDreamFailure(opts.root, sessionId, state, nowIso);
       continue;
     }
 
@@ -232,7 +246,7 @@ export async function runDream(opts) {
     });
 
     const tailId = lastMessageId(diffNew);
-    processedSessions.push({ sessionId, tailId, beforeCount, newCount, segments: segments.length, actions: actions.length });
+    processedSessions.push({ sessionId, tailId, beforeCount, newCount, state, segments: segments.length, actions: actions.length });
     sessionsReport.push({ sessionId, new: newCount, segments: segments.length, actions: actions.length, status: 'triaged' });
   }
 
@@ -304,9 +318,21 @@ export async function runDream(opts) {
         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 });
+      if (r.errors.length > 0) {
+        const status = r.successfulScopes > 0 ? 'partial' : 'error';
+        const error = summarizeExtractionErrors(r.errors);
+        segmentReports.push({ sessionId: triage.sessionId, status, ...r, error });
+        onProgress({ phase: 'extract-segments', sessionId: triage.sessionId, status, ...r, error });
+        await writeDreamError(opts.root, `sessions/${triage.sessionId}`, {
+          phase: 'extract-segments',
+          message: error,
+          rawSnippet: r.errors.find(item => item.rawSnippet)?.rawSnippet,
+        });
+      } else {
+        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) {
       segmentReports.push({ sessionId: triage.sessionId, status: 'error', error: err.message });
       onProgress({ phase: 'extract-segments', sessionId: triage.sessionId, status: 'error', error: err.message });
@@ -349,18 +375,22 @@ export async function runDream(opts) {
     }
   }
 
-  // 7. bookkeep — advance a Session cursor only after every Apply target
-  // selected for that Session in this run completed successfully. Apply keeps
-  // all batch output in memory until the target's final canonical write, so a
-  // failed target has no durable progress that can safely move the cursor.
-  // Keeping the cursor on any target error lets the next run retry the failed
-  // target together with the same source diff.
+  // 7. bookkeep — advance a Session cursor only after every Apply target and
+  // its provenance extraction completed successfully. Apply keeps all batch
+  // output in memory until the target's final canonical write, while extraction
+  // reports per-scope failures after any successful writes. Either failure must
+  // retain the source diff so the next run can retry it rather than permanently
+  // losing canonical content or evidence.
   const targetStatus = new Map(targetsReport.map(report => [report.target, report.status]));
+  const extractionStatus = new Map(segmentReports.map(report => [report.sessionId, report.status]));
   for (const pg of processedSessions) {
     const sessionTargets = targetsToApply
       .filter(target => target.sources.some(source => source.sessionId === pg.sessionId))
       .map(target => target.target);
-    if (sessionTargets.length === 0 || !sessionTargets.every(target => targetStatus.get(target) === 'done')) {
+    const applySucceeded = sessionTargets.length > 0
+      && sessionTargets.every(target => targetStatus.get(target) === 'done');
+    if (!applySucceeded || extractionStatus.get(pg.sessionId) !== 'done') {
+      await recordDreamFailure(opts.root, pg.sessionId, pg.state, nowIso);
       continue;
     }
     if (pg.tailId) {
@@ -368,6 +398,8 @@ export async function runDream(opts) {
         lastDreamMessageId: pg.tailId,
         lastDreamAt: nowIso,
         messageCount: pg.beforeCount,
+        failureCount: 0,
+        lastFailureAt: null,
       });
     }
   }
@@ -399,6 +431,35 @@ export async function runDream(opts) {
 
 // ─── helpers ──────────────────────────────────────────────────
 
+function summarizeExtractionErrors(errors) {
+  const details = errors
+    .slice(0, 3)
+    .map(item => `${item.scope}: ${String(item.error || 'unknown error').slice(0, 300)}`)
+    .join('; ');
+  return `Dream segment extraction failed for ${errors.length} scope(s): ${details}`;
+}
+
+function dreamRetryAt(state, limits) {
+  const failureCount = Math.max(0, Number(state?.failureCount) || 0);
+  const failedAt = Date.parse(state?.lastFailureAt || '');
+  if (failureCount === 0 || !Number.isFinite(failedAt)) return null;
+  const hours = Math.min(
+    limits.DREAM_FAILURE_BACKOFF_MAX_HOURS,
+    limits.DREAM_FAILURE_BACKOFF_HOURS * (2 ** Math.max(0, failureCount - 1)),
+  );
+  return failedAt + hours * 60 * 60 * 1000;
+}
+
+async function recordDreamFailure(root, sessionId, state, nowIso) {
+  await writeSessionState(root, sessionId, {
+    lastDreamMessageId: state?.lastDreamMessageId || null,
+    lastDreamAt: state?.lastDreamAt || null,
+    messageCount: Number(state?.messageCount) || 0,
+    failureCount: Math.max(0, Number(state?.failureCount) || 0) + 1,
+    lastFailureAt: nowIso,
+  });
+}
+
 function lastMessageId(messages) {
   if (!Array.isArray(messages) || messages.length === 0) return null;
   for (let i = messages.length - 1; i >= 0; i -= 1) {

package/yeaft/dream/segment-extract.js

@@ -50,13 +50,16 @@ export async function extractAndWriteMemorySegments(opts) {
   if (typeof opts.llm !== 'function') throw new Error('extractAndWriteMemorySegments: llm required');
 
   const messages = normalizeMessages(opts.messages || []);
-  if (messages.length === 0) return { scopes: 0, segments: 0, errors: [] };
+  if (messages.length === 0) {
+    return { scopes: 0, segments: 0, attemptedScopes: 0, successfulScopes: 0, errors: [] };
+  }
   const allowedSourceIds = new Set(messages.map(message => message.id));
 
   const targetScopes = normalizeTargetScopes(opts.sessionId, opts.targets || []);
   const now = opts.nowIso ? opts.nowIso() : new Date().toISOString();
   let segmentCount = 0;
   let scopeCount = 0;
+  let successfulScopes = 0;
   const errors = [];
 
   for (const scope of targetScopes) {
@@ -72,6 +75,7 @@ export async function extractAndWriteMemorySegments(opts) {
         allowedSourceIds,
         maxPromptChars: opts.limits?.MAX_DREAM_PROMPT_CHARS,
       });
+      successfulScopes += 1;
     } catch (err) {
       errors.push({ scope, error: err.message, rawSnippet: err.rawSnippet || '' });
     }
@@ -92,7 +96,13 @@ export async function extractAndWriteMemorySegments(opts) {
     scopeCount += 1;
   }
 
-  return { scopes: scopeCount, segments: segmentCount, errors };
+  return {
+    scopes: scopeCount,
+    segments: segmentCount,
+    attemptedScopes: targetScopes.length,
+    successfulScopes,
+    errors,
+  };
 }
 
 async function extractScopeSegments({ scope, sessionId, messages, llm, language, now, allowedSourceIds, maxPromptChars }) {

package/yeaft/dream/session-wiring.js

@@ -44,6 +44,7 @@ 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 { parseModelRef, resolveMaxOutputTokens, resolveModel } from '../models.js';
 import { listSessions as listSessionMetas } from '../sessions/session-store.js';
 import { readSessionState } from './state.js';
 import { boundDreamPrompt } from './segment.js';
@@ -380,12 +381,16 @@ function makeLlm(session) {
     const dreamLimits = loadLimitsFromConfig(effectiveConfig);
     const boundedPrompt = boundDreamPrompt(prompt, dreamLimits.MAX_DREAM_PROMPT_CHARS);
 
+    const { modelId } = parseModelRef(model);
+    const modelMaxOutput = resolveMaxOutputTokens(modelId, effectiveConfig);
+    const maxTokens = Math.min(modelMaxOutput, dreamLimits.MAX_DREAM_OUTPUT_TOKENS);
     const r = await adapter.call({
       model,
       system: effectiveSystem,
       messages: [{ role: 'user', content: boundedPrompt }],
-      maxTokens: 2048,
-      modelEffort: effectiveConfig?.modelEffort || undefined,
+      maxTokens,
+      effort: effectiveConfig?.modelEffort || undefined,
+      effortSource: effectiveConfig?.modelEffort ? 'user' : undefined,
     });
 
     // Emit complete loop event (request + response) to the debug panel.
@@ -417,7 +422,7 @@ function makeLlm(session) {
       usage,
       latencyMs,
       ttfbMs: null,
-      stopReason: 'end_turn',
+      stopReason: r?.stopReason || 'end_turn',
       rawRequest: null,
       rawResponse: null,
     });
@@ -426,6 +431,13 @@ function makeLlm(session) {
       session._dreamProgressSink(loopEvent);
     }
 
+    if (r?.stopReason === 'max_tokens') {
+      const err = new Error(`Dream ${pass} response exceeded the ${maxTokens}-token output limit`);
+      err.code = 'DREAM_OUTPUT_TRUNCATED';
+      err.rawSnippet = typeof r.text === 'string' ? r.text.slice(-1000) : '';
+      throw err;
+    }
+
     return (r && r.text) ? r.text : '';
   };
 }
@@ -433,10 +445,34 @@ 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);
+  const sessionConfig = sessionId && session?.yeaftDir
+    ? loadSessionConfig(session.yeaftDir, sessionId)
+    : null;
+  const effective = sessionConfig && Object.keys(sessionConfig).length > 0
+    ? resolveSessionConfig(base, sessionConfig)
+    : { ...base };
+  const model = effective.primaryModel || effective.model;
+  if (!model) return effective;
+
+  const { providerName, modelId } = parseModelRef(model);
+  const catalogEntry = Array.isArray(effective.availableModels)
+    ? effective.availableModels.find(entry => entry?.ref === model
+      || (entry?.id === modelId && (!providerName || entry?.provider === providerName)))
+    : null;
+  const registryInfo = resolveModel(modelId);
+  const modelInfo = {
+    ...(registryInfo || {}),
+    ...(catalogEntry || {}),
+  };
+
+  // The live Session object belongs to the Session that triggered Dream. A
+  // target Session may select another model, so its cached modelInfo and token
+  // limits are not valid here. Rebuild modelInfo from the target catalog entry
+  // and let the resolver use the bare model id for registry/models.dev lookup.
+  return {
+    ...effective,
+    modelInfo: Object.keys(modelInfo).length > 0 ? modelInfo : null,
+  };
 }
 
 

package/yeaft/dream/state.js

@@ -8,11 +8,13 @@
  *
  *        ~/.yeaft/memory/sessions/<id>/.dream-state
  *
- *      A 3-line text file:
+ *      A small line-oriented text file:
  *
  *        lastDreamMessageId: m-1024
  *        lastDreamAt: 2026-04-28T03:07:00Z
  *        messageCount: 491
+ *        failureCount: 0
+ *        lastFailureAt:
  *
  *      Fields are independent of each other; missing fields default to
  *      empty / null / 0. The file is rewritten atomically every dream.
@@ -60,11 +62,17 @@ const DREAM_BLOCK_CLOSE = '<!-- /dream-state -->';
  *
  * @param {string} root — memory root, e.g. ~/.yeaft/memory
  * @param {string} sessionId
- * @returns {Promise<{ lastDreamMessageId: string|null, lastDreamAt: string|null, messageCount: number }>}
+ * @returns {Promise<{ lastDreamMessageId: string|null, lastDreamAt: string|null, messageCount: number, failureCount: number, lastFailureAt: string|null }>}
  */
 export async function readSessionState(root, sessionId) {
   const abs = join(root, 'sessions', sessionId, STATE_FILE);
-  const empty = { lastDreamMessageId: null, lastDreamAt: null, messageCount: 0 };
+  const empty = {
+    lastDreamMessageId: null,
+    lastDreamAt: null,
+    messageCount: 0,
+    failureCount: 0,
+    lastFailureAt: null,
+  };
   let raw;
   try { raw = await fsp.readFile(abs, 'utf8'); }
   catch (err) {
@@ -80,16 +88,20 @@ export async function readSessionState(root, sessionId) {
  *
  * @param {string} root
  * @param {string} sessionId
- * @param {{ lastDreamMessageId?: string|null, lastDreamAt?: string|null, messageCount?: number }} state
+ * @param {{ lastDreamMessageId?: string|null, lastDreamAt?: string|null, messageCount?: number, failureCount?: number, lastFailureAt?: string|null }} state
  */
 export async function writeSessionState(root, sessionId, state) {
   const dir = join(root, 'sessions', sessionId);
   await fsp.mkdir(dir, { recursive: true });
   const abs = join(dir, STATE_FILE);
+  const current = existsSync(abs) ? await readSessionState(root, sessionId) : {};
+  const merged = { ...current, ...state };
   const body =
-    `lastDreamMessageId: ${state.lastDreamMessageId == null ? '' : state.lastDreamMessageId}\n` +
-    `lastDreamAt: ${state.lastDreamAt == null ? '' : state.lastDreamAt}\n` +
-    `messageCount: ${Number.isFinite(state.messageCount) ? state.messageCount : 0}\n`;
+    `lastDreamMessageId: ${merged.lastDreamMessageId == null ? '' : merged.lastDreamMessageId}\n` +
+    `lastDreamAt: ${merged.lastDreamAt == null ? '' : merged.lastDreamAt}\n` +
+    `messageCount: ${Number.isFinite(merged.messageCount) ? merged.messageCount : 0}\n` +
+    `failureCount: ${Number.isFinite(merged.failureCount) ? Math.max(0, Math.floor(merged.failureCount)) : 0}\n` +
+    `lastFailureAt: ${merged.lastFailureAt == null ? '' : merged.lastFailureAt}\n`;
   await atomicWrite(abs, body);
 }
 
@@ -99,7 +111,13 @@ export async function writeSessionState(root, sessionId, state) {
  * @param {string} raw
  */
 function parseSessionState(raw) {
-  const out = { lastDreamMessageId: null, lastDreamAt: null, messageCount: 0 };
+  const out = {
+    lastDreamMessageId: null,
+    lastDreamAt: null,
+    messageCount: 0,
+    failureCount: 0,
+    lastFailureAt: null,
+  };
   const lines = String(raw || '').split(/\r?\n/);
   for (const ln of lines) {
     const m = /^(\w[\w-]*)\s*:\s*(.*)$/.exec(ln);
@@ -111,7 +129,10 @@ function parseSessionState(raw) {
     else if (k === 'messageCount') {
       const n = Number(v);
       out.messageCount = Number.isFinite(n) ? n : 0;
-    }
+    } else if (k === 'failureCount') {
+      const n = Number(v);
+      out.failureCount = Number.isFinite(n) ? Math.max(0, Math.floor(n)) : 0;
+    } else if (k === 'lastFailureAt') out.lastFailureAt = v || null;
   }
   return out;
 }

package/yeaft/engine.js

@@ -2177,6 +2177,12 @@ export class Engine {
       memoryInjection = amsContext.snapshotBlock;
     }
     const loadedMemoryForDebug = loadedMemoryDebugEntries(amsContext?.snapshot);
+    const loadedMemoryMetaForDebug = {
+      recallLimit: resolveMemoryRecallLimit(this.#config),
+      recallCandidates: Number.isFinite(recallResult?.meta?.hitCount)
+        ? recallResult.meta.hitCount
+        : (recallResult && Array.isArray(recallResult.entries) ? recallResult.entries.length : 0),
+    };
 
     // Diagnostic payload for the Dream debug panel. The full AMS Resident
     // layer can include user and per-VP summaries, but the browser-facing
@@ -2443,12 +2449,7 @@ export class Engine {
         type: 'memory_used',
         turnId: queryTurnId,
         loaded: loadedMemoryForDebug,
-        meta: {
-          recallLimit: resolveMemoryRecallLimit(this.#config),
-          recallCandidates: Number.isFinite(recallResult?.meta?.hitCount)
-            ? recallResult.meta.hitCount
-            : (recallResult && Array.isArray(recallResult.entries) ? recallResult.entries.length : 0),
-        },
+        meta: loadedMemoryMetaForDebug,
       };
     }
 
@@ -2580,6 +2581,10 @@ export class Engine {
         // from `messages.find(role==='user')` would always return turn
         // 1's prompt and mislabel every subsequent Turn header.
         userPrompt: userQuestionPreview,
+        // Persist the exact AMS projection that produced memoryInjection. Live
+        // memory_used events are only progress signals and disappear on reload.
+        memoryLoaded: loadedMemoryForDebug,
+        memoryLoadedMeta: loadedMemoryMetaForDebug,
       });
 
       const startTime = Date.now();

package/yeaft/llm/adapter.js

@@ -651,7 +651,7 @@ export class LLMAdapter {
    * Make a single model call without tools (for side queries like summarization).
    *
    * @param {{ model: string, system: string, messages: UnifiedMessage[], maxTokens?: number, signal?: AbortSignal }} params
-   * @returns {Promise<{ text: string, usage: { inputTokens: number, outputTokens: number } }>}
+   * @returns {Promise<{ text: string, stopReason?: 'end_turn'|'tool_use'|'max_tokens', usage: { inputTokens: number, outputTokens: number } }>}
    */
   async call(params) { // eslint-disable-line no-unused-vars
     throw new Error('call() must be implemented by subclass');

package/yeaft/llm/anthropic.js

@@ -581,6 +581,7 @@ export class AnthropicAdapter extends LLMAdapter {
 
     return {
       text,
+      stopReason: this.#mapStopReason(result.stop_reason),
       usage: {
         inputTokens: result.usage?.input_tokens || 0,
         outputTokens: result.usage?.output_tokens || 0,

package/yeaft/llm/openai-responses.js

@@ -594,6 +594,7 @@ export class OpenAIResponsesAdapter extends LLMAdapter {
     const usage = result.usage || {};
     return {
       text,
+      stopReason: this.#mapStopReason(result, false),
       usage: {
         inputTokens: usage.input_tokens || 0,
         outputTokens: usage.output_tokens || 0,

package/yeaft/llm/router.js

@@ -668,7 +668,7 @@ export class AdapterRouter extends LLMAdapter {
    * Make a single model call — routes to the correct provider adapter.
    *
    * @param {import('./adapter.js').CallParams} params
-   * @returns {Promise<{ text: string, usage: { inputTokens: number, outputTokens: number } }>}
+   * @returns {Promise<{ text: string, stopReason?: 'end_turn'|'tool_use'|'max_tokens', usage: { inputTokens: number, outputTokens: number } }>}
    */
   async call(params) {
     const dispatchSnapshot = this.#captureDispatchSnapshot();