npm - @yeaft/webchat-agent - Versions diffs - 1.0.507 → 1.0.508 - Mend

@yeaft/webchat-agent 1.0.507 → 1.0.508

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 (12) hide show

package/local-runtime/server/handlers/client-workbench.js +7 -1
package/local-runtime/server/workbench-route.js +11 -4
package/local-runtime/version.json +1 -1
package/local-runtime/web/app.bundle.js +80 -80
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/engine.js +9 -4
package/yeaft/history-window.js +76 -25
package/yeaft/prompts.js +3 -0
package/yeaft/session.js +16 -45
package/yeaft/sub-agent/runner.js +6 -4

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

Binary file

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

@@ -17,6 +17,6 @@
 </head>
 <body>
   <div id="app"></div>
-  <script type="module" src="app.bundle.js?v=c13a2178"></script>
+  <script type="module" src="app.bundle.js?v=c0c1e6d3"></script>
 </body>
 </html>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.507",
+  "version": "1.0.508",
   "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/engine.js CHANGED Viewed

@@ -2103,11 +2103,16 @@ export class Engine {
         ...(internalTrigger ? { internal: true } : { userAuthored: true }),
       }, { sessionId: runtimeSessionId });
     }
-    // Native Session history, including internal wakeups, never comes from
-    // Dream. Work Center and scoped child agents keep their memory contracts.
+    // Native Session history, including internal wakeups, comes from the
+    // canonical message transcript. Dream memory loading is temporarily
+    // disabled for every scenario (including Work Center and child agents)
+    // while message-history recall is evaluated as its replacement. Keep the
+    // downstream memory pipeline intact behind this single switch so it can be
+    // restored without migrating or deleting persisted memory data.
     const useMessageHistory = scenario !== 'work-item' && !!runtimeSessionId && !vpPersona?.subAgent;
-    const useDreamMemory = scenario === 'work-item' || !!vpPersona?.subAgent
-      || (!runtimeSessionId && !internalTrigger);
+    // const useDreamMemory = scenario === 'work-item' || !!vpPersona?.subAgent
+    //   || (!runtimeSessionId && !internalTrigger);
+    const useDreamMemory = false;
     const recentTurnCap = this.#config.yeaft?.recentTurnsLimit ?? 20;
     const relatedTurnCap = this.#config.yeaft?.relatedTurnsLimit ?? 8;
     let relatedHistoryTurns = [];

package/yeaft/history-window.js CHANGED Viewed

@@ -27,6 +27,7 @@ export const DEFAULT_RUNTIME_CACHE_TURN_CAP = 25;
 export const DEFAULT_RUNTIME_CACHE_TOKEN_BUDGET = 32768;
 export const DEFAULT_RUNTIME_CACHE_MESSAGE_CAP = 256;
+const MINIMUM_RECENT_PROVIDER_TURNS = 20;
 const IMAGE_PART_TOKEN_COST = 1024;
 const DOCUMENT_PART_TOKEN_COST = 2048;
 const CONTENT_PART_FRAME_TOKENS = 2;
