@yeaft/webchat-agent 1.0.441 → 1.0.443

package/index.js

@@ -24,6 +24,7 @@ import { connect } from './connection.js';
 import { loadMcpServers } from './mcp.js';
 import { SAFE_REMOTE_UPGRADE_CAPABILITY } from './upgrade-command.js';
 import { loadConfig as loadYeaftConfig } from './yeaft/config.js';
+import { initYeaftDir } from './yeaft/init.js';
 import { updateBrowserRuntimeSettings } from './yeaft/config-api.js';
 import { bootBrowserRuntime, shutdownBrowserRuntime } from './browser-runtime/index.js';
 import {
@@ -106,12 +107,15 @@ const { agentName: AGENT_NAME, instanceId: INSTANCE_ID } = resolveRuntimeIdentit
 // WebSocket connection goes live, so downstream code can assume a real path.
 const YEAFT_DIR = process.env.YEAFT_DIR || fileConfig.yeaftDir || getDefaultYeaftDir(INSTANCE_ID);
 try {
-  if (!existsSync(YEAFT_DIR)) {
-    mkdirSync(YEAFT_DIR, { recursive: true, mode: 0o700 });
-    console.log(`[Agent] Created yeaft dir: ${YEAFT_DIR}`);
+  const initResult = initYeaftDir(YEAFT_DIR);
+  for (const warning of initResult.warnings || []) {
+    console.warn(`[Agent] ${warning}`);
+  }
+  if (initResult.created?.length > 0) {
+    console.log(`[Agent] Initialized yeaft dir: ${YEAFT_DIR}`);
   }
 } catch (err) {
-  console.warn(`[Agent] Could not ensure yeaft dir ${YEAFT_DIR}: ${err?.message || err}`);
+  console.warn(`[Agent] Could not initialize yeaft dir ${YEAFT_DIR}: ${err?.message || err}`);
 }
 
 const agentSecret = process.env.AGENT_SECRET_FILE

package/local-runtime/version.json

@@ -1 +1 @@
-{"version":"1.0.441"}
+{"version":"1.0.443"}

package/package.json

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

@@ -196,7 +196,7 @@ export function updateLlmConfig(update, dir) {
  * stable shape — `normaliseYeaftSection` guarantees that.
  *
  * @param {string} [dir] — Yeaft data directory
- * @returns {{ maxConcurrentThreads: number, autoArchiveIdleDays: number, recentTurnsLimit: number } | { error: string }}
+ * @returns {{ maxConcurrentThreads: number, autoArchiveIdleDays: number, recentTurnsLimit: number, dream: object } | { error: string }}
  */
 export function getYeaftSettings(dir) {
   const root = dir || process.env.YEAFT_DIR || DEFAULT_YEAFT_DIR;
@@ -215,14 +215,15 @@ export function getYeaftSettings(dir) {
  * Update the Yeaft-section of config.json. Merges into existing config
  * (LLM provider / model fields are untouched) and validates each field:
  * `maxConcurrentThreads` must be 1..50, `autoArchiveIdleDays` must be
- * 1..3650, `recentTurnsLimit` must be 1..500. Invalid values are rejected
+ * 1..3650, `recentTurnsLimit` must be 1..500. Dream limits are read-only
+ * runtime defaults here; invalid values are rejected
  * outright so the UI sees an error rather than silently reverting — a
  * silent revert would make "I set it to 100 and nothing happened"
  * impossible to debug.
  *
  * @param {{ maxConcurrentThreads?: number, autoArchiveIdleDays?: number, recentTurnsLimit?: number }} update
  * @param {string} [dir]
- * @returns {{ maxConcurrentThreads: number, autoArchiveIdleDays: number, recentTurnsLimit: number } | { error: string }}
+ * @returns {{ maxConcurrentThreads: number, autoArchiveIdleDays: number, recentTurnsLimit: number, dream: object } | { error: string }}
  */
 export function updateYeaftSettings(update, dir) {
   const root = dir || process.env.YEAFT_DIR || DEFAULT_YEAFT_DIR;
@@ -266,6 +267,9 @@ export function updateYeaftSettings(update, dir) {
           ? Math.floor(Number(update.recentTurnsLimit))
           : prev.recentTurnsLimit,
       };
+      if (existing.yeaft?.dream && typeof existing.yeaft.dream === 'object') {
+        merged.dream = existing.yeaft.dream;
+      }
       existing.yeaft = merged;
       return merged;
     });

package/yeaft/config.js

@@ -29,6 +29,7 @@ import { normalizeKnownProviderForRuntime } from './llm/known-providers.js';
 import { createDenyAllPluginConfig, normalizePluginConfig } from './plugins.js';
 import { normaliseBrowserRuntimeSection } from '../browser-runtime/config.js';
 import { readWorkspaceFile } from './workspace-file.js';
+import { DEFAULT_LIMITS } from './dream/limits.js';
 
 /** Default configuration values. */
 const DEFAULTS = {
@@ -254,13 +255,14 @@ function isTruthy(val) {
  * bounds via `clampYeaftField`.
  *
  * @param {any} raw — jsonConfig.yeaft (may be undefined / malformed)
- * @returns {{ maxConcurrentThreads: number, autoArchiveIdleDays: number }}
+ * @returns {{ maxConcurrentThreads: number, autoArchiveIdleDays: number, recentTurnsLimit: number, dream: object }}
  */
 export function normaliseYeaftSection(raw) {
   const out = {
     maxConcurrentThreads: DEFAULTS.yeaftMaxConcurrentThreads,
     autoArchiveIdleDays: DEFAULTS.yeaftAutoArchiveIdleDays,
     recentTurnsLimit: DEFAULTS.yeaftRecentTurnsLimit,
+    dream: { ...DEFAULT_LIMITS },
   };
   if (!raw || typeof raw !== 'object') return out;
   const mc = clampYeaftField(raw.maxConcurrentThreads, 'maxConcurrentThreads');
@@ -269,6 +271,13 @@ export function normaliseYeaftSection(raw) {
   if (ad !== null) out.autoArchiveIdleDays = ad;
   const rt = clampYeaftField(raw.recentTurnsLimit, 'recentTurnsLimit');
   if (rt !== null) out.recentTurnsLimit = rt;
+  const dream = raw.dream;
+  if (dream && typeof dream === 'object' && !Array.isArray(dream)) {
+    for (const key of Object.keys(DEFAULT_LIMITS)) {
+      const value = Number(dream[key]);
+      if (Number.isFinite(value) && value > 0) out.dream[key] = Math.floor(value);
+    }
+  }
   return out;
 }
 

package/yeaft/dream/apply.js

@@ -26,10 +26,16 @@ import { inspect } from 'util';
 import { writeContent, writeSummary, readContent, readMemory, readSummary } from '../memory/store.js';
 import { parseSegments } from '../memory/segment.js';
 import { syncScope } from '../memory/segment-sync.js';
-import { batchSourcesForApply, needsBatchedApply, truncateMessage } from './segment.js';
+import {
+  batchSourcesForApply,
+  boundDreamPrompt,
+  needsBatchedApply,
+  truncateMessage,
+} from './segment.js';
 import { snapshotScope } from './snapshot.js';
 import { parseJsonSafe } from './triage.js';
 import { render } from './prompts/index.js';
+import { MAX_DREAM_PROMPT_CHARS } from './limits.js';
 
 function malformedJsonError(message, raw) {
   const err = new Error(message);
@@ -239,7 +245,7 @@ export function targetToScope(target) {
  *   root: string,
  *   ts: string,                    // shared timestamp folder
  *   llm: (req: { pass: string, prompt: string, system: string }) => Promise<string>,
- *   limits?: { MAX_APPLY_TOKENS?: number },
+ *   limits?: { MAX_APPLY_TOKENS?: number, MAX_DREAM_PROMPT_CHARS?: number },
  *   snapshot?: typeof snapshotScope,
  *   nowIso?: () => string,
  *   onProgress?: (event: object) => void,
@@ -272,55 +278,81 @@ export async function applyMergedTarget(merged, opts) {
   }
 
   let batchesUsed = 0;
-  const maxApply = (opts.limits && opts.limits.MAX_APPLY_TOKENS) || undefined;
+  const maxApply = (opts.limits && opts.limits.MAX_APPLY_TOKENS) || 80000;
+  // Leave room for the prompt template and JSON framing. The bounded context
+  // and source chunks are prompt projections; canonical files remain complete.
+  const maxPromptChars = (opts.limits && opts.limits.MAX_DREAM_PROMPT_CHARS) || MAX_DREAM_PROMPT_CHARS;
+  const providerPromptBudget = Math.floor(maxPromptChars / 4) - 2048;
+  const promptBudget = Math.max(1024, Math.min(Math.floor(maxApply) - 2048, providerPromptBudget));
+  const initialContext = boundApplyContext(contentMd, summaryMd, promptBudget);
 
   if (merged.kind === 'create') {
     const siblings = opts.siblingTopicsFor ? await opts.siblingTopicsFor(merged.target) : [];
-    const prompt = buildCreatePrompt({
-      target: merged.target,
-      sources: merged.sources,
-      siblingTopics: siblings,
-      language: opts.language,
-    });
-    if (opts.onProgress) opts.onProgress({ phase: 'apply', target: merged.target, status: 'llm', batch: 1, of: 1 });
-    const raw = await opts.llm({ pass: 'create', prompt, system: applySystem(opts.language) });
-    const parsed = parseJsonSafe(raw);
-    const parsedContent = parsed && typeof parsed.content_md === 'string'
-      ? parsed.content_md
-      : (parsed && typeof parsed.memory_md === 'string' ? parsed.memory_md : null);
-    if (parsedContent === null) {
-      throw malformedJsonError(`apply: CREATE returned malformed JSON for ${merged.target}`, raw);
+    const sourceBatches = needsBatchedApply(
+      { memoryMd: '', summaryMd: '', sources: merged.sources },
+      promptBudget,
+    )
+      ? batchSourcesForApply({ memoryMd: '', summaryMd: '', sources: merged.sources }, promptBudget)
+      : [merged.sources];
+
+    let i = 0;
+    for (const batch of sourceBatches) {
+      i += 1;
+      const prompt = boundDreamPrompt(i === 1
+        ? buildCreatePrompt({
+          target: merged.target,
+          sources: batch,
+          siblingTopics: siblings,
+          language: opts.language,
+        })
+        : buildUpdatePrompt({
+          target: merged.target,
+          contentMd: boundApplyContext(contentMd, summaryMd, promptBudget).contentMd,
+          summaryMd: boundApplyContext(contentMd, summaryMd, promptBudget).summaryMd,
+          sources: batch,
+          batchInfo: { index: i, total: sourceBatches.length },
+          language: opts.language,
+        }), maxPromptChars);
+      if (opts.onProgress) opts.onProgress({ phase: 'apply', target: merged.target, status: 'llm', batch: i, of: sourceBatches.length });
+      const raw = await opts.llm({ pass: i === 1 ? 'create' : 'update', prompt, system: applySystem(opts.language) });
+      const parsed = parseJsonSafe(raw);
+      const parsedContent = parsed && typeof parsed.content_md === 'string'
+        ? parsed.content_md
+        : (parsed && typeof parsed.memory_md === 'string' ? parsed.memory_md : null);
+      if (parsedContent === null) {
+        throw malformedJsonError(`apply: ${i === 1 ? 'CREATE' : 'UPDATE'} batch ${i} returned malformed JSON for ${merged.target}`, raw);
+      }
+      const ensured = ensurePrimarySessionOutput({
+        target: merged.target,
+        memoryMd: parsedContent,
+        summaryMd: typeof parsed.summary_md === 'string' ? parsed.summary_md : summaryMd,
+        sources: batch,
+        language: opts.language,
+      });
+      contentMd = ensured.memoryMd;
+      summaryMd = ensured.summaryMd;
     }
-    const ensured = ensurePrimarySessionOutput({
-      target: merged.target,
-      memoryMd: parsedContent,
-      summaryMd: typeof parsed.summary_md === 'string' ? parsed.summary_md : '',
-      sources: merged.sources,
-      language: opts.language,
-    });
-    contentMd = ensured.memoryMd;
-    summaryMd = ensured.summaryMd;
-    batchesUsed = 1;
+    batchesUsed = sourceBatches.length;
   } else {
-    // UPDATE — possibly batched.
-    const batches = needsBatchedApply(
-      { memoryMd: contentMd, summaryMd, sources: merged.sources },
-      maxApply,
-    )
-      ? batchSourcesForApply({ memoryMd: contentMd, summaryMd, sources: merged.sources }, maxApply)
+    // UPDATE — possibly batched. A single Session source may be split into
+    // many bounded batches; old overlap is never present in merged.sources.
+    const input = { ...initialContext, sources: merged.sources };
+    const batches = needsBatchedApply(input, promptBudget)
+      ? batchSourcesForApply(input, promptBudget)
       : [merged.sources];
 
     let i = 0;
     for (const batch of batches) {
       i += 1;
-      const prompt = buildUpdatePrompt({
+      const context = boundApplyContext(contentMd, summaryMd, promptBudget);
+      const prompt = boundDreamPrompt(buildUpdatePrompt({
         target: merged.target,
-        contentMd,
-        summaryMd,
+        contentMd: context.contentMd,
+        summaryMd: context.summaryMd,
         sources: batch,
         batchInfo: { index: i, total: batches.length },
         language: opts.language,
-      });
+      }), maxPromptChars);
       if (opts.onProgress) opts.onProgress({ phase: 'apply', target: merged.target, status: 'llm', batch: i, of: batches.length });
       const raw = await opts.llm({ pass: 'update', prompt, system: applySystem(opts.language) });
       const parsed = parseJsonSafe(raw);
@@ -392,6 +424,27 @@ function scopeRelDir(scope) {
 
 function oneLine(s) { return String(s || '').replace(/\s+/g, ' ').trim().slice(0, 200); }
 
+function boundApplyContext(contentMd, summaryMd, budget) {
+  const maxChars = Math.max(4096, Math.floor(Math.max(1, budget) * 4));
+  const summary = truncatePromptText(summaryMd, Math.min(maxChars, 8_000));
+  const contentBudget = Math.max(0, maxChars - summary.length);
+  return {
+    contentMd: truncatePromptText(contentMd, contentBudget),
+    summaryMd: summary,
+  };
+}
+
+function truncatePromptText(value, maxChars) {
+  const text = String(value || '');
+  if (text.length <= maxChars) return text;
+  const marker = '\n\n[canonical memory clipped for Dream apply; durable source remains on disk]\n\n';
+  if (maxChars <= marker.length) return text.slice(0, Math.max(0, maxChars));
+  const room = maxChars - marker.length;
+  const head = Math.ceil(room * 0.62);
+  const tail = room - head;
+  return text.slice(0, head) + marker + (tail > 0 ? text.slice(-tail) : '');
+}
+
 function isLegacyCanonicalMemory(memoryMd, scope) {
   const raw = String(memoryMd || '').trim();
   if (!raw) return false;

package/yeaft/dream/limits.js

@@ -14,6 +14,10 @@ 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;
+// Provider tokenizers differ substantially for CJK and serialized tool text.
+// Keep an independent character ceiling so the approximate token budget cannot
+// turn into a multi-million-token wire request.
+export const MAX_DREAM_PROMPT_CHARS = 96000;
 export const MAX_DIFF_TOKENS_PER_TRIAGE = 60000;
 export const MAX_APPLY_TOKENS = 80000;
 export const DREAM_BACKUP_KEEP = 7;
@@ -28,6 +32,7 @@ export const DEFAULT_LIMITS = Object.freeze({
   DREAM_OVERLAP,
   MIN_NEW_PER_GROUP,
   MAX_SINGLE_MESSAGE_CHARS,
+  MAX_DREAM_PROMPT_CHARS,
   MAX_DIFF_TOKENS_PER_TRIAGE,
   MAX_APPLY_TOKENS,
   DREAM_BACKUP_KEEP,

package/yeaft/dream/runner.js

@@ -8,8 +8,7 @@
  *   enumerateSessions()                  via opts.listSessions()
  *     ↓
  *   for each session with newCount ≥ MIN_NEW_PER_GROUP (auto)
- *                    or > 0 (manual)
- *                    or prior messages in a scoped manual session rerun:
+ *                    or > 0 (manual):
  *       loadDiff()                     via opts.loadSessionDiff(sessionId, sinceId)
  *       applyOverlap()                 via opts.loadOverlapPreamble(...)
  *       segment()                      segmentDiff(...)
@@ -46,7 +45,11 @@ import {
   DEFAULT_LIMITS,
 } from './limits.js';
 import { clearDreamError, readSessionState, writeSessionState, writeDreamError } from './state.js';
-import { segmentDiff, truncateMessage, estimateMessagesTokens } from './segment.js';
+import {
+  segmentDiff,
+  compressDreamMessages,
+  selectDreamNewMessages,
+} from './segment.js';
 import { triageGroupSegments } from './triage.js';
 import { mergeByTarget } from './merge.js';
 import { applyMergedTarget } from './apply.js';
@@ -58,7 +61,7 @@ import { tsForBackup, pruneOldSnapshots } from './snapshot.js';
  * @typedef {Object} RunDreamOpts
  * @property {string} root                    — memory root, e.g. ~/.yeaft/memory
  * @property {boolean} [manual=false]         — manual trigger overrides newCount<20 skip
- * @property {string[]} [scopeFilter]         — optional: only dream these targets; scoped manual session triggers rerun the current session when there are prior messages but no new cursor delta ('*' allowed)
+ * @property {string[]} [scopeFilter]         — optional: only dream these targets ('*' allowed)
  * @property {(req: {pass:string, prompt:string, system:string}) => Promise<string>} llm
  * @property {() => Promise<Array<string>>} listSessions   — return all session ids (incl. '_no-session')
  * @property {(sessionId: string) => Promise<number>} countMessages   — total message count for a session
@@ -109,11 +112,9 @@ export async function runDream(opts) {
   };
 
   for (const sessionId of sessionIds) {
-    // Current-session manual dream passes are the one case where scopeFilter
-    // must constrain enumeration too: clicking the conversation header means
-    // "dream this session now", not "triage every session and then only apply
-    // sessions/<id>". Pure target filters such as ['user'] still triage every
-    // session so their hard-rule actions can contribute to the requested scope.
+    // A Session filter constrains enumeration; a pure target filter such as
+    // ['user'] still triages every Session so hard-rule actions can contribute
+    // to the requested scope.
     if (sessionFilter && !sessionFilter.has(sessionId)) {
       sessionsReport.push({ sessionId, new: 0, status: 'skipped', reason: 'scope-filtered' });
       continue;
@@ -122,13 +123,7 @@ export async function runDream(opts) {
     const beforeCount = await safeCall(() => opts.countMessages(sessionId), 0);
     const newCount = Math.max(0, beforeCount - (state.messageCount || 0));
 
-    const rerunScopedManual = !!opts.manual
-      && sessionFilter
-      && sessionFilter.has(sessionId)
-      && newCount === 0
-      && beforeCount > 0;
-
-    if (newCount === 0 && !rerunScopedManual) {
+    if (newCount === 0) {
       const topics = await resolveTopicSummaries(sessionId);
       if (opts.manual && topics.length >= 2) {
         try {
@@ -140,6 +135,7 @@ export async function runDream(opts) {
             language: opts.language,
             ts,
             segmentIndex: opts.segmentIndex || null,
+            maxPromptChars: limits.MAX_DREAM_PROMPT_CHARS,
           });
           sessionsReport.push({ sessionId, new: 0, status: 'consolidated', ...result });
         } catch (err) {
@@ -156,14 +152,14 @@ export async function runDream(opts) {
     }
 
     onProgress({ phase: 'load-diff', sessionId });
-    const diffCursor = rerunScopedManual ? null : state.lastDreamMessageId;
+    const diffCursor = state.lastDreamMessageId;
     const loadDiff = opts.loadSessionDiff || opts.loadGroupDiff;
     const diffNew = await safeCall(() => loadDiff(sessionId, diffCursor), []);
     if (!diffNew || diffNew.length === 0) {
       sessionsReport.push({ sessionId, new: newCount, status: 'skipped', reason: 'empty-diff' });
       continue;
     }
-    const overlapMessages = state.lastDreamMessageId && !rerunScopedManual
+    const overlapMessages = state.lastDreamMessageId
       ? await safeCall(
           () => opts.loadOverlapPreamble
             ? opts.loadOverlapPreamble(sessionId, state.lastDreamMessageId, limits.DREAM_OVERLAP)
@@ -171,11 +167,33 @@ export async function runDream(opts) {
           [],
         )
       : [];
-    const taggedOverlap = overlapMessages.map(m => ({ ...m, kind: 'overlap', body: truncateMessage(m.body || '') }));
-    const taggedNew = diffNew.map(m => ({ ...m, kind: 'new', body: truncateMessage(m.body || '') }));
+    const taggedOverlap = compressDreamMessages(overlapMessages)
+      .map(m => ({ ...m, kind: 'overlap' }));
+    const taggedNew = compressDreamMessages(diffNew)
+      .map(m => ({ ...m, kind: 'new' }));
     const fullDiff = [...taggedOverlap, ...taggedNew];
+    if (taggedNew.length === 0) {
+      // Tool-only traffic is intentionally not sent to Dream, but it still
+      // belongs to the processed transcript range. Advance the cursor so a
+      // failed/empty pass cannot replay the same execution history forever.
+      const tailId = lastMessageId(diffNew);
+      if (tailId) {
+        await writeSessionState(opts.root, sessionId, {
+          lastDreamMessageId: tailId,
+          lastDreamAt: nowIso,
+          messageCount: beforeCount,
+        });
+      }
+      sessionsReport.push({ sessionId, new: newCount, status: 'skipped', reason: 'no-durable-new-messages' });
+      continue;
+    }
 
-    const segments = segmentDiff(fullDiff, limits.MAX_DIFF_TOKENS_PER_TRIAGE, limits.DREAM_OVERLAP);
+    const segments = segmentDiff(
+      fullDiff,
+      limits.MAX_DIFF_TOKENS_PER_TRIAGE,
+      limits.DREAM_OVERLAP,
+      limits.MAX_DREAM_PROMPT_CHARS,
+    );
     onProgress({ phase: 'triage', sessionId, status: 'running', segments: segments.length });
 
     let actions;
@@ -186,6 +204,7 @@ export async function runDream(opts) {
         sessionId,
         segments,
         topicSummaries,
+        maxPromptChars: limits.MAX_DREAM_PROMPT_CHARS,
         llm: dreamLlmForSession(opts.llm, sessionId),
         onProgress,
         language: opts.language,
@@ -206,11 +225,15 @@ export async function runDream(opts) {
     }
 
     onProgress({ phase: 'triage', sessionId, status: 'done', actions: actions.length });
-    sessionTriages.push({ sessionId, diff: fullDiff, actions });
+    sessionTriages.push({
+      sessionId,
+      diff: selectDreamNewMessages(taggedNew),
+      actions,
+    });
 
     const tailId = lastMessageId(diffNew);
     processedSessions.push({ sessionId, tailId, beforeCount, newCount, segments: segments.length, actions: actions.length });
-    sessionsReport.push({ sessionId, new: newCount, segments: segments.length, actions: actions.length, status: 'triaged', rerun: rerunScopedManual || undefined });
+    sessionsReport.push({ sessionId, new: newCount, segments: segments.length, actions: actions.length, status: 'triaged' });
   }
 
   // 3. merge
@@ -277,6 +300,7 @@ export async function runDream(opts) {
         targets,
         llm: dreamLlmForSession(opts.llm, triage.sessionId),
         language: opts.language,
+        limits,
         nowIso: opts.nowIso || (() => nowIso),
         segmentIndex: opts.segmentIndex || null,
       });
@@ -310,6 +334,7 @@ export async function runDream(opts) {
         language: opts.language,
         ts,
         segmentIndex: opts.segmentIndex || null,
+        maxPromptChars: limits.MAX_DREAM_PROMPT_CHARS,
       });
       topicConsolidation.push({ sessionId, status: 'done', ...result });
       onProgress({ phase: 'topic-consolidation', sessionId, status: 'done', ...result });
@@ -324,17 +349,20 @@ export async function runDream(opts) {
     }
   }
 
-  // 7. bookkeep — only when at least one apply for this session's actions
-  // succeeded. We use a permissive policy: if ANY merged-target apply
-  // succeeded for a session's contributed actions, advance that session's
-  // cursor. (If everything errored, we keep the cursor so next run
-  // retries.)
-  const successfulTargets = new Set(targetsReport.filter(r => r.status === 'done').map(r => r.target));
+  // 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.
+  const targetStatus = new Map(targetsReport.map(report => [report.target, report.status]));
   for (const pg of processedSessions) {
-    const contributed = (sessionTriages.find(g => g.sessionId === pg.sessionId) || { actions: [] })
-      .actions.map(a => a.scope);
-    const anySuccess = contributed.some(t => successfulTargets.has(t));
-    if (!anySuccess) continue;
+    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')) {
+      continue;
+    }
     if (pg.tailId) {
       await writeSessionState(opts.root, pg.sessionId, {
         lastDreamMessageId: pg.tailId,

package/yeaft/dream/segment-extract.js

@@ -10,6 +10,7 @@ import { readScope, writeScope } from '../memory/segment-store.js';
 import { syncScope } from '../memory/segment-sync.js';
 import { makeSegment } from '../memory/segment.js';
 import { render, extractTemplateForScope } from './prompts/index.js';
+import { boundDreamPrompt } from './segment.js';
 import { parseJsonSafe } from './triage.js';
 
 const MAX_MESSAGES = 80;
@@ -40,6 +41,7 @@ const VALID_KINDS = new Set([
  *   language?: string,
  *   nowIso?: Function,
  *   segmentIndex?: import('../memory/index-db.js').SegmentIndex|null,
+ *   limits?: { MAX_DREAM_PROMPT_CHARS?: number },
  * }} opts
  */
 export async function extractAndWriteMemorySegments(opts) {
@@ -68,6 +70,7 @@ export async function extractAndWriteMemorySegments(opts) {
         language: opts.language,
         now,
         allowedSourceIds,
+        maxPromptChars: opts.limits?.MAX_DREAM_PROMPT_CHARS,
       });
     } catch (err) {
       errors.push({ scope, error: err.message, rawSnippet: err.rawSnippet || '' });
@@ -92,10 +95,13 @@ export async function extractAndWriteMemorySegments(opts) {
   return { scopes: scopeCount, segments: segmentCount, errors };
 }
 
-async function extractScopeSegments({ scope, sessionId, messages, llm, language, now, allowedSourceIds }) {
+async function extractScopeSegments({ scope, sessionId, messages, llm, language, now, allowedSourceIds, maxPromptChars }) {
   const template = extractTemplateForScope(scope);
   const base = render(template, templateVarsForScope(scope, sessionId), { language });
-  const prompt = `${base}\n\nTarget scope: ${scope}\n\nConversation diff, oldest first:\n${renderMessages(messages)}\n\nReturn only the JSON array. Do not wrap it in Markdown.`;
+  const prompt = boundDreamPrompt(
+    `${base}\n\nTarget scope: ${scope}\n\nConversation diff, oldest first:\n${renderMessages(messages)}\n\nReturn only the JSON array. Do not wrap it in Markdown.`,
+    maxPromptChars,
+  );
   const firstRaw = await llm({ pass: 'extract-segments', prompt, system: extractSystem(language) });
   const firstParsed = parseJsonSafe(firstRaw);
   if (Array.isArray(firstParsed)) {
@@ -104,7 +110,7 @@ async function extractScopeSegments({ scope, sessionId, messages, llm, language,
       .filter(Boolean);
   }
 
-  const retryPrompt = `${prompt}\n\nYour previous output was malformed JSON. Previous output snippet:\n${rawSnippet(firstRaw)}\n\nRetry now. Return only a strict JSON array.`;
+  const retryPrompt = boundDreamPrompt(`${prompt}\n\nYour previous output was malformed JSON. Previous output snippet:\n${rawSnippet(firstRaw)}\n\nRetry now. Return only a strict JSON array.`, maxPromptChars);
   const retryRaw = await llm({ pass: 'extract-segments-retry', prompt: retryPrompt, system: extractSystem(language) });
   const retryParsed = parseJsonSafe(retryRaw);
   if (!Array.isArray(retryParsed)) {

package/yeaft/dream/segment.js

@@ -1,7 +1,7 @@
 /**
  * dream/segment.js.
  *
- * Three independent length-control concerns, kept pure so they can be
+ * Four independent length-control concerns, kept pure so they can be
  * unit-tested without touching disk or any LLM:
  *
  *   1. truncateMessage — clamp a single message body to
@@ -21,15 +21,21 @@
  *
  *   4. needsBatchedApply / batchSourcesForApply — when an Apply target's
  *      memory + summary + sources cumulatively exceed MAX_APPLY_TOKENS,
- *      split the sources (one source = one group's contribution) into
- *      batches; the LLM is then called once per batch, threading the
- *      written-back memory.md as input to the next batch. (§17.2)
+ *      split source messages into bounded batches; the LLM is then called
+ *      once per batch, threading the written-back memory.md as input to the
+ *      next batch. A single Session source may therefore produce multiple
+ *      ordered batches.
+ *
+ * Dream only needs durable user/assistant prose. Tool results are execution
+ * history and can be enormous; `compressDreamMessages()` drops them before
+ * triage/apply while preserving the original conversation on disk.
  *
  * No side-effects. All functions are deterministic given their inputs.
  */
 
 import {
   MAX_SINGLE_MESSAGE_CHARS,
+  MAX_DREAM_PROMPT_CHARS,
   MAX_DIFF_TOKENS_PER_TRIAGE,
   MAX_APPLY_TOKENS,
   DREAM_OVERLAP,
@@ -80,6 +86,67 @@ export function estimateMessagesTokens(msgs) {
   return n;
 }
 
+/**
+ * Remove execution-only messages from the Dream input. The transcript remains
+ * the source of truth; this is only a prompt projection. Overlap messages are
+ * retained for triage context but never become new durable evidence.
+ *
+ * @param {Array<object>} messages
+ * @returns {Array<object>}
+ */
+export function compressDreamMessages(messages) {
+  if (!Array.isArray(messages)) return [];
+  return messages
+    .filter(message => message && typeof message === 'object')
+    .filter(message => ['user', 'assistant'].includes(String(message.role || '').toLowerCase()))
+    .map(message => ({
+      ...message,
+      body: truncateMessage(message.body || message.content || ''),
+    }))
+    .filter(message => String(message.body || '').trim());
+}
+
+/**
+ * Keep only newly observed messages when applying/extracting. Triage may use
+ * overlap context, but re-feeding it to Apply causes old Dreamed content to be
+ * processed again on every pass.
+ *
+ * @param {Array<object>} messages
+ * @returns {Array<object>}
+ */
+export function selectDreamNewMessages(messages) {
+  return (Array.isArray(messages) ? messages : [])
+    .filter(message => message && message.kind !== 'overlap');
+}
+
+/**
+ * Hard cap the final Dream prompt at the provider boundary. Keep both the
+ * prompt contract (head) and the JSON/output instruction (tail); discard only
+ * the middle source transcript. The durable transcript and canonical memory
+ * remain on disk.
+ *
+ * @param {string} prompt
+ * @param {number} [maxChars=MAX_DREAM_PROMPT_CHARS]
+ * @returns {string}
+ */
+export function boundDreamPrompt(prompt, maxChars = MAX_DREAM_PROMPT_CHARS) {
+  const text = String(prompt || '');
+  const cap = Number.isFinite(maxChars) && maxChars > 0
+    ? Math.floor(maxChars)
+    : MAX_DREAM_PROMPT_CHARS;
+  if (text.length <= cap) return text;
+  const marker = '\n\n[Dream prompt compressed: middle transcript omitted; durable source remains on disk]\n\n';
+  if (cap <= marker.length) {
+    const head = Math.ceil(cap / 2);
+    const tail = cap - head;
+    return text.slice(0, head) + (tail > 0 ? text.slice(-tail) : '');
+  }
+  const room = cap - marker.length;
+  const head = Math.ceil(room * 0.62);
+  const tail = room - head;
+  return text.slice(0, head) + marker + (tail > 0 ? text.slice(-tail) : '');
+}
+
 /**
  * Split a contiguous group diff into ≤MAX-token segments, with a
  * DREAM_OVERLAP-message tail/head overlap between consecutive segments.
@@ -99,14 +166,19 @@ export function estimateMessagesTokens(msgs) {
  * @param {Array<{id?: string, role?: string, body?: string}>} diff
  * @param {number} [maxTokens=MAX_DIFF_TOKENS_PER_TRIAGE]
  * @param {number} [overlap=DREAM_OVERLAP]
+ * @param {number} [maxPromptChars=MAX_DREAM_PROMPT_CHARS]
  * @returns {Array<{ messages: Array<object>, overlapCount: number, newCount: number }>}
  */
-export function segmentDiff(diff, maxTokens = MAX_DIFF_TOKENS_PER_TRIAGE, overlap = DREAM_OVERLAP) {
+export function segmentDiff(diff, maxTokens = MAX_DIFF_TOKENS_PER_TRIAGE, overlap = DREAM_OVERLAP, maxPromptChars = MAX_DREAM_PROMPT_CHARS) {
   const msgs = Array.isArray(diff) ? diff : [];
+  const boundedPromptChars = Number.isFinite(maxPromptChars) && maxPromptChars > 0
+    ? maxPromptChars
+    : MAX_DREAM_PROMPT_CHARS;
+  const boundedMaxTokens = Math.min(maxTokens, Math.max(1, Math.floor(boundedPromptChars / 4) - 2048));
   if (msgs.length === 0) return [];
 
   // Fast path: whole diff fits in one segment.
-  if (estimateMessagesTokens(msgs) <= maxTokens) {
+  if (estimateMessagesTokens(msgs) <= boundedMaxTokens) {
     return [{ messages: msgs, overlapCount: 0, newCount: msgs.length }];
   }
 
@@ -120,7 +192,7 @@ export function segmentDiff(diff, maxTokens = MAX_DIFF_TOKENS_PER_TRIAGE, overla
     let end = cursor;
     while (end < msgs.length) {
       const cost = estimateTokens(msgs[end].body || '') + estimateTokens(msgs[end].role || '') + 2;
-      if (used + cost > maxTokens && end > cursor) break;
+      if (used + cost > boundedMaxTokens && end > cursor) break;
       used += cost;
       end += 1;
     }
@@ -161,9 +233,9 @@ function totalApplyTokens(merged) {
  * previous-batch output replaces memoryMd, so we account for the same
  * baseline cost in each batch.
  *
- * If a single source (one group's diff) alone would overflow, it still
- * goes into its own batch — we never split a source diff here (segment
- * happens earlier, in triage).
+ * Sources are split into ordered message chunks when one Session's diff is
+ * larger than the apply budget. This is required because a single Session
+ * can contribute thousands of messages after a long gap between Dream runs.
  *
  * @param {{ memoryMd?: string, summaryMd?: string, sources: Array<{ sessionId: string, diff: any }> }} merged
  * @param {number} [maxTokens=MAX_APPLY_TOKENS]
@@ -173,10 +245,11 @@ export function batchSourcesForApply(merged, maxTokens = MAX_APPLY_TOKENS) {
   const sources = Array.isArray(merged.sources) ? merged.sources : [];
   if (sources.length === 0) return [];
   const baseline = estimateTokens(merged.memoryMd || '') + estimateTokens(merged.summaryMd || '');
+  const sourceChunks = sources.flatMap(source => splitApplySource(source, Math.max(1, maxTokens - baseline)));
   const batches = [];
   let cur = [];
   let used = baseline;
-  for (const src of sources) {
+  for (const src of sourceChunks) {
     const cost = estimateMessagesTokens(src.diff || []);
     if (cur.length > 0 && used + cost > maxTokens) {
       batches.push(cur);
@@ -189,3 +262,23 @@ export function batchSourcesForApply(merged, maxTokens = MAX_APPLY_TOKENS) {
   if (cur.length > 0) batches.push(cur);
   return batches;
 }
+
+function splitApplySource(source, budget) {
+  const messages = Array.isArray(source?.diff) ? source.diff : [];
+  if (messages.length === 0) return [{ ...source, diff: [] }];
+  const chunks = [];
+  let current = [];
+  let used = 0;
+  for (const message of messages) {
+    const cost = estimateMessagesTokens([message]);
+    if (current.length > 0 && used + cost > budget) {
+      chunks.push({ ...source, diff: current });
+      current = [];
+      used = 0;
+    }
+    current.push(message);
+    used += cost;
+  }
+  if (current.length > 0) chunks.push({ ...source, diff: current });
+  return chunks;
+}

package/yeaft/dream/session-wiring.js

@@ -46,7 +46,8 @@ 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';
+import { boundDreamPrompt } from './segment.js';
+import { DREAM_NUDGE_AFTER_MESSAGES, DREAM_INTERVAL_HOURS, loadLimitsFromConfig } from './limits.js';
 
 /**
  * Build the per-call options for runDream. Pure: takes a session and returns
@@ -83,6 +84,7 @@ export function buildRunDreamOpts(session, onProgress) {
     root: memoryRoot,
     language: session.config?.language || 'en',
     segmentIndex: session.memoryIndex || null,
+    limits: loadLimitsFromConfig(session.config),
     llm: makeLlm(session),
     listSessions: async () => {
       try { return listRegisteredSessions([sessionConversationsRoot, legacySessionConversationsRoot]); }
@@ -355,7 +357,11 @@ function makeLlm(session) {
   return async ({ pass, prompt, system, sessionId }) => {
     const adapter = session.adapter;
     const effectiveConfig = resolveDreamSessionConfig(session, sessionId);
-    const model = effectiveConfig?.model || effectiveConfig?.primaryModel;
+    // Session model overrides may be stored provider-qualified while the
+    // resolved config also exposes a provider-local `model` id. Dream must
+    // route through the exact Session selection first; otherwise a short id
+    // can resolve to another provider or fail as unsupported.
+    const model = effectiveConfig?.primaryModel || effectiveConfig?.model;
     if (!model) {
       throw new Error(`dream: no session model configured (pass=${pass}, sessionId=${sessionId || 'unknown'})`);
     }
@@ -371,11 +377,13 @@ function makeLlm(session) {
     const effectiveSystem = system || (String(effectiveConfig?.language || '').toLowerCase().startsWith('zh')
       ? `你是梦境流水线 — pass: ${pass}。请用中文生成自然语言内容；JSON key 保持英文。`
       : `You are the dream pipeline — pass: ${pass}.`);
+    const dreamLimits = loadLimitsFromConfig(effectiveConfig);
+    const boundedPrompt = boundDreamPrompt(prompt, dreamLimits.MAX_DREAM_PROMPT_CHARS);
 
     const r = await adapter.call({
       model,
       system: effectiveSystem,
-      messages: [{ role: 'user', content: prompt }],
+      messages: [{ role: 'user', content: boundedPrompt }],
       maxTokens: 2048,
       modelEffort: effectiveConfig?.modelEffort || undefined,
     });
@@ -402,7 +410,8 @@ function makeLlm(session) {
       model: model || 'unknown',
       sessionId: sessionId || null,
       systemPrompt: effectiveSystem,
-      messages: [{ role: 'user', content: prompt }],
+      messages: [{ role: 'user', content: boundedPrompt }],
+      promptChars: boundedPrompt.length,
       response: typeof r?.text === 'string' ? r.text : '',
       toolCalls: [],
       usage,

package/yeaft/dream/topic-consolidation.js

@@ -18,6 +18,7 @@ import {
   TOPIC_REDIRECT_FILE,
 } from '../memory/topic-redirect.js';
 import { render } from './prompts/index.js';
+import { boundDreamPrompt } from './segment.js';
 import { parseJsonSafe } from './triage.js';
 import { snapshotScope } from './snapshot.js';
 
@@ -54,9 +55,9 @@ export async function consolidateSessionTopics(opts) {
     const parsed = parseJsonSafe(await opts.llm({
       pass: 'topic-consolidation',
       system: topicConsolidationSystem(opts.language),
-      prompt: render('consolidateTopics', {
+      prompt: boundDreamPrompt(render('consolidateTopics', {
         topics: batch.map(topic => `- ${topic.path}: ${topic.summary}`).join('\n'),
-      }, { language: opts.language }),
+      }, { language: opts.language }), opts.maxPromptChars),
     }));
     if (!Array.isArray(parsed?.groups)) continue;
     groups.push(...validateGroups(parsed.groups, topics));
@@ -128,13 +129,13 @@ async function applyConsolidationGroup(group, opts) {
   const raw = await opts.llm({
     pass: 'topic-merge',
     system: topicConsolidationSystem(opts.language),
-    prompt: render('mergeTopics', {
+    prompt: boundDreamPrompt(render('mergeTopics', {
       canonical: canonical.path,
       topicContents: available.map(record => [
         `## ${record.path}`,
         record.content || record.memory || record.summary,
       ].join('\n')).join('\n\n'),
-    }, { language: opts.language }),
+    }, { language: opts.language }), opts.maxPromptChars),
   });
   const parsed = parseJsonSafe(raw);
   const mergedContent = String(parsed?.content_md || '').trim();

package/yeaft/dream/triage.js

@@ -36,7 +36,7 @@ import { isValidTopic } from '../memory/store.js';
  * below.)
  */
 
-import { truncateMessage } from './segment.js';
+import { boundDreamPrompt, truncateMessage } from './segment.js';
 import { render } from './prompts/index.js';
 import { resolveTopicRedirect } from '../memory/topic-redirect.js';
 
@@ -106,7 +106,7 @@ export function applyHardRules({ sessionId, chatId, messages }) {
 /**
  * Build the prompt used for Pass-1.
  *
- * @param {{ sessionId: string, messages: Array<object>, topicSummaries: Array<{ path: string, summary: string }> }} ctx
+ * @param {{ sessionId: string, messages: Array<object>, topicSummaries: Array<{ path: string, summary: string }>, maxPromptChars?: number }} ctx
  */
 export function buildPass1Prompt(ctx) {
   const topicSummaries = (!ctx.topicSummaries || ctx.topicSummaries.length === 0)
@@ -119,11 +119,11 @@ export function buildPass1Prompt(ctx) {
     conv.push(truncateMessage(m.body || ''));
     conv.push('');
   }
-  return render('triagePass1', {
+  return boundDreamPrompt(render('triagePass1', {
     sessionId: ctx.sessionId,
     topicSummaries,
     conversation: conv.join('\n').trimEnd(),
-  }, { language: ctx.language });
+  }, { language: ctx.language }), ctx.maxPromptChars);
 }
 
 /**
@@ -135,10 +135,10 @@ export function buildPass2Prompt(ctx) {
   const existingTopics = (!ctx.existingTopics || ctx.existingTopics.length === 0)
     ? (String(ctx.language || '').toLowerCase().startsWith('zh') ? '  （无）' : '  (none)')
     : ctx.existingTopics.map(t => `  - ${t.path} — ${oneLine(t.summary)}`).join('\n');
-  return render('triagePass2', {
+  return boundDreamPrompt(render('triagePass2', {
     description: ctx.description,
     existingTopics,
-  }, { language: ctx.language });
+  }, { language: ctx.language }), ctx.maxPromptChars);
 }
 
 /**
@@ -150,12 +150,13 @@ export function buildPass2Prompt(ctx) {
  *   messages: Array<object>,
  *   topicSummaries: Array<{ path: string, summary: string }>,
  *   llm: (req: { pass: string, prompt: string, system: string }) => Promise<string>,
+ *   maxPromptChars?: number,
  * }} args
  * @returns {Promise<Array<{ kind: 'update'|'create', scope: string }>>}
  */
-export async function classifySoft({ root, sessionId, messages, topicSummaries, llm, language }) {
+export async function classifySoft({ root, sessionId, messages, topicSummaries, llm, language, maxPromptChars }) {
   if (!llm) throw new Error('triage.classifySoft: llm callable required');
-  const pass1Prompt = buildPass1Prompt({ sessionId, messages, topicSummaries, language });
+  const pass1Prompt = buildPass1Prompt({ sessionId, messages, topicSummaries, language, maxPromptChars });
   const pass1Raw = await llm({ pass: 'triage-pass1', prompt: pass1Prompt, system: triageSystem(language) });
   const pass1 = parseJsonSafe(pass1Raw);
   const out = [];
@@ -174,6 +175,7 @@ export async function classifySoft({ root, sessionId, messages, topicSummaries,
       description: description.trim(),
       existingTopics: topicSummaries || [],
       language,
+      maxPromptChars,
     });
     const pass2Raw = await llm({ pass: 'triage-pass2', prompt: pass2Prompt, system: triageSystem(language) });
     const pass2 = parseJsonSafe(pass2Raw);
@@ -224,11 +226,12 @@ export async function triageOneSegment(args) {
  *   segments: Array<{ messages: Array<object> }>,
  *   topicSummaries: Array<{ path: string, summary: string }>,
  *   llm: (req: { pass: string, prompt: string, system: string }) => Promise<string>,
+ *   maxPromptChars?: number,
  *   onProgress?: (event: object) => void,
  * }} args
  * @returns {Promise<Array<{ kind: 'update'|'create', scope: string }>>}
  */
-export async function triageGroupSegments({ root, sessionId, segments, topicSummaries, llm, onProgress, language }) {
+export async function triageGroupSegments({ root, sessionId, segments, topicSummaries, llm, onProgress, language, maxPromptChars }) {
   let acc = [];
   let i = 0;
   for (const seg of (segments || [])) {
@@ -241,6 +244,7 @@ export async function triageGroupSegments({ root, sessionId, segments, topicSumm
       topicSummaries,
       llm,
       language,
+      maxPromptChars,
     });
     acc = dedupeActions([...acc, ...segActions]);
   }

package/yeaft/engine.js

@@ -691,7 +691,7 @@ export class Engine {
   /** @type {import('./stats/tool-usage.js').ToolUsageStats|null} — per-tool call/latency counters */
   #toolStats = null;
 
-  /** @type {object|null} — Config override for internal tasks (recall, consolidation, dream) using fastModel */
+  /** @type {object|null} — Config override for internal compact/recall tasks using fastModel; Dream uses the Session primary model */
   #fastConfig;
 
   /** @type {((agentId: string, evt: object) => void) | null} */
@@ -5437,7 +5437,7 @@ export class Engine {
   /** @returns {string|null} */
   get yeaftDir() { return this.#yeaftDir; }
 
-  /** @returns {object} — Config with fastModel as model (for internal tasks) */
+  /** @returns {object} — Config with fastModel as model (for compact and other non-Dream internal tasks) */
   get fastConfig() { return this.#fastConfig; }
 
   /**