@yeaft/webchat-agent 1.0.202 → 1.0.203

package/local-runtime/version.json

@@ -1 +1 @@
-{"version":"1.0.202"}
+{"version":"1.0.203"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.202",
+  "version": "1.0.203",
   "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

@@ -32,7 +32,7 @@ import { archiveTurn } from './archive/turn-archive.js';
 import { archiveToolResults } from './archive/tool-results.js';
 import { readSummary as readScopeSummary } from './memory/store.js';
 import { runAdjust } from './memory/adjust.js';
-import { cleanMemoryPromptText } from './memory/prompt-cleanup.js';
+import { cleanMemoryPromptText, isMemoryPromptRelevant } from './memory/prompt-cleanup.js';
 import { isVpSeedBackfillStub } from './memory/seed-backfill.js';
 import { runStopHooks } from './stop-hooks.js';
 import { perfNowMs, recordAgentPerfTrace } from './perf-trace.js';
@@ -388,6 +388,20 @@ export function shouldAllowGroupReflection({
  * }} args
  * @returns {Array<{scope: string, summary: string}>}
  */
+export function selectResidentTopicScopes(topicScopes, recallEntries, userMsg = '') {
+  const recalledTopicScopes = new Set((recallEntries || [])
+    .map(entry => entry?.scope)
+    .filter(scope => typeof scope === 'string' && /^sessions\/[^/]+\/topic\//.test(scope)));
+  return (Array.isArray(topicScopes) ? topicScopes : [])
+    .filter(scope => recalledTopicScopes.has(scope) || isTopicScopeRelevant(scope, userMsg));
+}
+
+function isTopicScopeRelevant(scope, userMsg) {
+  if (!userMsg || typeof scope !== 'string') return false;
+  const label = scope.replace(/^sessions\/[^/]+\/topic\//, '').replace(/[/-]+/g, ' ');
+  return isMemoryPromptRelevant(label, userMsg);
+}
+
 export function buildResidentEntries(args) {
   const summaries = (args && args.summaries) || {};
   const out = [];
@@ -873,6 +887,7 @@ export class Engine {
    *   ownVpId?: string|null,
    *   summaries: { user?: string, session?: string, vp?: string },
    *   recallEntries: object[],
+   *   userMsg?: string,
    * }} args
    * @returns {{
    *   ams: import('./memory/ams.js').ActiveMemorySet,
@@ -912,7 +927,7 @@ export class Engine {
     ams.setOnDemand(segs);
 
     // (c) Snapshot — render the AMS layers as a single prompt block.
-    const snapshotBlock = this.#renderAmsSnapshot(ams, this.#config.language || 'en');
+    const snapshotBlock = this.#renderAmsSnapshot(ams, this.#config.language || 'en', args.userMsg || '');
 
     const scopes = buildRelevantScopes({
       sessionId: args.sessionId,
@@ -929,10 +944,11 @@ export class Engine {
    *
    * @param {import('./memory/ams.js').ActiveMemorySet} ams
    * @param {string} [language]
+   * @param {string} [userMsg]
    * @returns {string}
    */
-  #renderAmsSnapshot(ams, language = 'en') {
-    const snap = ams.snapshot();
+  #renderAmsSnapshot(ams, language = 'en', userMsg = '') {
+    const snap = ams.snapshot({ userMsg });
     if (!snap) return '';
     const parts = [];
     if (snap.resident.length === 0 && snap.recent.length === 0 && snap.onDemand.length === 0) {
@@ -1906,6 +1922,11 @@ export class Engine {
     if (recallEntryCount > 0) {
       yield { type: 'recall', entryCount: recallEntryCount, cached: false, threadId };
     }
+    const topicScopesForResident = selectResidentTopicScopes(
+      topicScopesForMemory,
+      recallResult?.entries || [],
+      prompt,
+    );
 
     // Layer-A summaries — same scopes AMS Resident will surface, loaded
     // here so we can pass them into #prepareAms. (Rolling per-scope
@@ -1916,7 +1937,7 @@ export class Engine {
         ? vpPersona.vpId
         : (typeof senderVpId === 'string' ? senderVpId : undefined),
       language: this.#config.language || 'en',
-      topicScopes: topicScopesForMemory,
+      topicScopes: topicScopesForResident,
     });
 
     // ─── AMS: populate + snapshot ───────────────────────────────
@@ -1935,6 +1956,7 @@ export class Engine {
       ownVpId: ownVpIdForAms,
       summaries,
       recallEntries: recallResult ? (recallResult.entries || []) : [],
+      userMsg: prompt,
     });
     if (amsContext && amsContext.snapshotBlock) {
       memoryInjection = amsContext.snapshotBlock;

package/yeaft/memory/ams.js

@@ -17,7 +17,12 @@
  */
 
 import { approxTokens } from './budget.js';
-import { cleanMemoryPromptText, isDuplicateMemoryText, rememberMemoryText } from './prompt-cleanup.js';
+import {
+  cleanMemoryPromptText,
+  filterMemoryPromptTextForPrompt,
+  isDuplicateMemoryText,
+  rememberMemoryText,
+} from './prompt-cleanup.js';
 import { isVpForeign } from './store.js';
 
 const RECENT_DEFAULT_CAPACITY = 64;
@@ -144,16 +149,18 @@ export class ActiveMemorySet {
    * system prompt. Each layer is greedily packed within its budget;
    * overflow is dropped from this turn but not from disk.
    *
+   * @param {{ userMsg?: string }} [opts]
    * @returns {AmsSnapshot}
    */
-  snapshot() {
+  snapshot(opts = {}) {
+    const userMsg = typeof opts.userMsg === 'string' ? opts.userMsg : '';
     const seenPromptText = new Set();
 
     // Resident: pack scopes by priority order (caller provides via insert
     // order — current group's own vp first, then user, etc.).
     const { picked: resPicked, cost: resCost } = pickMemoryItems({
       items: [...this._resident.entries()].map(([scope, summary]) => ({
-        scope, summary: cleanMemoryPromptText(summary),
+        scope, summary: filterMemoryPromptTextForPrompt(summary, userMsg),
       })),
       budget: this.budget.resident,
       seen: seenPromptText,
@@ -165,7 +172,7 @@ export class ActiveMemorySet {
     const { picked: recPicked, cost: recCost } = pickMemoryItems({
       items: [...this._recent.values()]
         .reverse()
-        .map(e => ({ ...e.seg, body: cleanMemoryPromptText(e.seg?.body) })),
+        .map(e => ({ ...e.seg, body: filterMemoryPromptTextForPrompt(e.seg?.body, userMsg) })),
       budget: this.budget.recent,
       seen: seenPromptText,
       textOf: seg => seg.body,
@@ -175,7 +182,7 @@ export class ActiveMemorySet {
     // OnDemand: insertion order from caller (already FTS-ranked).
     const { picked: odPicked, cost: odCost } = pickMemoryItems({
       items: [...this._onDemand.values()]
-        .map(seg => ({ ...seg, body: cleanMemoryPromptText(seg?.body) })),
+        .map(seg => ({ ...seg, body: filterMemoryPromptTextForPrompt(seg?.body, userMsg) })),
       budget: this.budget.onDemand,
       seen: seenPromptText,
       textOf: seg => seg.body,

package/yeaft/memory/prompt-cleanup.js

@@ -8,6 +8,20 @@
 
 const DREAM_STATE_BLOCK_RE = /<!--\s*dream-state\s*-->[\s\S]*?<!--\s*\/dream-state\s*-->/gi;
 
+const TRANSIENT_MEMORY_RE = /\b(work\s*item|current\s+(?:state|work|task)|in[_ -]?progress|todo|next\s+step|blocker|blocked|pr\s*#?\d+|pull\s+request|review|merge\s+commit|release\s+tag|tag\s+v\d|v\d+\.\d+\.\d+)\b|(?:工作项|当前(?:状态|任务|工作)|正在|待办|下一步|阻塞|评审|合并|发布|标签|已推|已合并|已完成)/i;
+const ASCII_WORD_RE = /[a-z0-9_]{3,}/gi;
+const CJK_RUN_RE = /[\u4e00-\u9fff]{2,}/g;
+const MARKDOWN_LIST_ITEM_RE = /^\s*(?:[-*+]\s+|\d+[.)]\s+)/;
+const COMMON_INTENT_TOKENS = new Set([
+  'current', 'state', 'work', 'task', 'item', 'items', 'todo', 'todos',
+  'next', 'step', 'steps', 'done', 'completed', 'finish', 'finished',
+  'merge', 'merged', 'review', 'reviewed', 'release', 'tag', 'tags',
+  'pr', 'pull', 'request', 'issue', 'fix', 'feat', 'test', 'tests',
+  'dream', 'memory', 'session', 'topic', 'status', 'blocker', 'blocked',
+  '当前', '状态', '任务', '工作', '工作项', '待办', '下一步', '完成', '已完成',
+  '合并', '评审', '发布', '标签', '记忆', '主题', '阻塞', '正在',
+]);
+
 /**
  * Remove Dream scheduler metadata blocks from memory text.
  *
@@ -31,6 +45,134 @@ export function cleanMemoryPromptText(text) {
     .trim();
 }
 
+/**
+ * Whether a memory item describes short-lived execution state rather than a
+ * stable preference / project fact. Transient memory is still valid on disk, but
+ * should only enter the prompt when it is related to the current user turn.
+ *
+ * @param {string} text
+ * @returns {boolean}
+ */
+export function isTransientMemoryText(text) {
+  return TRANSIENT_MEMORY_RE.test(cleanMemoryPromptText(text));
+}
+
+/**
+ * Conservative prompt relevance gate for transient Dream memories. Stable
+ * memories are handled by the caller; this function only answers whether a
+ * known-transient item has lexical overlap with the current user request.
+ *
+ * @param {string} memoryText
+ * @param {string} userText
+ * @returns {boolean}
+ */
+export function isTransientMemoryRelevant(memoryText, userText) {
+  return isMemoryPromptRelevant(memoryText, userText);
+}
+
+/**
+ * Conservative lexical relevance check used only at prompt assembly time. It is
+ * deliberately not semantic clustering: if there is no concrete token overlap,
+ * the memory should win again through FTS when the user asks for it explicitly.
+ *
+ * @param {string} memoryText
+ * @param {string} userText
+ * @returns {boolean}
+ */
+export function isMemoryPromptRelevant(memoryText, userText) {
+  const memoryTokens = promptRelevanceTokens(memoryText);
+  const userTokens = promptRelevanceTokens(userText);
+  if (memoryTokens.size === 0 || userTokens.size === 0) return false;
+  for (const token of memoryTokens) {
+    if (userTokens.has(token)) return true;
+  }
+  return false;
+}
+
+/**
+ * Drop irrelevant transient paragraphs while preserving stable memory text. This
+ * keeps disk memory intact; it only trims what enters the current prompt.
+ *
+ * @param {string} text
+ * @param {string} userText
+ * @returns {string}
+ */
+export function filterMemoryPromptTextForPrompt(text, userText) {
+  const cleaned = cleanMemoryPromptText(text);
+  if (!cleaned || !userText) return cleaned;
+  const kept = [];
+  for (const chunk of splitMemoryPromptChunks(cleaned)) {
+    if (!isTransientMemoryText(chunk) || isTransientMemoryRelevant(chunk, userText)) {
+      kept.push(chunk);
+    }
+  }
+  return joinMemoryPromptChunks(kept).trim();
+}
+
+function splitMemoryPromptChunks(text) {
+  const chunks = [];
+  for (const block of String(text || '').split(/\n{2,}/)) {
+    const trimmed = block.trim();
+    if (!trimmed) continue;
+    chunks.push(...splitListBlock(trimmed));
+  }
+  return chunks;
+}
+
+function splitListBlock(block) {
+  const lines = block.split('\n');
+  if (!lines.some(line => MARKDOWN_LIST_ITEM_RE.test(line))) return [block];
+
+  const chunks = [];
+  let current = [];
+  for (const line of lines) {
+    if (MARKDOWN_LIST_ITEM_RE.test(line) && current.length > 0) {
+      chunks.push(current.join('\n').trim());
+      current = [];
+    }
+    current.push(line);
+  }
+  if (current.length > 0) chunks.push(current.join('\n').trim());
+  return chunks.filter(Boolean);
+}
+
+function joinMemoryPromptChunks(chunks) {
+  const out = [];
+  let previousWasList = false;
+  for (const chunk of chunks) {
+    const isList = MARKDOWN_LIST_ITEM_RE.test(chunk);
+    if (out.length > 0 && !(previousWasList && isList)) out.push('');
+    out.push(chunk);
+    previousWasList = isList;
+  }
+  return out.join('\n');
+}
+
+/**
+ * @param {string} text
+ * @returns {Set<string>}
+ */
+export function promptRelevanceTokens(text) {
+  const cleaned = cleanMemoryPromptText(text).toLowerCase();
+  const out = new Set();
+  for (const match of cleaned.matchAll(ASCII_WORD_RE)) {
+    const token = match[0];
+    if (!COMMON_INTENT_TOKENS.has(token)) out.add(token);
+  }
+  for (const match of cleaned.matchAll(CJK_RUN_RE)) {
+    for (const token of cjkBigrams(match[0])) {
+      if (!COMMON_INTENT_TOKENS.has(token)) out.add(token);
+    }
+  }
+  return out;
+}
+
+function cjkBigrams(text) {
+  const out = [];
+  for (let i = 0; i < text.length - 1; i += 1) out.push(text.slice(i, i + 2));
+  return out;
+}
+
 /**
  * Normalized key for conservative prompt dedupe. This is intentionally simple:
  * exact semantic clustering belongs in Dream; prompt assembly only removes