@yeaft/webchat-agent 1.0.290 → 1.0.293

package/package.json

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

@@ -84,6 +84,8 @@ const AMS_ADJUST_TIMEOUT_MS = 30_000;
 /** Maximum silence while a visible turn waits for a result-producing task. */
 const DEFAULT_ASYNC_TASK_WAIT_TIMEOUT_MS = 120_000;
 
+const DEFAULT_MEMORY_RECALL_LIMIT = 8;
+
 // ─── LLM retry policy defaults ──────────────────────────────────
 // Hard-coded floor / ceiling for retry behaviour. The engine reads the
 // effective policy from `config.llmRetry` so users can dial these via
@@ -442,6 +444,47 @@ function isZhRuntimeLanguage(language) {
   return String(language || '').toLowerCase().startsWith('zh');
 }
 
+function resolveMemoryRecallLimit(config) {
+  const raw = config?.memoryRecallLimit ?? config?.dreamMemoryRecallLimit;
+  if (!Number.isFinite(raw) || raw <= 0) return DEFAULT_MEMORY_RECALL_LIMIT;
+  return Math.max(1, Math.floor(raw));
+}
+
+function loadedMemoryDebugEntries(snapshot) {
+  const snap = snapshot || {};
+  return [
+    ...loadedResidentDebugEntries(snap.resident || []),
+    ...loadedSegmentDebugEntries(snap.recent || [], 'recent'),
+    ...loadedSegmentDebugEntries(snap.onDemand || [], 'onDemand'),
+  ];
+}
+
+function loadedResidentDebugEntries(entries) {
+  return (entries || []).map((entry, index) => ({
+    id: `resident:${entry.scope || index}`,
+    layer: 'resident',
+    scope: entry.scope || null,
+    label: memoryScopeLabel(entry.scope || ''),
+    kind: 'summary',
+    score: null,
+    tags: [],
+    body: entry.summary || '',
+  })).filter(entry => entry.body);
+}
+
+function loadedSegmentDebugEntries(segments, layer) {
+  return (segments || []).map((seg, index) => ({
+    id: seg.id || `${layer}:${index}`,
+    layer,
+    scope: seg.scope || null,
+    label: memoryScopeLabel(seg.scope || ''),
+    kind: seg.kind || null,
+    score: typeof seg.score === 'number' ? seg.score : null,
+    tags: Array.isArray(seg.tags) ? seg.tags : [],
+    body: seg.body || '',
+  })).filter(entry => entry.body);
+}
+
 export class Engine {
   /** @type {import('./llm/adapter.js').LLMAdapter} */
   #adapter;
@@ -906,6 +949,7 @@ export class Engine {
    *   ownVpId: string|null,
    *   scopes: string[],
    *   snapshotBlock: string,
+ *   snapshot: import('./memory/ams.js').AmsSnapshot,
  *   residentEntries: Array<{scope:string, summary:string}>,
    * } | null}
    */
@@ -938,14 +982,15 @@ 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', args.userMsg || '');
+    const snapshot = ams.snapshot({ userMsg: args.userMsg || '' });
+    const snapshotBlock = this.#renderAmsSnapshot(snapshot, this.#config.language || 'en');
 
     const scopes = buildRelevantScopes({
       sessionId: args.sessionId,
       vpId: ownVpId,
     });
 
-    return { ams, sessionKey, ownVpId, scopes, snapshotBlock, residentEntries };
+    return { ams, sessionKey, ownVpId, scopes, snapshotBlock, snapshot, residentEntries };
   }
 
   /**
@@ -953,13 +998,11 @@ export class Engine {
    * injection. Mirrors the heading style of the existing memory blocks
    * so the LLM sees a consistent layout.
    *
-   * @param {import('./memory/ams.js').ActiveMemorySet} ams
+   * @param {import('./memory/ams.js').AmsSnapshot} snap
    * @param {string} [language]
-   * @param {string} [userMsg]
    * @returns {string}
    */
