npm - @yeaft/webchat-agent - Versions diffs - 1.0.440 → 1.0.442 - Mend

@yeaft/webchat-agent 1.0.440 → 1.0.442

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (16) hide show

package/local-runtime/version.json +1 -1
package/local-runtime/web/app.bundle.js +38 -36
package/local-runtime/web/app.bundle.js.gz +0 -0
package/local-runtime/web/index.html +1 -1
package/package.json +1 -1
package/yeaft/config-api.js +7 -3
package/yeaft/config.js +10 -1
package/yeaft/dream/apply.js +90 -37
package/yeaft/dream/limits.js +5 -0
package/yeaft/dream/runner.js +61 -33
package/yeaft/dream/segment-extract.js +9 -3
package/yeaft/dream/segment.js +104 -11
package/yeaft/dream/session-wiring.js +13 -4
package/yeaft/dream/topic-consolidation.js +5 -4
package/yeaft/dream/triage.js +13 -9
package/yeaft/engine.js +2 -2

package/local-runtime/web/app.bundle.js.gz CHANGED Viewed

Binary file

package/local-runtime/web/index.html CHANGED Viewed

@@ -16,6 +16,6 @@
 </head>
 <body>
   <div id="app"></div>
-  <script type="module" src="app.bundle.js?v=1968a0f6"></script>
+  <script type="module" src="app.bundle.js?v=120e77b4"></script>
 </body>
 </html>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.440",
+  "version": "1.0.442",
   "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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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)) {