@yeaft/webchat-agent 0.1.848 → 0.1.850

package/package.json

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

package/unify/dream-v2/apply.js

@@ -228,7 +228,23 @@ export async function applyMergedTarget(merged, opts) {
   await writeMemory(scope, stamped, { root: opts.root });
   await writeSummary(scope, summaryMd || '', { root: opts.root, language: opts.language });
 
-  if (opts.onProgress) opts.onProgress({ phase: 'apply', target: merged.target, status: 'done', batches: batchesUsed });
+  if (opts.onProgress) {
+    // feat-dream-debug-detail: surface a truncated copy of what was
+    // actually written so the debug panel can show "what segments were
+    // generated" instead of just "done". The full bytes are on disk
+    // anyway — this preview is for at-a-glance debugging.
+    opts.onProgress({
+      phase: 'apply',
+      target: merged.target,
+      status: 'done',
+      batches: batchesUsed,
+      kind: merged.kind,
+      memoryMdPreview: truncateForDebug(stamped),
+      summaryMdPreview: truncateForDebug(summaryMd || ''),
+      memoryMdLength: (stamped || '').length,
+      summaryMdLength: (summaryMd || '').length,
+    });
+  }
   return { target: merged.target, kind: merged.kind, batches: batchesUsed };
 }
 
@@ -246,3 +262,23 @@ function scopeRelDir(scope) {
 }
 
 function oneLine(s) { return String(s || '').replace(/\s+/g, ' ').trim().slice(0, 200); }
+
+/**
+ * Per-field truncation cap for debug previews emitted on `apply/done`.
+ * Keep this small — the dream panel only needs a recognisable snippet.
+ * Total worst-case payload is `PREVIEW_MAX * 2 * targets_per_run` per
+ * dream pass; with N=50 targets that's ~200 KB. The full bytes are on
+ * disk under <root>/<scope>/{memory,summary}.md anyway — these previews
+ * are for at-a-glance debugging only.
+ */
+const PREVIEW_MAX = 2048;
+
+/**
+ * Truncate a markdown blob for inclusion in a debug-panel cell. Adds a
+ * "…(+N chars)" marker so the user knows it was cut.
+ */
+function truncateForDebug(s, max = PREVIEW_MAX) {
+  const str = String(s || '');
+  if (str.length <= max) return str;
+  return str.slice(0, max) + `…(+${str.length - max} chars)`;
+}

package/unify/dream-v2/session-wiring.js

@@ -7,6 +7,35 @@
  *
  * Memory v2 is the only path. The legacy `config.memoryV2` opt-out flag was
  * retired (task-710) — the wiring is unconditional.
+ *
+ * ─────────────────────────────────────────────────────────────────────
+ * Wire contract — DreamEvent (consumed by web/components/UnifyDebugPanel.js)
+ * ─────────────────────────────────────────────────────────────────────
+ * The events persisted to trace_events with these event_type values are
+ * load-bearing for the debug panel. Renaming a field on this side
+ * silently degrades that UI to a generic JSON dump.
+ *
+ *   dream_turn_open:   { type:'turn_open',  turnId, userPrompt, vpId, groupId, at }
+ *   dream_loop:        { type:'loop',       turnId, loopNumber, pass, model,
+ *                        systemPrompt: string,
+ *                        messages: [{ role:'user', content:string }],
+ *                        response: string,
+ *                        toolCalls: [], usage: { inputTokens, outputTokens, totalTokens },
+ *                        latencyMs, ttfbMs, stopReason, rawRequest, rawResponse }
+ *   dream_turn_close:  { type:'turn_close', turnId, totalMs, totalTokens, loopCount,
+ *                        metrics: { llmCallCount, inputTokens, outputTokens,
+ *                                   totalTokens, durationMs, passBreakdown:{[pass]:{
+ *                                     llmCallCount, inputTokens, outputTokens,
+ *                                     totalTokens, durationMs }} } }
+ *   dream_run:         { type:'dream_run',  turnId, phase:'result',
+ *                        status:'done'|'error', metrics, resultSummary:{ groups,
+ *                        targets, error, skipped, skippedReason } }
+ *   dream_progress:    runner-emitted phase events (`start`/`load-diff`/`triage`/
+ *                      `merge`/`apply`/`done`). The `apply/done` variant carries
+ *                      `kind, memoryMdPreview, summaryMdPreview, memoryMdLength,
+ *                      summaryMdLength` (see apply.js).
+ *
+ * `groupId` may be inherited via `stampDreamScope()` when a scope is active.
  */
 
 import { join } from 'path';

package/unify/history-compact.js

@@ -94,13 +94,14 @@ export const countTurns = countTurnsImpl;
  * Token thresholds are derived from `maxContextTokens` at evaluation
  * time so the policy auto-adjusts to the user's configured context.
  */
-export const DEFAULT_TURN_LIMIT = 30;
-export const DEFAULT_MIN_TOKEN_FLOOR = 12_000;
+export const DEFAULT_TURN_LIMIT = Infinity;
+export const DEFAULT_MIN_TOKEN_FLOOR = 0;
 export const DEFAULT_MAX_CONTEXT_TOKENS = 200_000;
-export const DEFAULT_TOKEN_FRACTION = 0.8;
-export const DEFAULT_HARD_TOKEN_CEILING = 200_000;
-export const DEFAULT_MIN_TURNS_FOR_COMPACT = 5;
+export const DEFAULT_TOKEN_FRACTION = 0.5;
+export const DEFAULT_HARD_TOKEN_CEILING = Infinity;
+export const DEFAULT_MIN_TURNS_FOR_COMPACT = 0;
 export const DEFAULT_KEEP_TOOL_TURNS = 3;