-  #renderAmsSnapshot(ams, language = 'en', userMsg = '') {
-    const snap = ams.snapshot({ userMsg });
+  #renderAmsSnapshot(snap, language = 'en') {
     if (!snap) return '';
     const parts = [];
     if (snap.resident.length === 0 && snap.recent.length === 0 && snap.onDemand.length === 0) {
@@ -1342,7 +1385,7 @@ export class Engine {
    * @returns {Promise<{ profile: string, entries: object[], formatted: string }|null>}
    */
   async #recallMemory(prompt, ctx = {}) {
-    const memory = { profile: '', entries: [], formatted: '' };
+    const memory = { profile: '', entries: [], formatted: '', meta: {} };
     if (!this.#memoryIndex) return memory;
     try {
       const result = runMemoryPreflow(this.#memoryIndex, {
@@ -1351,11 +1394,13 @@ export class Engine {
         chatId: ctx.chatId || this.#chatId,
         vpId: ctx.vpId,
         extraScopes: ctx.extraScopes,
+        pickLimit: resolveMemoryRecallLimit(this.#config),
         fallbackOnEmpty: true,
       });
       memory.profile = result.profile || '';
       memory.entries = result.entries || [];
       memory.formatted = result.formatted || '';
+      memory.meta = result.meta || {};
     } catch {
       // Fail soft — empty injection.
     }
@@ -2029,6 +2074,7 @@ export class Engine {
     if (amsContext && amsContext.snapshotBlock) {
       memoryInjection = amsContext.snapshotBlock;
     }
+    const loadedMemoryForDebug = loadedMemoryDebugEntries(amsContext?.snapshot);
 
     // Diagnostic payload for the Dream debug panel. The full AMS Resident
     // layer can include user and per-VP summaries, but the browser-facing
@@ -2282,19 +2328,20 @@ export class Engine {
       yield { type: 'skill_error', turnId: queryTurnId, skillName: explicitSkillName, message: skillResolutionError };
     }
 
-    // Surface memory recall to the debug panel right after turn_open.
-    // recallResult was loaded above; emit a structured `memory_used`
-    // event so the UI can show "loaded N segments" without parsing
-    // the legacy `recall` event (which only carried entryCount).
-    if (recallResult && Array.isArray(recallResult.entries) && recallResult.entries.length > 0) {
+    // Surface the exact memory that entered the prompt. This must be based on
+    // the AMS snapshot, not raw FTS candidates, otherwise debug can claim memory
+    // was loaded even when prompt cleanup, dedupe, or token budget dropped it.
+    if (loadedMemoryForDebug.length > 0) {
       yield {
         type: 'memory_used',
         turnId: queryTurnId,
-        loaded: recallResult.entries.map(e => ({
-          id: e && e.id || null,
-          score: e && typeof e.score === 'number' ? e.score : null,
-          kind: e && e.kind || null,
-        })),
+        loaded: loadedMemoryForDebug,
+        meta: {
+          recallLimit: resolveMemoryRecallLimit(this.#config),
+          recallCandidates: Number.isFinite(recallResult?.meta?.hitCount)
+            ? recallResult.meta.hitCount
+            : (recallResult && Array.isArray(recallResult.entries) ? recallResult.entries.length : 0),
+        },
       };
     }
 

package/yeaft/memory/preflow.js

@@ -19,6 +19,8 @@ import { extractKeywords } from './keywords.js';
 import { approxTokens } from './budget.js';
 import { isVpForeign } from './store.js';
 
+export const DEFAULT_PICK_LIMIT = 8;
+
 /**
  * @typedef {object} PreflowOptions
  * @property {string}        userMsg
@@ -27,6 +29,7 @@ import { isVpForeign } from './store.js';
  * @property {string[]}     [currentTags]        tags from the current group/feature context
  * @property {number}       [topK]               max FTS rows to fetch (default 50)
  * @property {number}       [budgetTokens]       onDemand budget (caller-supplied)
+ * @property {number}       [pickLimit]          max picked segments (default 8)
  */
 
 /**
@@ -54,6 +57,8 @@ export function runPreflow(index, opts) {
   const topK = Number.isFinite(opts.topK) && opts.topK > 0 ? opts.topK : 50;
   const budgetTokens = Number.isFinite(opts.budgetTokens) && opts.budgetTokens > 0
     ? opts.budgetTokens : Infinity;
+  const pickLimit = Number.isFinite(opts.pickLimit) && opts.pickLimit > 0
+    ? Math.floor(opts.pickLimit) : DEFAULT_PICK_LIMIT;
 
   const keywords = extractKeywords(userMsg);
   if (keywords.length === 0) {
@@ -80,7 +85,7 @@ export function runPreflow(index, opts) {
   let dropped = 0;
   for (const h of reranked) {
     const tk = approxTokens(h.body);
-    if (cost + tk <= budgetTokens) {
+    if (picked.length < pickLimit && cost + tk <= budgetTokens) {
       picked.push(toSegment(h));
       cost += tk;
     } else {
@@ -152,7 +157,7 @@ export function rerank(hits, ctx) {
       return { ...h, _score: score };
     })
     .sort((a, b) => a._score - b._score)
-    .map(({ _score, ...rest }) => rest);
+    .map(({ _score, ...rest }) => ({ ...rest, score: _score }));
 }
 
 function toSegment(h) {
@@ -163,6 +168,7 @@ function toSegment(h) {
     tags: h.tags,
     sourceMessages: h.sourceMessages,
     body: h.body,
+    score: typeof h.score === 'number' ? h.score : (typeof h.rank === 'number' ? h.rank : undefined),
     createdAt: h.createdAt,
     updatedAt: h.updatedAt,
   };

package/yeaft/projects/store.js

@@ -0,0 +1,152 @@
+import { existsSync, mkdirSync, readFileSync, renameSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { join } from 'node:path';
+import { writeAtomic } from '../storage/atomic.js';
+
+const PROJECTS_FILE = 'projects.json';
+const PROJECTS_VERSION = 1;
+
+export class ProjectStoreError extends Error {
+  constructor(code, message) {
+    super(message || code);
+    this.name = 'ProjectStoreError';
+    this.code = code;
+  }
+}
+
+function projectsPath(yeaftDir) {
+  return join(yeaftDir, PROJECTS_FILE);
+}
+
+function normalizeSessionIds(values) {
+  const out = [];
+  const seen = new Set();
+  for (const value of Array.isArray(values) ? values : []) {
+    const id = typeof value === 'string' ? value.trim() : '';
+    if (!id || seen.has(id)) continue;
+    seen.add(id);
+    out.push(id);
+  }
+  return out;
+}
+
+function normalizeProject(row, index = 0) {
+  if (!row || typeof row !== 'object' || typeof row.id !== 'string' || !row.id) return null;
+  const name = typeof row.name === 'string' ? row.name.trim() : '';
+  if (!name) return null;
+  return {
+    id: row.id,
+    name,
+    sessionIds: normalizeSessionIds(row.sessionIds),
+    sortOrder: Number.isFinite(row.sortOrder) ? row.sortOrder : index,
+    createdAt: typeof row.createdAt === 'string' ? row.createdAt : '',
+    updatedAt: typeof row.updatedAt === 'string' ? row.updatedAt : '',
+  };
+}
+
+export function loadProjects(yeaftDir) {
+  if (!yeaftDir || !existsSync(projectsPath(yeaftDir))) return [];
+  try {
+    const parsed = JSON.parse(readFileSync(projectsPath(yeaftDir), 'utf8'));
+    const rows = Array.isArray(parsed?.projects) ? parsed.projects : [];
+    return rows.map(normalizeProject).filter(Boolean).sort((a, b) => a.sortOrder - b.sortOrder);
+  } catch {
+    const path = projectsPath(yeaftDir);
+    try { renameSync(path, `${path}.corrupt-${Date.now()}`); } catch { /* keep the unreadable file if quarantine fails */ }
+    return [];
+  }
+}
+
+function saveProjects(yeaftDir, projects) {
+  if (!yeaftDir) throw new ProjectStoreError('missing_root', 'Yeaft directory is required');
+  mkdirSync(yeaftDir, { recursive: true });
+  const now = new Date().toISOString();
+  const normalized = projects.map(normalizeProject).filter(Boolean).map((project, index) => ({
+    ...project,
+    sortOrder: index,
+    updatedAt: project.updatedAt || now,
+  }));
+  writeAtomic(projectsPath(yeaftDir), `${JSON.stringify({
+    version: PROJECTS_VERSION,
+    updatedAt: now,
+    projects: normalized,
+  }, null, 2)}\n`);
+  return normalized;
+}
+
+function requireName(value) {
+  const name = typeof value === 'string' ? value.trim() : '';
+  if (!name) throw new ProjectStoreError('invalid_name', 'Project name is required');
+  return name.slice(0, 120);
+}
+
+function requireProject(projects, projectId) {
+  const project = projects.find(row => row.id === projectId);
+  if (!project) throw new ProjectStoreError('not_found', 'Project not found');
+  return project;
+}
+
+export function createProject(yeaftDir, name) {
+  const projects = loadProjects(yeaftDir);
+  const now = new Date().toISOString();
+  const project = {
+    id: `project-${randomUUID().slice(0, 8)}`,
+    name: requireName(name),
+    sessionIds: [],
+    sortOrder: projects.length,
+    createdAt: now,
+    updatedAt: now,
+  };
+  saveProjects(yeaftDir, [...projects, project]);
+  return project;
+}
+
+export function renameProject(yeaftDir, projectId, name) {
+  const projects = loadProjects(yeaftDir);
+  const project = requireProject(projects, projectId);
+  project.name = requireName(name);
+  project.updatedAt = new Date().toISOString();
+  saveProjects(yeaftDir, projects);
+  return project;
+}
+
+export function deleteProject(yeaftDir, projectId) {
+  const projects = loadProjects(yeaftDir);
+  requireProject(projects, projectId);
+  saveProjects(yeaftDir, projects.filter(row => row.id !== projectId));
+  return { projectId };
+}
+
+export function moveSessionToProject(yeaftDir, sessionId, projectId = null) {
+  const id = typeof sessionId === 'string' ? sessionId.trim() : '';
+  if (!id) throw new ProjectStoreError('invalid_session_id', 'Session id is required');
+  const projects = loadProjects(yeaftDir);
+  const target = projectId ? requireProject(projects, projectId) : null;
+  for (const project of projects) {
+    project.sessionIds = project.sessionIds.filter(value => value !== id);
+  }
+  if (target) target.sessionIds.push(id);
+  saveProjects(yeaftDir, projects);
+  return { sessionId: id, projectId: target?.id || null };
+}
+
+export function removeSessionFromProjects(yeaftDir, sessionId) {
+  const projects = loadProjects(yeaftDir);
+  let changed = false;
+  for (const project of projects) {
+    const next = project.sessionIds.filter(id => id !== sessionId);
+    if (next.length !== project.sessionIds.length) changed = true;
+    project.sessionIds = next;
+  }
+  if (changed) saveProjects(yeaftDir, projects);
+  return changed;
+}
+
+export function findProjectForSession(yeaftDir, sessionId) {
+  return loadProjects(yeaftDir).find(project => project.sessionIds.includes(sessionId)) || null;
+}
+
+export function sharedSessionIdsForProject(yeaftDir, sessionId) {
+  const project = findProjectForSession(yeaftDir, sessionId);
+  return project ? project.sessionIds.filter(id => id !== sessionId) : [];
+}

package/yeaft/sessions/pre-flow.js

@@ -259,6 +259,7 @@ export function formatPickedForInjection(picked) {
  * @property {string[]}       [currentTags]        Contextual tags for rerank
  * @property {number}         [topK]               Max FTS rows fetched (default 50)
  * @property {number}         [budgetTokens]       Token budget for picked segments
+ * @property {number}         [pickLimit]          Max picked segments (default 8)
  * @property {boolean}        [fallbackOnEmpty]    Include bounded recent scoped segments when FTS has no hits
  * @property {number}         [fallbackPerScope]   Max fallback segments per scope
  */
@@ -353,6 +354,7 @@ export function runMemoryPreflow(index, opts) {
     currentTags: opts.currentTags || [],
     topK: opts.topK,
     budgetTokens: opts.budgetTokens,
+    pickLimit: opts.pickLimit,
   });
 
   let fallbackUsed = false;
@@ -362,6 +364,7 @@ export function runMemoryPreflow(index, opts) {
       ownVpId: opts.vpId || null,
       budgetTokens: opts.budgetTokens,
       perScope: opts.fallbackPerScope,
+      pickLimit: opts.pickLimit,
     });
     if (fallback.length > 0) {
       fallbackUsed = true;
@@ -400,6 +403,7 @@ function fallbackScopedSegments(index, opts) {
   const scopes = prioritizeFallbackScopes(filterScopes(opts.relevantScopes || [], opts.ownVpId || null));
   const perScope = Number.isFinite(opts.perScope) && opts.perScope > 0 ? Math.floor(opts.perScope) : 2;
   const budgetTokens = Number.isFinite(opts.budgetTokens) && opts.budgetTokens > 0 ? opts.budgetTokens : 1200;
+  const pickLimit = Number.isFinite(opts.pickLimit) && opts.pickLimit > 0 ? Math.floor(opts.pickLimit) : 8;
   const buckets = [];
   for (const scope of scopes) {
     let segs = [];
@@ -419,6 +423,7 @@ function fallbackScopedSegments(index, opts) {
       if (!seg) continue;
       const tk = approxTokens(seg.body || '');
       if (tk <= 0 || cost + tk > budgetTokens) continue;
+      if (out.length >= pickLimit) return out;
       out.push(seg);
       cost += tk;
     }

package/yeaft/web-bridge.js

@@ -64,6 +64,17 @@ import { persistYeaftAttachments, attachmentsForPersistence, persistedAttachment
 import { normalizeSessionMessageQuote, sessionMessageQuotePrompt } from './session-message-quote.js';
 import { ConversationStore, parseSeqFromId, projectVisibleSessionMessages } from './conversation/persist.js';
 import { isHiddenConversationRow, isVisibleConversationRow } from './conversation/internal-control.js';
+import {
+  ProjectStoreError,
+  createProject,
+  deleteProject,
+  loadProjects,
+  moveSessionToProject,
+  removeSessionFromProjects,
+  renameProject,
+} from './projects/store.js';
+import { readSummary as readScopeSummary } from './memory/store.js';
+import { estimateTokens } from './dream/segment.js';
 import { imageMetadataForPersistence } from './image-assets.js';
 import { sliceLastNTurns } from './turn-utils.js';
 import { pairSanitize } from './pair-sanitize.js';
@@ -3008,6 +3019,54 @@ function decorateSessionsWithRuntimeState(sessions) {
   });
 }
 
+const PROJECT_CONTEXT_MAX_SIBLINGS = 8;
+const PROJECT_CONTEXT_MAX_TOKENS = 4096;
+const PROJECT_CONTEXT_TRUNCATION_NOTICE = '\n[Summary truncated to Project context budget]';
+
+async function sharedProjectContext(yeaftDir, sessionId, options = {}) {
+  const project = loadProjects(yeaftDir).find(row => row.sessionIds.includes(sessionId));
+  if (!project) return '';
+  const memoryRoot = join(yeaftDir, 'memory');
+  const language = options.language || 'en';
+  const configuredBudget = Number.isFinite(options.tokenBudget) && options.tokenBudget > 0
+    ? options.tokenBudget
+    : PROJECT_CONTEXT_MAX_TOKENS;
+  const tokenBudget = Math.min(configuredBudget, PROJECT_CONTEXT_MAX_TOKENS);
+  let context = '';
+  const siblingIds = project.sessionIds
+    .filter(id => id !== sessionId)
+    .slice(0, PROJECT_CONTEXT_MAX_SIBLINGS);
+  for (const siblingId of siblingIds) {
+    const summary = await readScopeSummary(
+      { kind: 'session', id: siblingId },
+      { root: memoryRoot, language },
+    ).catch(() => '');
+    if (!summary) continue;
+    const separator = context ? '\n\n' : '';
+    const header = `[Session ${siblingId}]\n`;
+    const fullContext = `${context}${separator}${header}${summary}`;
+    if (estimateTokens(fullContext) <= tokenBudget) {
+      context = fullContext;
+      continue;
+    }
+
+    const prefix = `${context}${separator}${header}`;
+    if (estimateTokens(`${prefix}${PROJECT_CONTEXT_TRUNCATION_NOTICE}`) <= tokenBudget) {
+      let low = 0;
+      let high = summary.length;
+      while (low < high) {
+        const middle = Math.ceil((low + high) / 2);
+        const candidate = `${prefix}${summary.slice(0, middle)}${PROJECT_CONTEXT_TRUNCATION_NOTICE}`;
+        if (estimateTokens(candidate) <= tokenBudget) low = middle;
+        else high = middle - 1;
+      }
+      context = `${prefix}${summary.slice(0, low)}${PROJECT_CONTEXT_TRUNCATION_NOTICE}`;
+    }
+    break;
+  }
+  return context;
+}
+
 function sendSessionCrudResult(payload) {
   const next = payload && payload.ok && Array.isArray(payload.sessions)
     ? { ...payload, sessions: decorateSessionsWithRuntimeState(payload.sessions) }
@@ -3020,7 +3079,7 @@ function sendSessionSnapshotBroadcast() {
     const yeaftDir = ctx.CONFIG?.yeaftDir;
     if (!yeaftDir) return;
     const sessions = decorateSessionsWithRuntimeState(snapshotSessions(yeaftDir));
-    sendSessionEvent({ type: 'session_list_updated', sessions });
+    sendSessionEvent({ type: 'session_list_updated', sessions, projects: loadProjects(yeaftDir) });
   } catch (err) {
     console.warn('[Yeaft] sendSessionSnapshotBroadcast failed:', err?.message || err);
   }
@@ -3059,6 +3118,7 @@ function sessionErrorPayload(err) {
   let code = 'unknown';
   if (err instanceof SessionCrudError) code = err.code;
   else if (err instanceof SessionConfigError) code = err.code;
+  else if (err instanceof ProjectStoreError) code = err.code;
   return {
     code,
     sessionId: err && err.sessionId,
@@ -3071,12 +3131,49 @@ export function handleYeaftListSessions(msg) {
   try {
     const yeaftDir = ctx.CONFIG?.yeaftDir;
     const groups = snapshotSessions(yeaftDir);
-    sendSessionCrudResult({ op: 'list', requestId, ok: true, sessions: groups });
+    sendSessionCrudResult({ op: 'list', requestId, ok: true, sessions: groups, projects: loadProjects(yeaftDir) });
   } catch (err) {
     sendSessionCrudResult({ op: 'list', requestId, ok: false, error: sessionErrorPayload(err) });
   }
 }
 
+export function handleYeaftProjectMutation(msg) {
+  const requestId = msg && msg.requestId;
+  const op = msg && msg.op;
+  try {
+    const yeaftDir = ctx.CONFIG?.yeaftDir;
+    let result = null;
+    if (op === 'create') result = createProject(yeaftDir, msg.name);
+    else if (op === 'rename') result = renameProject(yeaftDir, msg.projectId, msg.name);
+    else if (op === 'delete') result = deleteProject(yeaftDir, msg.projectId);
+    else if (op === 'move_session') {
+      if (!snapshotSessions(yeaftDir).some(row => row.id === msg.sessionId)) {
+        throw new ProjectStoreError('session_not_found', 'Session not found');
+      }
+      result = moveSessionToProject(yeaftDir, msg.sessionId, msg.projectId || null);
+    } else {
+      throw new ProjectStoreError('invalid_op', 'Unknown Project operation');
+    }
+    sendSessionEvent({
+      type: 'project_mutation_result',
+      requestId,
+      op,
+      ok: true,
+      result,
+      projects: loadProjects(yeaftDir),
+    }, { requestId });
+    sendSessionSnapshotBroadcast();
+  } catch (err) {
+    sendSessionEvent({
+      type: 'project_mutation_result',
+      requestId,
+      op,
+      ok: false,
+      error: sessionErrorPayload(err),
+    }, { requestId });
+  }
+}
+
 export function handleYeaftCreateSession(msg) {
   const requestId = msg && msg.requestId;
   const payload = (msg && msg.payload) || {};
@@ -3260,6 +3357,7 @@ export function handleYeaftDeleteSession(msg) {
   try {
     const yeaftDir = ctx.CONFIG?.yeaftDir;
     const result = deleteSession(yeaftDir, sessionId);
+    removeSessionFromProjects(yeaftDir, sessionId);
     ctx.assetOutbox?.removeSession(sessionId);
     // Cascade: remove every persisted message stamped with this group id.
     // Hard delete (per user spec): no soft-archive, the bytes are gone.
@@ -3978,6 +4076,7 @@ function handleEngineEvent(event, hctx) {
         type: 'memory_used',
         turnId: event.turnId,
         loaded: event.loaded || [],
+        meta: event.meta || null,
       }, envelope);
       break;
 
@@ -5054,6 +5153,18 @@ async function runVpTurn({ prompt, promptParts = null, sessionId, vpId, threadId
         envelope: inboundEnvelope,
         threadId,
       });
+      if (queryOpts) {
+        const projectContext = await sharedProjectContext(ctx.CONFIG?.yeaftDir, sessionId, {
+          language: session?.config?.language,
+          tokenBudget: Math.max(512, Math.floor((session?.config?.messageTokenBudget || 32768) / 8)),
+        });
+        if (projectContext) {
+          const sharedBlock = `[Project Shared Context]\nRead-only memory summaries from sibling Sessions in the same Project. Preserve each source Session identity.\n\n${projectContext}`;
+          queryOpts.sessionAnnouncement = queryOpts.sessionAnnouncement
+            ? `${queryOpts.sessionAnnouncement}\n\n${sharedBlock}`
+            : sharedBlock;
+        }
+      }
       let turnSessionMeta = null;
       try { turnSessionMeta = sessionCoordinator?.group?.getMeta?.() || null; } catch { turnSessionMeta = null; }
       const projectRuntime = getProjectRuntimeForTurn(turnSessionMeta);
@@ -7171,6 +7282,8 @@ export async function handleYeaftMcpReload(msg = {}) {
 }
 
 export const __testHooks = {
+  loadProjects,
+  sharedProjectContext,
   loadVisibleGroupHistoryPage,
   projectVisibleHistoryChunkMessages,
   persistInboundMessageOnceByMsgId,