@@ -565,10 +566,11 @@ function truncateToolResultsForModel(messages, options = {}) {
 const HISTORY_SOURCE_INDEX = Symbol('historySourceIndex');
-function withHistorySourceIndexes(messages) {
+function withHistorySourceIndexes(messages, offset = 0) {
   return messages.map((message, index) => (
     message && typeof message === 'object'
-      ? { ...message, [HISTORY_SOURCE_INDEX]: index }
+      ? { ...message, [HISTORY_SOURCE_INDEX]: Number.isInteger(message[HISTORY_SOURCE_INDEX])
+        ? message[HISTORY_SOURCE_INDEX] : offset + index }
       : message
   ));
 }
@@ -795,12 +797,13 @@ function bucketTextMessages(messages) {
 }
 function bucketTurn(messages, index, supplied = {}) {
-  const user = messages.find(bucketUserBoundary);
-  const sourceIds = [...new Set(messages.flatMap(bucketSourceIds))];
-  const keys = [...new Set(messages.filter(bucketUserBoundary).flatMap(bucketUserKeys))];
+  const indexedMessages = withHistorySourceIndexes(messages, index ?? 0);
+  const user = indexedMessages.find(bucketUserBoundary);
+  const sourceIds = [...new Set(indexedMessages.flatMap(bucketSourceIds))];
+  const keys = [...new Set(indexedMessages.filter(bucketUserBoundary).flatMap(bucketUserKeys))];
   if (supplied.id) keys.push(`turn:${supplied.id}`);
   if (keys.length === 0 && index != null) keys.push(`snapshot:${index}`);
-  const text = bucketTextMessages(messages);
+  const text = bucketTextMessages(indexedMessages);
   return {
     ...supplied,
     id: supplied.id || keys[0] || `snapshot:${index}`,
@@ -808,7 +811,7 @@ function bucketTurn(messages, index, supplied = {}) {
     sourceIds,
     userSeq: Number.isFinite(supplied.userSeq) ? supplied.userSeq : bucketSequence(user),
     index,
-    messages,
+    messages: indexedMessages,
     text,
     tokens: estimateMessagesTokens(text),
   };
@@ -893,19 +896,20 @@ function describeBucket(turns, messages = turns.flatMap(turn => turn.text)) {
 /**
  * Recompute provider history from untrimmed candidates; never mutate/cache the
- * result in the transcript. Past human turns are atomic text units, including
- * every VP's assistant text. Tools are optional enrichment, newest first.
+ * result in the transcript. Past human turn boundaries are retained when the
+ * configured recent window fits; tools are optional enrichment, newest first.
  *
  * The active turn is outside both buckets and consumes the global budget first.
- * Its opening user row is protected; an oversized active turn alone may be
- * fitted using the legacy protocol-safe transform. Past turns are never fitted.
- * External recall must have comparable userSeq/source identities to establish
+ * Its opening user row is protected. Oversized recent text is fitted only in the
+ * disposable provider copy so one large turn cannot evict the rest of the recent
+ * window. Related recall remains optional and complete. External recall must have
+ * comparable userSeq/source identities to establish
  * that it predates recent/current history; unknown chronology fails closed.
  *
  * @param {Array<object>} snapshot Untrimmed history plus the active execution.
  * @param {{ prompt?: string, relatedTurns?: Array<object>, recentTurnCap?: number,
  * relatedTurnCap?: number, messageTokenBudget?: number, maxMessageCount?: number,
- * language?: string, currentTurnStartIndex?: number,
+ * keepToolTurns?: number, language?: string, currentTurnStartIndex?: number,
  * scoreTurn?: (turn: object, prompt: string) => (number|object) }} [options]
  * @returns {{messages: Array<object>, meta: object}}
  */
@@ -915,6 +919,7 @@ export function buildHistoryBuckets(snapshot, options = {}) {
   const messageCap = bucketCap(options.maxMessageCount, DEFAULT_RUNTIME_CACHE_MESSAGE_CAP);
   const recentCap = bucketCap(options.recentTurnCap, 20);
   const relatedCap = bucketCap(options.relatedTurnCap, 8, 10);
+  const keepToolTurns = bucketCap(options.keepToolTurns, DEFAULT_KEEP_TOOL_TURNS);
   const allTurns = splitBucketTurns(source);
   const currentStart = Number.isInteger(options.currentTurnStartIndex)
     ? Math.max(0, Math.min(source.length, options.currentTurnStartIndex))
@@ -1025,16 +1030,53 @@ export function buildHistoryBuckets(snapshot, options = {}) {
   const reserve = reservable.length ? Math.floor(availableTokens * 0.25) : 0;
   const reservedRows = reservable.length
     ? Math.max(Math.floor(availableRows * 0.25), Math.min(...reservable.map(turn => turn.text.length))) : 0;
+  function fitRecentTurn(turn, tokenLimit) {
+    if (turn.tokens <= tokenLimit) return turn.text;
+    const fitted = [];
+    let tokens = tokenLimit;
+    for (let index = 0; index < turn.text.length; index += 1) {
+      const remainingRows = turn.text.length - index;
+      const allowance = Math.max(2, Math.floor(tokens / remainingRows));
+      const message = shrinkMessageToBudget(turn.text[index], allowance);
+      const rows = dropEmptyAssistantRows([message]);
+      fitted.push(...rows);
+      tokens -= estimateMessagesTokens(rows);
+    }
+    return fitted;
+  }
   function selectRecent(limit, rowLimit = availableRows) {
+    const candidates = past.slice(-recentCap);
+    if (!candidates.length || limit <= 0 || rowLimit <= 0) return [];
+    const preserveBoundaries = candidates.length >= MINIMUM_RECENT_PROVIDER_TURNS
+      && rowLimit >= candidates.reduce((sum, turn) => sum + turn.text.length, 0)
+      && limit >= candidates.length * 2;
+    if (!preserveBoundaries) {
+      const selected = [];
+      let tokens = 0;
+      let rows = 0;
+      for (let index = candidates.length - 1; index >= 0; index -= 1) {
+        const turn = candidates[index];
+        if (tokens + turn.tokens > limit || rows + turn.text.length > rowLimit) break;
+        selected.unshift(turn);
+        tokens += turn.tokens;
+        rows += turn.text.length;
+      }
+      return selected;
+    }
     const selected = [];
-    let tokens = 0;
-    let rows = 0;
-    for (let index = past.length - 1; index >= 0 && selected.length < recentCap; index -= 1) {
-      const turn = past[index];
-      if (tokens + turn.tokens > limit || rows + turn.text.length > rowLimit) break;
-      selected.unshift(turn);
-      tokens += turn.tokens;
-      rows += turn.text.length;
+    let tokens = Math.floor(limit);
+    let rows = Math.floor(rowLimit);
+    for (const turn of candidates) {
+      const remainingTurns = candidates.length - selected.length;
+      if (rows < remainingTurns) break;
+      const allowance = Math.max(2, Math.floor(tokens / remainingTurns));
+      const fitted = fitRecentTurn(turn, allowance);
+      if (!fitted.length || fitted.length > rows - (remainingTurns - 1)) continue;
+      const used = estimateMessagesTokens(fitted);
+      selected.push({ ...turn, text: fitted, tokens: used });
+      tokens -= used;
+      rows -= fitted.length;
     }
     return selected;
   }
@@ -1072,13 +1114,22 @@ export function buildHistoryBuckets(snapshot, options = {}) {
   related.sort((a, b) => bucketBefore(a, b) ? -1 : bucketBefore(b, a) ? 1 : 0);
   const relatedMessages = related.flatMap(turn => turn.text);
-  const recentText = withHistorySourceIndexes(recent.flatMap(turn => turn.messages)
-    .filter(isVisibleConversationRow));
-  const recentBaseline = bucketTextMessages(recentText);
+  const recentText = recent.flatMap(turn => turn.messages)
+    .filter(isVisibleConversationRow);
+  const recentWasFitted = recent.some(turn => turn.text !== turn.messages
+    && (turn.text.length !== bucketTextMessages(turn.messages).length
+      || turn.tokens !== estimateMessagesTokens(bucketTextMessages(turn.messages))));
+  const recentBaseline = recent.flatMap(turn => recentWasFitted ? turn.text : bucketTextMessages(turn.messages));
   // Enrich only after both complete-text buckets and the active turn are paid.
+  // Tool protocol is useful only for immediate continuity; unlike visible text,
+  // it never reaches farther back than the configured recent tool window.
+  const toolCutIndex = indexOfNthTurnFromEnd(recentText, keepToolTurns);
+  const recentToolSource = keepToolTurns > 0
+    ? recentText.slice(toolCutIndex < 0 ? 0 : toolCutIndex)
+    : [];
   const recentMessages = withoutHistorySourceIndexes(addOptionalRecentToolPairs(
     recentBaseline,
-    truncateToolResultsForModel(recentText, { language: options.language }),
+    truncateToolResultsForModel(recentToolSource, { language: options.language }),
     {
       messageTokenBudget: availableTokens - estimateMessagesTokens(relatedMessages),
       maxMessageCount: availableRows - relatedMessages.length,

package/yeaft/prompts.js CHANGED Viewed

@@ -532,6 +532,8 @@ function renderVpPersona(vpPersona, lang, effectiveLang = 'en') {
   const name = selectVpPersonaName(vpPersona, effectiveLang);
   if (!name) return '';
   const body = selectVpPersonaBody(vpPersona, effectiveLang);
+  const runtimePreamble = typeof vpPersona.runtimePreamble === 'string'
+    ? vpPersona.runtimePreamble.trim() : '';
   // Persona is the IDENTITY layer (not an overlay). Do not prepend a
   // generic assistant identity here: the VP soul body is the source of truth.
@@ -540,6 +542,7 @@ function renderVpPersona(vpPersona, lang, effectiveLang = 'en') {
   const soulHeading = effectiveLang === 'zh' ? '## 灵魂' : '## Soul';
   const lines = [`# ${name}`, '', soulHeading];
   if (body) lines.push('', body);
+  if (runtimePreamble) lines.push('', runtimePreamble);
   return lines.join('\n');
 }

package/yeaft/session.js CHANGED Viewed

@@ -49,7 +49,8 @@ import { ensureDefaultSessionIfEmpty, migrateRegisteredWorkDirSessions } from '.
 import { seedDefaultVps } from './vp/seed-defaults.js';
 import { topUpDefaultVps } from './vp/seed-topup.js';
 import { archiveLegacyScopes } from './memory/seed-backfill.js';
-import { createV2DreamScheduler, bootInitEmptyGroups, bootCatchUpStaleDream } from './dream/session-wiring.js';
+// Dream scheduler wiring is intentionally not imported while the runtime path is disabled.
+// import { createV2DreamScheduler, bootInitEmptyGroups, bootCatchUpStaleDream } from './dream/session-wiring.js';
 import { isWorkCenterEnabled } from './work-center/feature.js';
 import { openSegmentIndex } from './memory/index-db.js';
 import { syncAll as syncSegmentIndex } from './memory/segment-sync.js';
@@ -473,50 +474,20 @@ export async function loadSession(options = {}) {
   });
-  // ─── 9a. Create dream scheduler ────────────
-  // The legacy R6 dream-scheduler was retired alongside recall-r6;
-  // dream is the only active path (the `config.memoryV2` opt-out
-  // flag was retired in task-710 — wiring is unconditional).
-  // partialSession lets the v2 scheduler dereference adapter/config/
-  // engine/trace lazily — safe because callers attach more fields
-  // after this line.
-  const partialSession = {
-    yeaftDir,
-    adapter,
-    config,
-    engine,
-    trace,
-  };
-  const dreamScheduler = createV2DreamScheduler(partialSession);
-  // task-710: kick a dream pass at boot for any group that has user
-  // messages but zero memory segments in the FTS index. Without this a
-  // freshly opened agent had to wait an hour (or for the nudge counter
-  // to cross 50) before the first segment landed and recall could find
-  // anything. Fire-and-forget; failure logs at debug only.
-  if (memoryIndex && !config._readOnly) {
-    bootInitEmptyGroups({
-      yeaftDir,
-      memoryIndex,
-      dreamScheduler,
-      config,
-    }).catch(() => { /* best-effort boot init */ });
-  }
-  // fix/dream-cadence-and-ui-trigger: stale-cadence catch-up. If the
-  // newest per-group lastDreamAt across all groups is older than
-  // DREAM_INTERVAL_HOURS (or absent and there's user traffic), fire a
-  // single non-manual tick now. Independent of the interval timer —
-  // necessary because production observed 12 days between scheduled
-  // ticks (the unref'd interval did not fire reliably on long-lived
-  // server processes).
-  if (!config._readOnly) {
-    bootCatchUpStaleDream({
-      yeaftDir,
-      dreamScheduler,
-      config,
-    }).catch(() => { /* best-effort catch-up */ });
-  }
+  // ─── 9a. Dream runtime temporarily disabled ────────────
+  // Message history now supplies turn context. Keep the Dream implementation
+  // and persisted data intact, but do not create a scheduler or run boot-time
+  // initialization/catch-up while the replacement is evaluated.
+  //
+  // const partialSession = { yeaftDir, adapter, config, engine, trace };
+  // const dreamScheduler = createV2DreamScheduler(partialSession);
+  // if (memoryIndex && !config._readOnly) {
+  //   bootInitEmptyGroups({ yeaftDir, memoryIndex, dreamScheduler, config }).catch(() => {});
+  // }
+  // if (!config._readOnly) {
+  //   bootCatchUpStaleDream({ yeaftDir, dreamScheduler, config }).catch(() => {});
+  // }
+  const dreamScheduler = null;
   // H2.f.5 retired the old session-level thread engine registry, input queue,
   // and dispatcher. The session exposes a default `engine`; PR #797 keeps

package/yeaft/sub-agent/runner.js CHANGED Viewed

@@ -221,10 +221,12 @@ export function startSubAgent(agent, deps = {}) {
       deps.parentVpPersona && typeof deps.parentVpPersona === 'object'
         ? { ...deps.parentVpPersona }
         : {};
-    baseVpPersona.persona =
-      [(baseVpPersona.persona || '').trim(), preamble.trim()]
-        .filter(Boolean)
-        .join('\n\n');
+    // Keep the spawned-agent contract outside the inherited VP soul. Stock
+    // souls can contain bilingual section markers, and persona rendering selects
+    // one language section before provider dispatch; appending the preamble to
+    // that source can therefore discard the child identity and mission. The
+    // prompt renderer appends this runtime-only block after soul selection.
+    baseVpPersona.runtimePreamble = preamble.trim();
     if (!baseVpPersona.displayName || !String(baseVpPersona.displayName).trim()) {
       baseVpPersona.displayName = `${deps.parentName || 'Parent'}/${agent.name || 'sub-agent'}`;
     }