+export const DEFAULT_TOOL_CALL_COMPACT_THRESHOLD = 30;
 /**
  * Effective default token trigger when no `maxContextTokens` is provided:
  *   min(80% of 200K, 200K) = 160K. Preserved as `DEFAULT_TOKEN_LIMIT` for
@@ -116,7 +117,7 @@ export const DEFAULT_TOKEN_LIMIT = Math.min(
  * replaces everything before this window. 2 keeps "what we were just
  * talking about" lossless.
  */
-export const DEFAULT_KEEP_RECENT_TURNS = 2;
+export const DEFAULT_KEEP_RECENT_TURNS = 3;
 
 /**
  * Default cap on the number of turns kept in the per-call snapshot fed
@@ -233,9 +234,10 @@ export function shouldCompactHistory(messages, opts = {}) {
   const tokenCount = estimateMessagesTokens(messages);
 
   let reason = null;
-  // (1) Soft floor: never compact small conversations.
-  // (2) Short-history guard: fewer than five turns should not compact unless
-  //     the estimated prompt is already at the context-pressure threshold.
+  // Product rule: async group compact is allowed only when the current
+  // conversation exceeds the model context window threshold. Turn count is
+  // preserved as an explicit test/future-config override, but defaults to
+  // Infinity so it cannot compact a small context by itself.
   if (tokenCount < minTokenFloor || (turnCount < minTurnsForCompact && tokenCount < tokenLimit)) {
     return {
       trigger: false,
@@ -249,10 +251,8 @@ export function shouldCompactHistory(messages, opts = {}) {
       hardTokenCeiling,
     };
   }
-  // (2) Trigger evaluation. Turn check is opt-in (Infinity by default).
-  if (Number.isFinite(turnLimit) && turnCount > turnLimit) reason = 'turn_count';
-  else if (tokenCount > hardTokenCeiling) reason = 'token_ceiling';
-  else if (tokenCount >= tokenLimit) reason = 'token_threshold';
+  if (tokenCount > hardTokenCeiling) reason = 'token_ceiling';
+  else if (tokenCount > tokenLimit) reason = 'token_threshold';
 
   return {
     trigger: reason !== null,
@@ -273,6 +273,27 @@ function hasContentAfterToolStrip(content) {
   return content != null;
 }
 
+function countToolCallsInContent(content) {
+  if (!Array.isArray(content)) return 0;
+  let n = 0;
+  for (const part of content) {
+    if (!part || typeof part !== 'object') continue;
+    if (part.type === 'tool_use' || part.type === 'function_call') n++;
+  }
+  return n;
+}
+
+function countToolCallsInMessages(messages) {
+  if (!Array.isArray(messages)) return 0;
+  let n = 0;
+  for (const m of messages) {
+    if (!m || typeof m !== 'object') continue;
+    if (Array.isArray(m.toolCalls)) n += m.toolCalls.length;
+    n += countToolCallsInContent(m.content);
+  }
+  return n;
+}
+
 function stripToolContentParts(content) {
   if (!Array.isArray(content)) return content;
   return content.filter(part => {
@@ -326,6 +347,31 @@ export function stripToolNoiseFromOlderTurns(messages, opts = {}) {
   return [...cleanedOlder, ...recent.map(m => ({ ...m }))];
 }
 
+/**
+ * Apply the async compact retained-tail tool policy. Small retained tails keep
+ * every tool pair intact. Once the retained tail exceeds the threshold, keep
+ * full tool history only for the latest turn and strip tool noise from the
+ * earlier retained turns while preserving their normal text.
+ *
+ * @param {Array<object>} tail
+ * @param {{ keepToolTurns?: number, toolCallCompactThreshold?: number }} [opts]
+ * @returns {Array<object>}
+ */
+export function compactRetainedTailToolCalls(tail, opts = {}) {
+  if (!Array.isArray(tail) || tail.length === 0) return [];
+
+  const threshold = Number.isFinite(opts.toolCallCompactThreshold) && opts.toolCallCompactThreshold >= 0
+    ? opts.toolCallCompactThreshold
+    : DEFAULT_TOOL_CALL_COMPACT_THRESHOLD;
+  const toolCallCount = countToolCallsInMessages(tail);
+  if (toolCallCount <= threshold) return tail.map(m => ({ ...m }));
+
+  const keepToolTurns = Number.isFinite(opts.keepToolTurns) && opts.keepToolTurns >= 0
+    ? opts.keepToolTurns
+    : 1;
+  return stripToolNoiseFromOlderTurns(tail, { keepToolTurns });
+}
+
 /**
  * Strip noise from a message list before sending it to the summarizer:
  *   - drop `role: 'tool'` (raw tool results — too verbose, mostly redundant)
@@ -499,6 +545,8 @@ export async function compactHistory(messages, options) {
     tokenFraction,
     hardTokenCeiling,
     language,
+    keepToolTurns,
+    toolCallCompactThreshold,
   } = options || {};
 
   if (typeof summarize !== 'function') {
@@ -600,7 +648,11 @@ export async function compactHistory(messages, options) {
   // whose tool_use IDs aren't fully matched in the tail. This is what
   // keeps the next adapter call from 400-ing on tool_use/tool_result
   // mismatch when the storage / fan-out layer reorders messages.
-  const safeTail = pairSanitize(tail);
+  const compactedTail = compactRetainedTailToolCalls(tail, {
+    keepToolTurns,
+    toolCallCompactThreshold,
+  });
+  const safeTail = pairSanitize(compactedTail);
 
   const newMessages = [summaryMsg, ...safeTail];
   const after = shouldCompactHistory(newMessages, triggerOpts);