@yeaft/webchat-agent 1.0.325 → 1.0.328

package/package.json

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

@@ -31,6 +31,7 @@ import { evaluateCompactTriggers } from './compact/triggers.js';
 import { archiveTurn } from './archive/turn-archive.js';
 import { archiveToolResults } from './archive/tool-results.js';
 import { readSummary as readScopeSummary } from './memory/store.js';
+import { ActiveMemorySet } from './memory/ams.js';
 import { runAdjust } from './memory/adjust.js';
 import { cleanMemoryPromptText, isMemoryPromptRelevant } from './memory/prompt-cleanup.js';
 import { isVpSeedBackfillStub } from './memory/seed-backfill.js';
@@ -44,7 +45,7 @@ import { lookupModelLimitSync } from './llm/models-dev.js';
 import { countTurns } from './turn-utils.js';
 import { attachRouterPlan, extractPriorPlan, stripMetaForWire } from './router/continuity.js';
 import { resolveThinking } from './router/thinking.js';
-import { approxTokens } from './memory/budget.js';
+import { approxTokens, computeBudget } from './memory/budget.js';
 import { COLLAB_TOOL_POLICY, isToolErrorOutput, normalizeToolOutput, truncateToolResultIfNeeded } from './tools/registry.js';
 import { extractDisplayImages, stripDisplayImageData } from './image-assets.js';
 import { acknowledgePendingNotifications, formatNotificationsForPrompt, peekPendingNotifications } from './sub-agent/notifications.js';
@@ -365,7 +366,7 @@ export function shouldAllowGroupReflection({
  * @typedef {{ type: 'turn_start', turnNumber: number }} TurnStartEvent
  * @typedef {{ type: 'turn_end', turnNumber: number, stopReason: string, terminal?: boolean }} TurnEndEvent
  * @typedef {{ type: 'tool_start', id: string, name: string, input: object }} ToolStartEvent
- * @typedef {{ type: 'tool_end', id: string, name: string, output: string, isError: boolean }} ToolEndEvent
+ * @typedef {{ type: 'tool_end', id: string, name: string, output: string, isError: boolean, skipped?: boolean }} ToolEndEvent
  * @typedef {{ type: 'consolidate', archivedCount: number, extractedCount: number }} ConsolidateEvent
  * @typedef {{ type: 'recall', entryCount: number, cached: boolean }} RecallEvent
  * @typedef {{ type: 'fallback', from: string, to: string, reason: string }} FallbackEvent
@@ -399,7 +400,7 @@ export function shouldAllowGroupReflection({
  * @param {{
  *   sessionId?: string|null,
  *   ownVpId?: string|null,
- *   summaries: { user?: string, session?: string, vp?: string, topics?: Array<{scope:string, summary:string}> }
+ *   summaries: { user?: string, session?: string, vp?: string, topics?: Array<{scope:string, summary:string}>, relatedSessions?: Array<{sessionId:string, summary:string}> }
  * }} args
  * @returns {Array<{scope: string, summary: string}>}
  */
@@ -445,6 +446,18 @@ export function buildResidentEntries(args) {
   if (args.sessionId && args.ownVpId && vpSummary && !isVpSeedBackfillStub(vpSummary)) {
     out.push({ scope: `sessions/${args.sessionId}/vp/${args.ownVpId}`, summary: vpSummary });
   }
+  // Related Session experience is useful but lower-priority than every memory
+  // source owned by the active Session/VP. Append it last so the resident
+  // budget can never evict current context in favour of historical prose.
+  if (Array.isArray(summaries.relatedSessions)) {
+    for (const related of summaries.relatedSessions) {
+      const relatedSessionId = typeof related?.sessionId === 'string' ? related.sessionId.trim() : '';
+      const summary = cleanMemoryPromptText(related?.summary);
+      if (relatedSessionId && relatedSessionId !== args.sessionId && summary) {
+        out.push({ scope: `sessions/${relatedSessionId}`, summary });
+      }
+    }
+  }
   return out;
 }
 
@@ -452,6 +465,11 @@ function isZhRuntimeLanguage(language) {
   return String(language || '').toLowerCase().startsWith('zh');
 }
 
+function sessionIdFromMemoryScope(scope) {
+  const match = /^(?:sessions|session|group)\/([^/]+)$/.exec(String(scope || ''));
+  return match ? match[1] : null;
+}
+
 function resolveMemoryRecallLimit(config) {
   const raw = config?.memoryRecallLimit ?? config?.dreamMemoryRecallLimit;
   if (!Number.isFinite(raw) || raw <= 0) return DEFAULT_MEMORY_RECALL_LIMIT;
@@ -476,6 +494,7 @@ function loadedResidentDebugEntries(entries) {
     kind: 'summary',
     score: null,
     tags: [],
+    category: entry.category || null,
     body: entry.summary || '',
   })).filter(entry => entry.body);
 }
@@ -910,13 +929,17 @@ export class Engine {
    * dream tick (Phase 6) is what populates these; on a fresh install they
    * all return ''.
    *
-   * @param {{sessionId?: string, vpId?: string, language?: string, topicScopes?: string[]}} ctx
-   * @returns {Promise<{user:string, session:string, vp:string, topics:Array<{scope:string, summary:string}>}>}
+   * @param {{sessionId?: string, vpId?: string, language?: string, topicScopes?: string[], relatedSessionIds?: string[]}} ctx
+   * @returns {Promise<{user:string, session:string, vp:string, topics:Array<{scope:string, summary:string}>, relatedSessions:Array<{sessionId:string, summary:string}>}>}
    */
-  async #loadLayerASummaries({ sessionId, vpId, language, topicScopes } = {}) {
-    if (!this.#yeaftDir) return { user: '', session: '', vp: '', topics: [] };
+  async #loadLayerASummaries({ sessionId, vpId, language, topicScopes, relatedSessionIds } = {}) {
+    if (!this.#yeaftDir) return { user: '', session: '', vp: '', topics: [], relatedSessions: [] };
     const memoryRoot = `${this.#yeaftDir}/memory`;
     const topicScopeList = Array.isArray(topicScopes) ? topicScopes.slice(0, 12) : [];
+    const relatedIds = Array.from(new Set((Array.isArray(relatedSessionIds) ? relatedSessionIds : [])
+      .filter(id => typeof id === 'string' && id.trim() && id.trim() !== sessionId)
+      .map(id => id.trim())))
+      .slice(0, 8);
     const tasks = [
       readScopeSummary({ kind: 'user' }, { root: memoryRoot, language }).catch(() => ''),
       sessionId
@@ -926,10 +949,18 @@ export class Engine {
         ? readScopeSummary({ kind: 'session-vp', sessionId, id: vpId }, { root: memoryRoot, language }).catch(() => '')
         : Promise.resolve(''),
       Promise.all(topicScopeList.map(scope => readTopicSummary(scope, { root: memoryRoot, language }))),
+      Promise.all(relatedIds.map(async relatedSessionId => ({
+        sessionId: relatedSessionId,
+        summary: await readScopeSummary(
+          { kind: 'session', id: relatedSessionId },
+          { root: memoryRoot, language },
+        ).catch(() => ''),
+      }))),
     ];
-    const [user, session, vp, topicsRaw] = await Promise.all(tasks);
+    const [user, session, vp, topicsRaw, relatedSessionsRaw] = await Promise.all(tasks);
     const topics = (topicsRaw || []).filter(t => t && t.summary);
-    return { user: user || '', session: session || '', vp: vp || '', topics };
+    const relatedSessions = (relatedSessionsRaw || []).filter(entry => entry && entry.summary);
+    return { user: user || '', session: session || '', vp: vp || '', topics, relatedSessions };
   }
 
   async #loadSessionTopicLabels(sessionId, limit = 8) {
@@ -967,27 +998,42 @@ export class Engine {
    * } | null}
    */
   #prepareAms(args) {
-    if (!this.#amsRegistry) return null;
     const sessionKey = args.sessionId || 'default';
     const ownVpId = args.ownVpId || null;
-    const ams = this.#amsRegistry.getOrCreate(sessionKey, { ownVpId });
+    // Some read-only Engine entry points (notably sub-agents) intentionally do
+    // not own the parent's persistent registry. They still need the single AMS
+    // render outlet, otherwise FTS recall succeeds and then vanishes before the
+    // prompt. Use an isolated per-query AMS in that case: it preserves budgets,
+    // cleanup, and dedupe without sharing mutable parent state or writing disk.
+    const ams = this.#amsRegistry
+      ? this.#amsRegistry.getOrCreate(sessionKey, { ownVpId })
+      : new ActiveMemorySet({
+          ownVpId,
+          budget: computeBudget(this.#config?.maxContextTokens),
+        });
 
     // Prime #adjustRanBySession from disk-hydrated state on first access:
     // a reactivated group resumes with whatever adjustRanThisSession bit
     // it had on disconnect, so we don't burn a fresh adjust on every
     // reload. Once set true in this session we never clear it.
-    if (!this.#adjustRanBySession.has(sessionKey)
+    if (this.#amsRegistry
+        && !this.#adjustRanBySession.has(sessionKey)
         && this.#amsRegistry.adjustRanThisSession(sessionKey)) {
       this.#adjustRanBySession.set(sessionKey, true);
     }
 
     // (a) Resident: rebuild from the same scope summaries the worker
     // prompt is already going to see.
+    const relatedSessionIds = new Set((args.summaries?.relatedSessions || [])
+      .map(entry => entry?.sessionId)
+      .filter(Boolean));
     const residentEntries = buildResidentEntries({
       sessionId: args.sessionId,
       ownVpId,
       summaries: args.summaries || {},
-    });
+    }).map(entry => relatedSessionIds.has(entry.scope.replace(/^sessions\//, ''))
+      ? { ...entry, category: 'experience' }
+      : { ...entry, category: 'memory' });
     ams.setResident(residentEntries);
 
     // (b) onDemand: replace with this turn's FTS hits.
@@ -996,7 +1042,11 @@ export class Engine {
 
     // (c) Snapshot — render the AMS layers as a single prompt block.
     const snapshot = ams.snapshot({ userMsg: args.userMsg || '' });
-    const snapshotBlock = this.#renderAmsSnapshot(snapshot, this.#config.language || 'en');
+    const snapshotBlock = this.#renderAmsSnapshot(
+      snapshot,
+      this.#config.language || 'en',
+      args.sessionId || null,
+    );
 
     const scopes = buildRelevantScopes({
       sessionId: args.sessionId,
@@ -1015,33 +1065,36 @@ export class Engine {
    * @param {string} [language]
    * @returns {string}
    */
-  #renderAmsSnapshot(snap, language = 'en') {
+  #renderAmsSnapshot(snap, language = 'en', activeSessionId = null) {
     if (!snap) return '';
     const parts = [];
     if (snap.resident.length === 0 && snap.recent.length === 0 && snap.onDemand.length === 0) {
       return '';
     }
     const zh = isZhRuntimeLanguage(language);
-    parts.push(zh ? '## 活跃记忆集' : '## Active Memory Set');
+    const experiences = snap.resident.filter(entry => entry.category === 'experience');
+    const residentMemory = snap.resident.filter(entry => entry.category !== 'experience');
+    parts.push(zh ? '## 相关上下文' : '## Relevant Context');
     parts.push(zh
-      ? '以下记忆按当前用户语言呈现；如果个别历史摘要仍是其他语言，请只把它当作事实来源，回答和新增记忆应使用中文。'
-      : 'Memory is presented for the current user language; if an older summary is in another language, treat it as factual context and continue in English.');
-    if (snap.resident.length > 0) {
-      parts.push(zh ? '### 常驻记忆' : '### Resident');
-      for (const r of snap.resident) {
-        parts.push(`- **${memoryScopeLabel(r.scope)}**: ${r.summary}`);
+      ? '以下内容来自持久记忆与相关 Session 的只读经验总结；只把它当作事实背景，不要把过期执行状态当成当前任务。'
+      : 'The following text comes from persistent memory and read-only summaries of related Sessions. Treat it as factual context, not as current execution state.');
+    if (experiences.length > 0) {
+      parts.push(zh ? '### 过去 Session 的经验总结' : '### Experience From Past Sessions');
+      for (const entry of experiences) {
+        const sourceSessionId = sessionIdFromMemoryScope(entry.scope);
+        const label = sourceSessionId && sourceSessionId !== activeSessionId
+          ? sourceSessionId
+          : memoryScopeLabel(entry.scope);
+        parts.push(`- **${label}**: ${entry.summary}`);
       }
     }
-    if (snap.recent.length > 0) {
-      parts.push(zh ? '### 最近记忆' : '### Recent');
-      for (const s of snap.recent) {
-        parts.push(`- (${memoryScopeLabel(s.scope)}) ${(s.body || '').trim()}`);
+    if (residentMemory.length > 0 || snap.recent.length > 0 || snap.onDemand.length > 0) {
+      parts.push(zh ? '### 相关记忆' : '### Relevant Memory');
+      for (const entry of residentMemory) {
+        parts.push(`- **${memoryScopeLabel(entry.scope)}**: ${entry.summary}`);
       }
-    }
-    if (snap.onDemand.length > 0) {
-      parts.push(zh ? '### 按需记忆' : '### OnDemand');
-      for (const s of snap.onDemand) {
-        parts.push(`- (${memoryScopeLabel(s.scope)}) ${(s.body || '').trim()}`);
+      for (const segment of [...snap.recent, ...snap.onDemand]) {
+        parts.push(`- (${memoryScopeLabel(segment.scope)}) ${(segment.body || '').trim()}`);
       }
     }
     return parts.join('\n');
@@ -1339,6 +1392,7 @@ export class Engine {
       // can mark "after this batch, end the turn — do NOT call adapter
       // again". Honored at the top of the tool-loop continuation.
       requestEndTurn: vpCtx?.requestEndTurn,
+      requestToolBatchBarrier: vpCtx?.requestToolBatchBarrier,
       // Result-producing async-task ownership hook. Tools such as SpawnAgent
       // call this with the new `task.id` so the engine keeps the current query
       // parked at end_turn until the result arrives. Persistent background
@@ -2145,6 +2199,7 @@ export class Engine {
         : (typeof senderVpId === 'string' ? senderVpId : undefined),
       language: this.#config.language || 'en',
       topicScopes: topicScopesForResident,
+      relatedSessionIds: projectSessionIds,
     });
 
     // ─── AMS: populate + snapshot ───────────────────────────────
@@ -2210,7 +2265,9 @@ export class Engine {
 
     const projectDoc = this.#getProjectDocBlock(workDir);
     const activeTasks = this.#taskManager
-      ? this.#taskManager.renderActiveTasksForPrompt(runtimeSessionId)
+      ? this.#taskManager.renderActiveTasksForPrompt(runtimeSessionId, {
+          language: this.#config.language || 'en',
+        })
       : '';
     let resolvedSkillContent = '';
     let resolvedSkills = [];
@@ -3636,6 +3693,8 @@ export class Engine {
       }
 
       // Execute tool calls and feed results back
+      /** @type {{ kind?: string, message?: string, sourceToolCallId?: string, sourceToolName?: string } | null} */
+      let toolBatchBarrier = null;
       let currentToolCallForAsyncTask = null;
       // task-707: requestEndTurn is a per-batch closure that lets a tool
       // signal "end this turn after the current batch — no adapter retry".
@@ -3667,6 +3726,17 @@ export class Engine {
             endTurnRequested = reason || { kind: 'tool_handoff' };
           }
         },
+        requestToolBatchBarrier: (reason) => {
+          if (toolBatchBarrier != null) return;
+          const detail = reason && typeof reason === 'object'
+            ? { ...reason }
+            : { message: String(reason || 'A preceding tool result invalidated the remaining batch.') };
+          toolBatchBarrier = {
+            ...detail,
+            sourceToolCallId: currentToolCallForAsyncTask?.id || null,
+            sourceToolName: currentToolCallForAsyncTask?.name || null,
+          };
+        },
       });
 
       // task-325a: track whether we aborted mid tool-loop so we can
@@ -3681,11 +3751,14 @@ export class Engine {
         // that's already running (the signal is passed in, tools decide
         // themselves whether to bail early), but we stop dispatching
         // any remaining tools the moment abort fires.
-        if (signal?.aborted) {
+        if (signal?.aborted && !toolBatchBarrier) {
           abortedDuringTools = true;
           break;
         }
+        if (signal?.aborted) abortedDuringTools = true;
 
+        const activeToolBatchBarrier = toolBatchBarrier;
+        const skipped = activeToolBatchBarrier != null;
         const toolStartTime = Date.now();
 
         // PR-L: duplicate-call detection. If this exact (toolName,
@@ -3696,25 +3769,27 @@ export class Engine {
         // assistant(tool_use) → user(tool_result, …) pairing demanded
         // by the Anthropic / OpenAI Responses APIs stays intact. We
         // don't block the call — the LLM still decides.
-        const dupHash = argsHashOf(tc.input);
-        // PR-L follow-up: lookback is by user-conversation turn
-        // (`queryNumber`), NOT by inner adapter loop iteration. Each call
-        // to query() bumps queryNumber once, so "last 2 turns" means the
-        // current user turn + the previous two user turns — the natural
-        // semantic for "the model is stuck in a loop across the
-        // conversation."
-        const dupInfo = this.#execLog.dupInfo({
-          toolName: tc.name,
-          argsHash: dupHash,
-          currentTurn: queryNumber,
-          lookbackTurns: 2,
-        });
-        if (dupInfo.count + 1 >= DUP_TOOL_THRESHOLD) {
-          pendingDupReminders.push(buildDuplicateReminder({
+        if (!skipped) {
+          const dupHash = argsHashOf(tc.input);
+          // PR-L follow-up: lookback is by user-conversation turn
+          // (`queryNumber`), NOT by inner adapter loop iteration. Each call
+          // to query() bumps queryNumber once, so "last 2 turns" means the
+          // current user turn + the previous two user turns — the natural
+          // semantic for "the model is stuck in a loop across the
+          // conversation."
+          const dupInfo = this.#execLog.dupInfo({
             toolName: tc.name,
-            count: dupInfo.count + 1,
-            lastResultBrief: dupInfo.lastResultBrief,
-          }));
+            argsHash: dupHash,
+            currentTurn: queryNumber,
+            lookbackTurns: 2,
+          });
+          if (dupInfo.count + 1 >= DUP_TOOL_THRESHOLD) {
+            pendingDupReminders.push(buildDuplicateReminder({
+              toolName: tc.name,
+              count: dupInfo.count + 1,
+              lastResultBrief: dupInfo.lastResultBrief,
+            }));
+          }
         }
 
         let output;
@@ -3722,18 +3797,40 @@ export class Engine {
         let isError = false;
         let toolErrorOutput = null;
         let fatalToolError = null;
-        currentToolCallForAsyncTask = {
-          id: tc.id,
-          name: tc.name,
-          threadId: runtimeThreadId,
-        };
+        currentToolCallForAsyncTask = skipped
+          ? null
+          : {
+              id: tc.id,
+              name: tc.name,
+              threadId: runtimeThreadId,
+            };
 
         // Resolve tool: prefer ToolRegistry, fallback to legacy #tools Map
         const hasTool = this.#toolRegistry
           ? this.#toolRegistry.isAllowed(tc.name, { collabToolPolicy: effectiveCollabToolPolicy })
           : this.#tools.has(tc.name);
 
-        if (!hasTool) {
+        if (skipped) {
+          const source = activeToolBatchBarrier.sourceToolName || 'a preceding tool';
+          const sourceId = activeToolBatchBarrier.sourceToolCallId
+            ? ` (${activeToolBatchBarrier.sourceToolCallId})`
+            : '';
+          output = [
+            `Skipped ${tc.name} because ${source}${sourceId} invalidated the remaining tool batch.`,
+            activeToolBatchBarrier.message || 'Review the preceding tool result before deciding whether to retry this call.',
+            'This tool was not executed. Submit it again only after reviewing the preceding result.',
+          ].join('\n');
+          isError = true;
+          yield {
+            type: 'tool_end',
+            id: tc.id,
+            name: tc.name,
+            output,
+            isError: true,
+            skipped: true,
+            threadId: this.currentThreadId,
+          };
+        } else if (!hasTool) {
           output = `Error: unknown tool "${tc.name}"`;
           isError = true;
           yield { type: 'tool_end', id: tc.id, name: tc.name, output, isError: true, threadId: this.currentThreadId };
@@ -3816,13 +3913,14 @@ export class Engine {
           durationMs: toolDurationMs,
           isError,
           toolOutput: output,
+          ...(skipped ? { skipped: true } : {}),
           ...(displayImages.length > 0 ? { displayImageCount: displayImages.length } : {}),
         };
 
         // 2026-05-13: feed the per-tool counters. Stays best-effort — a
         // stats sink that throws shouldn't crash the engine. `record`
         // already swallows internal write errors.
-        if (this.#toolStats && typeof this.#toolStats.record === 'function') {
+        if (!skipped && this.#toolStats && typeof this.#toolStats.record === 'function') {
           try {
             this.#toolStats.record({
               name: tc.name,
@@ -3841,6 +3939,7 @@ export class Engine {
           toolOutput: output,
           durationMs: toolDurationMs,
           isError,
+          skipped,
         });
 
         // Append only the bounded copy to the model message history. Raw
@@ -3876,14 +3975,16 @@ export class Engine {
         // user-conversation turn), not the inner loop's turnNumber.
         // Aligns exec-log layout with dup detection lookback and the
         // T2 fallback-stub readTurn() call below.
-        this.#execLog.append(queryNumber, buildExecLogEntry({
-          loopIdx: queryToolCount,
-          toolName: tc.name,
-          args: tc.input,
-          output,
-          isError,
-        }));
-        queryToolCount += 1;
+        if (!skipped) {
+          this.#execLog.append(queryNumber, buildExecLogEntry({
+            loopIdx: queryToolCount,
+            toolName: tc.name,
+            args: tc.input,
+            output,
+            isError,
+          }));
+          queryToolCount += 1;
+        }
         if (fatalToolError) throw fatalToolError;
       }
 
@@ -3895,6 +3996,11 @@ export class Engine {
         conversationMessages.push({ role: 'user', content: reminder });
       }
 
+      // A batch barrier deliberately returns control to the provider. Any
+      // handoff requested by an earlier call belongs to the invalidated plan
+      // and must not leak into a later provider-generated batch.
+      if (toolBatchBarrier) endTurnRequested = null;
+
       // task-707: tool-callable end-turn signal. If a tool in this batch
       // called toolCtx.requestEndTurn(reason), break out of the outer
       // while-loop now — DON'T call adapter.stream() again. The
@@ -3907,7 +4013,7 @@ export class Engine {
       // collapse the arc into a summary that's only valuable across
       // multi-iteration tool loops) and BEFORE the abortedDuringTools
       // check (so a clean handoff doesn't get reported as 'aborted').
-      if (endTurnRequested) {
+      if (endTurnRequested && !toolBatchBarrier) {
         if (pendingSubAgentNotifs.length > 0) {
           acknowledgePendingNotifications(notifScope, pendingSubAgentNotifs.map(n => n.id));
         }
@@ -3945,7 +4051,8 @@ export class Engine {
       //     batch within the same query gets a distinct entry — without
       //     this the second batch would be silently skipped.
       const t1BatchDue = queryToolCount - lastT1AtToolCount >= TOOL_BATCH_SIZE;
-      if (groupReflectionAllowed && t1BatchDue && !abortedDuringTools && !signal?.aborted) {
+      if (groupReflectionAllowed && t1BatchDue && !toolBatchBarrier
+          && !abortedDuringTools && !signal?.aborted) {
         const t1DedupKey = `${queryNumber}:t1:${queryToolCount}`;
         if (this.#reflectedTurns.has(t1DedupKey)) {
           // Defensive: should never hit since t1BatchDue gates re-entry

package/yeaft/memory/ams.js

@@ -29,14 +29,14 @@ const RECENT_DEFAULT_CAPACITY = 64;
 
 /**
  * @typedef {object} AmsLayers
- * @property {Map<string, string>}                resident
+ * @property {Map<string, { summary: string, category?: string }>} resident
  * @property {Array<{ id: string, seg: import('./segment.js').Segment, ts: number }>} recent
  * @property {Map<string, import('./segment.js').Segment>} onDemand
  */
 
 /**
  * @typedef {object} AmsSnapshot
- * @property {Array<{ scope: string, summary: string }>} resident
+ * @property {Array<{ scope: string, summary: string, category?: string }>} resident
  * @property {import('./segment.js').Segment[]} recent
  * @property {import('./segment.js').Segment[]} onDemand
  * @property {{ resident: number, recent: number, onDemand: number, total: number }} usage
@@ -55,8 +55,8 @@ export class ActiveMemorySet {
     this.ownVpId = opts.ownVpId || null;
     this.budget = opts.budget;
     this.recentCapacity = opts.recentCapacity || RECENT_DEFAULT_CAPACITY;
-    /** @type {Map<string, string>} */
-    this._resident = new Map();          // scope → summaryText
+    /** @type {Map<string, { summary: string, category?: string }>} */
+    this._resident = new Map();          // scope → prompt-facing summary metadata
     /** @type {Map<string, { seg: import('./segment.js').Segment, ts: number }>} */
     this._recent = new Map();            // segId → entry (insertion-order is LRU order)
     /** @type {Map<string, import('./segment.js').Segment>} */
@@ -69,7 +69,7 @@ export class ActiveMemorySet {
    * Replace the resident layer with a fresh set of scope→summary
    * pairs. Foreign VP scopes are silently dropped.
    *
-   * @param {Array<{ scope: string, summary: string }>} entries
+   * @param {Array<{ scope: string, summary: string, category?: string }>} entries
    */
   setResident(entries) {
     this._resident.clear();
@@ -77,7 +77,10 @@ export class ActiveMemorySet {
       if (this._isForeignVp(e.scope)) continue;
       const summary = cleanMemoryPromptText(e.summary);
       if (!summary) continue;
-      this._resident.set(e.scope, summary);
+      this._resident.set(e.scope, {
+        summary,
+        ...(typeof e.category === 'string' && e.category ? { category: e.category } : {}),
+      });
     }
   }
 
@@ -159,8 +162,15 @@ export class ActiveMemorySet {
     // 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: filterMemoryPromptTextForPrompt(summary, userMsg),
+      items: [...this._resident.entries()].map(([scope, entry]) => ({
+        scope,
+        // Related-Session summaries are explicitly historical context. Keep the
+        // bounded prose intact and label it as experience instead of dropping
+        // the whole paragraph because it mentions an old PR/tag/task state.
+        summary: entry.category === 'experience'
+          ? cleanMemoryPromptText(entry.summary)
+          : filterMemoryPromptTextForPrompt(entry.summary, userMsg),
+        ...(entry.category ? { category: entry.category } : {}),
       })),
       budget: this.budget.resident,
       seen: seenPromptText,

package/yeaft/tasks/manager.js

@@ -20,6 +20,7 @@ import { getRuntimePlatformInfo } from '../runtime-platform.js';
 const LOG_PREVIEW_BYTES = 4096;
 const SUB_AGENT_LOG_PREVIEW_BYTES = 1024 * 1024;
 const DEFAULT_CANCEL_ESCALATION_MS = 2000;
+const PROMPT_TASK_LIMIT = 5;
 
 function logPreviewBytesFor(task) {
   return task?.kind === 'sub_agent' ? SUB_AGENT_LOG_PREVIEW_BYTES : LOG_PREVIEW_BYTES;
@@ -54,9 +55,35 @@ function publicSnapshot(task) {
   };
 }
 
-function taskCommand(task) {
-  const command = task?.runtime?.command;
-  return typeof command === 'string' && command.trim() ? command.trim() : '';
+function taskKindLabel(kind, language) {
+  const zh = String(language || '').toLowerCase().startsWith('zh');
+  if (kind === 'sub_agent') return zh ? '子 Agent' : 'sub-agent';
+  if (kind === 'shell') return zh ? '后台命令' : 'background command';
+  return zh ? '后台任务' : 'background task';
+}
+
+function safeTaskName(task) {
+  const name = typeof task?.runtime?.name === 'string' ? task.runtime.name.trim() : '';
+  return /^[\p{L}\p{N}][\p{L}\p{N}._-]{0,63}$/u.test(name) ? name : '';
+}
+
+function promptTaskLabel(task, language) {
+  const name = task?.kind === 'sub_agent' ? safeTaskName(task) : '';
+  if (!name) return taskKindLabel(task?.kind, language);
+  return String(language || '').toLowerCase().startsWith('zh')
+    ? `子 Agent ${name}`
+    : `sub-agent ${name}`;
+}
+
+function taskStatusLabel(status, language) {
+  const zh = String(language || '').toLowerCase().startsWith('zh');
+  if (!zh) return String(status || 'running').replace(/_/g, ' ');
+  const labels = {
+    running: '运行中',
+    queued: '等待中',
+    cancelling: '正在取消',
+  };
+  return labels[status] || String(status || '运行中').replace(/_/g, ' ');
 }
 
 export class TaskManager {
@@ -358,17 +385,27 @@ export class TaskManager {
     return publicSnapshot(task);
   }
 
-  renderActiveTasksForPrompt(sessionId = null) {
+  renderActiveTasksForPrompt(sessionId = null, { language = 'en', limit = PROMPT_TASK_LIMIT } = {}) {
     const tasks = this.listActiveTasks(sessionId);
     if (tasks.length === 0) return '';
-    const lines = ['<active_tasks>'];
-    for (const task of tasks) {
-      const preview = (task.log?.preview || '').trim().split('\n').slice(-3).join(' | ');
-      const command = taskCommand(task);
-      const cancelRequestedAt = typeof task.runtime?.cancelRequestedAt === 'string' ? task.runtime.cancelRequestedAt : '';
-      lines.push(`- ${task.id} | ${task.kind} | ${task.status} | owner=${task.ownerVpId || 'unknown'} | title=${JSON.stringify(task.title)}${command ? ` | command=${JSON.stringify(command)}` : ''}${cancelRequestedAt ? ` | cancelRequestedAt=${JSON.stringify(cancelRequestedAt)}` : ''} | log=${task.log?.path || ''}${preview ? ` | tail=${JSON.stringify(preview)}` : ''}`);
+    const zh = String(language || '').toLowerCase().startsWith('zh');
+    const maxTasks = Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : PROMPT_TASK_LIMIT;
+    const visible = tasks.slice(0, maxTasks);
+    const lines = [zh ? '## 可能相关的任务' : '## Possibly Relevant Tasks'];
+    lines.push(zh
+      ? '以下任务仍在后台运行。需要进度或完整输出时使用任务工具查询；不要把它们当成记忆事实。'
+      : 'These tasks are still running in the background. Use the task tools for progress or full output; do not treat them as memory facts.');
+    for (const task of visible) {
+      const title = promptTaskLabel(task, language);
+      const detail = zh
+        ? `${taskKindLabel(task.kind, language)}，${taskStatusLabel(task.status, language)}`
+        : `${taskKindLabel(task.kind, language)}, ${taskStatusLabel(task.status, language)}`;
+      lines.push(`- ${title} (${detail})`);
+    }
+    if (tasks.length > visible.length) {
+      const remaining = tasks.length - visible.length;
+      lines.push(zh ? `- 另有 ${remaining} 个运行中任务，可用任务列表查看。` : `- ${remaining} more running task${remaining === 1 ? '' : 's'}; use the task list to inspect them.`);
     }
-    lines.push('</active_tasks>');
     return lines.join('\n');
   }
 }