@yeaft/webchat-agent 0.1.965 → 0.1.966

package/package.json

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

package/yeaft/dream/runner.js

@@ -10,17 +10,17 @@
  *   for each session with newCount ≥ MIN_NEW_PER_GROUP (auto)
  *                    or > 0 (manual)
  *                    or prior messages in a scoped manual session rerun:
- *       loadDiff()                     via opts.loadGroupDiff(sessionId, sinceId)
+ *       loadDiff()                     via opts.loadSessionDiff(sessionId, sinceId)
  *       applyOverlap()                 via opts.loadOverlapPreamble(...)
  *       segment()                      segmentDiff(...)
- *       triageGroupSegments()          → group-local actions[]
+ *       triage segments                → session-local actions[]
  *
  *   mergeByTarget()                    → per-target actions
  *   for each merged target:
  *       applyMergedTarget()            (snapshot + UPDATE/CREATE + atomic write)
  *
  *   bookkeep:
- *     for each processed group:
+ *     for each processed session:
  *       session .dream-state ←
  *         { lastDreamMessageId: tail of real diff,
  *           lastDreamAt: nowIso,
@@ -50,6 +50,7 @@ import { segmentDiff, truncateMessage, estimateMessagesTokens } from './segment.
 import { triageGroupSegments } from './triage.js';
 import { mergeByTarget } from './merge.js';
 import { applyMergedTarget } from './apply.js';
+import { extractAndWriteMemorySegments } from './segment-extract.js';
 import { tsForBackup, pruneOldSnapshots } from './snapshot.js';
 
 /**
@@ -58,12 +59,14 @@ import { tsForBackup, pruneOldSnapshots } from './snapshot.js';
  * @property {boolean} [manual=false]         — manual trigger overrides newCount<20 skip
  * @property {string[]} [scopeFilter]         — optional: only dream these targets; scoped manual session triggers rerun the current session when there are prior messages but no new cursor delta ('*' allowed)
  * @property {(req: {pass:string, prompt:string, system:string}) => Promise<string>} llm
- * @property {() => Promise<Array<string>>} listSessions   — return all session ids (incl. '_no-group')
- * @property {(sessionId: string) => Promise<number>} countMessages   — total message count for a group
- * @property {(sessionId: string, sinceMessageId: string|null) => Promise<Array<object>>} loadGroupDiff
+ * @property {() => Promise<Array<string>>} listSessions   — return all session ids (incl. '_no-session')
+ * @property {(sessionId: string) => Promise<number>} countMessages   — total message count for a session
+ * @property {(sessionId: string, sinceMessageId: string|null) => Promise<Array<object>>} [loadSessionDiff]
+ * @property {(sessionId: string, sinceMessageId: string|null) => Promise<Array<object>>} [loadGroupDiff] — legacy alias for loadSessionDiff
  * @property {(sessionId: string, beforeMessageId: string|null, count: number) => Promise<Array<object>>} loadOverlapPreamble
  * @property {() => Promise<Array<{path:string, summary:string}>>} [listTopicSummaries]
  * @property {(target: string) => Promise<Array<{path:string, summary:string}>>} [siblingTopicsFor]
+ * @property {import('../memory/index-db.js').SegmentIndex|null} [segmentIndex] — optional derived FTS segment index to sync after segment writes
  * @property {(event: object) => void} [onProgress]
  * @property {object} [limits]                — override DEFAULT_LIMITS
  * @property {() => string} [nowIso]
@@ -86,7 +89,7 @@ export async function runDream(opts) {
 
   onProgress({ phase: 'start', manual: !!opts.manual, ts });
 
-  // 1. enumerate groups
+  // 1. enumerate sessions
   const sessionIds = await safeCall(opts.listSessions, []);
   const filter = Array.isArray(opts.scopeFilter) ? new Set(opts.scopeFilter) : null;
   const sessionFilter = deriveSessionFilter(filter);
@@ -135,7 +138,8 @@ export async function runDream(opts) {
 
     onProgress({ phase: 'load-diff', sessionId });
     const diffCursor = rerunScopedManual ? null : state.lastDreamMessageId;
-    const diffNew = await safeCall(() => opts.loadGroupDiff(sessionId, diffCursor), []);
+    const loadDiff = opts.loadSessionDiff || opts.loadGroupDiff;
+    const diffNew = await safeCall(() => loadDiff(sessionId, diffCursor), []);
     if (!diffNew || diffNew.length === 0) {
       sessionsReport.push({ sessionId, new: newCount, status: 'skipped', reason: 'empty-diff' });
       continue;
@@ -233,9 +237,42 @@ export async function runDream(opts) {
     }
   }
 
-  // 5. bookkeep — only when at least one apply for this group's actions
+  // 5. extract atomic H2 memory segments. The apply step above keeps the
+  // coarse summary layer (`summary.md`); this step keeps bounded, evidence-
+  // backed current details in segment-formatted `memory.md`.
+  const segmentReports = [];
+  for (const triage of sessionTriages) {
+    const appliedTargets = new Set(targetsReport.filter(r => r.status === 'done').map(r => r.target));
+    const targets = triage.actions.map(a => a.scope).filter(scope => appliedTargets.has(scope));
+    if (targets.length === 0) continue;
+    try {
+      onProgress({ phase: 'extract-segments', sessionId: triage.sessionId, status: 'running', targets: targets.length });
+      const r = await extractAndWriteMemorySegments({
+        root: opts.root,
+        sessionId: triage.sessionId,
+        messages: triage.diff,
+        targets,
+        llm: opts.llm,
+        language: opts.language,
+        nowIso: opts.nowIso || (() => nowIso),
+        segmentIndex: opts.segmentIndex || null,
+      });
+      segmentReports.push({ sessionId: triage.sessionId, status: 'done', ...r });
+      onProgress({ phase: 'extract-segments', sessionId: triage.sessionId, status: 'done', ...r });
+    } catch (err) {
+      segmentReports.push({ sessionId: triage.sessionId, status: 'error', error: err.message });
+      onProgress({ phase: 'extract-segments', sessionId: triage.sessionId, status: 'error', error: err.message });
+      await writeDreamError(opts.root, `sessions/${triage.sessionId}`, {
+        phase: 'extract-segments',
+        message: err.message,
+        stack: err.stack,
+      });
+    }
+  }
+
+  // 6. bookkeep — only when at least one apply for this session's actions
   // succeeded. We use a permissive policy: if ANY merged-target apply
-  // succeeded for a group's contributed actions, advance that group's
+  // succeeded for a session's contributed actions, advance that session's
   // cursor. (If everything errored, we keep the cursor so next run
   // retries.)
   const successfulTargets = new Set(targetsReport.filter(r => r.status === 'done').map(r => r.target));
@@ -271,6 +308,7 @@ export async function runDream(opts) {
     durationMs: duration,
     sessions: sessionsReport,
     targets: targetsReport,
+    memorySegments: segmentReports,
     backups: pruned,
     ts,
   };

package/yeaft/dream/segment-extract.js

@@ -0,0 +1,239 @@
+/**
+ * dream/segment-extract.js.
+ *
+ * Minimal H2 Dream bridge: extract atomic memory segments for the session
+ * scopes touched by a Dream pass and persist them through memory/segment-store.
+ * The existing apply path still maintains summary.md as the coarse layer.
+ */
+
+import { readScope, writeScope } from '../memory/segment-store.js';
+import { syncScope } from '../memory/segment-sync.js';
+import { makeSegment } from '../memory/segment.js';
+import { render, extractTemplateForScope } from './prompts/index.js';
+import { parseJsonSafe } from './triage.js';
+
+const MAX_TARGETS = 24;
+const MAX_MESSAGES = 80;
+const MAX_BODY_CHARS = 1200;
+const MAX_SEGMENTS_PER_SCOPE = 64;
+const RECENT_MESSAGE_COUNT = 8;
+const VALID_KINDS = new Set(['fact', 'preference', 'decision', 'lesson', 'relation', 'goal', 'context']);
+
+/**
+ * @param {{
+ *   root: string,
+ *   sessionId: string,
+ *   messages: Array<object>,
+ *   targets?: string[],
+ *   llm: Function,
+ *   language?: string,
+ *   nowIso?: Function,
+ *   segmentIndex?: import('../memory/index-db.js').SegmentIndex|null,
+ * }} opts
+ */
+export async function extractAndWriteMemorySegments(opts) {
+  if (!opts || !opts.root) throw new Error('extractAndWriteMemorySegments: root required');
+  if (!opts.sessionId) throw new Error('extractAndWriteMemorySegments: sessionId required');
+  if (typeof opts.llm !== 'function') throw new Error('extractAndWriteMemorySegments: llm required');
+
+  const messages = normalizeMessages(opts.messages || []);
+  if (messages.length === 0) return { scopes: 0, segments: 0, errors: [] };
+
+  const targetScopes = normalizeTargetScopes(opts.sessionId, opts.targets || []);
+  const now = opts.nowIso ? opts.nowIso() : new Date().toISOString();
+  let segmentCount = 0;
+  let scopeCount = 0;
+  const errors = [];
+
+  for (const scope of targetScopes.slice(0, MAX_TARGETS)) {
+    let extracted = [];
+    try {
+      extracted = await extractScopeSegments({
+        scope,
+        sessionId: opts.sessionId,
+        messages,
+        llm: opts.llm,
+        language: opts.language,
+        now,
+      });
+    } catch (err) {
+      errors.push({ scope, error: err.message, rawSnippet: err.rawSnippet || '' });
+    }
+
+    const recent = scope === `sessions/${opts.sessionId}`
+      ? [buildRecentSegment({ scope, messages, now })]
+      : [];
+    if (extracted.length === 0 && recent.length === 0) continue;
+
+    const nextSegments = mergeSegments(readScope(opts.root, scope), [...extracted, ...recent]);
+    writeScope(opts.root, scope, nextSegments);
+    if (opts.segmentIndex) syncScope(opts.root, opts.segmentIndex, scope);
+    segmentCount += extracted.length + recent.length;
+    scopeCount += 1;
+  }
+
+  return { scopes: scopeCount, segments: segmentCount, errors };
+}
+
+async function extractScopeSegments({ scope, sessionId, messages, llm, language, now }) {
+  const template = extractTemplateForScope(scope);
+  const base = render(template, templateVarsForScope(scope, sessionId), { language });
+  const prompt = `${base}\n\nTarget scope: ${scope}\n\nConversation diff, oldest first:\n${renderMessages(messages)}\n\nReturn only the JSON array. Do not wrap it in Markdown.`;
+  const firstRaw = await llm({ pass: 'extract-segments', prompt, system: extractSystem(language) });
+  const firstParsed = parseJsonSafe(firstRaw);
+  if (Array.isArray(firstParsed)) {
+    return firstParsed
+      .map(item => normalizeExtractedSegment({ item, scope, now }))
+      .filter(Boolean);
+  }
+
+  const retryPrompt = `${prompt}\n\nYour previous output was malformed JSON. Previous output snippet:\n${rawSnippet(firstRaw)}\n\nRetry now. Return only a strict JSON array.`;
+  const retryRaw = await llm({ pass: 'extract-segments-retry', prompt: retryPrompt, system: extractSystem(language) });
+  const retryParsed = parseJsonSafe(retryRaw);
+  if (!Array.isArray(retryParsed)) {
+    const err = new Error(`extract-segments: malformed JSON for ${scope}`);
+    err.rawSnippet = rawSnippet(retryRaw || firstRaw);
+    throw err;
+  }
+
+  return retryParsed
+    .map(item => normalizeExtractedSegment({ item, scope, now }))
+    .filter(Boolean);
+}
+
+function templateVarsForScope(scope, sessionId) {
+  const vars = { sessionId, vpId: '', topicId: '' };
+  const vpMatch = /^sessions\/[^/]+\/vp\/(.+)$/.exec(scope);
+  if (vpMatch) vars.vpId = vpMatch[1];
+  const topicMatch = /^sessions\/[^/]+\/topic\/(.+)$/.exec(scope);
+  if (topicMatch) vars.topicId = topicMatch[1];
+  return vars;
+}
+
+function normalizeTargetScopes(sessionId, targets) {
+  const out = new Set(['user', `sessions/${sessionId}`, `sessions/${sessionId}/user`]);
+  for (const target of targets) {
+    if (typeof target !== 'string') continue;
+    const clean = target.trim();
+    if (!clean) continue;
+    if (clean === 'user' || clean.startsWith(`sessions/${sessionId}/`) || clean === `sessions/${sessionId}`) {
+      out.add(clean);
+    }
+  }
+  return [...out];
+}
+
+function normalizeMessages(messages) {
+  return messages
+    .filter(m => m && typeof m === 'object')
+    .slice(-MAX_MESSAGES)
+    .map((m, index) => ({
+      id: String(m.id || m.messageId || `dream_msg_${index}`),
+      role: String(m.role || m.type || 'unknown'),
+      vpId: typeof m.vpId === 'string' ? m.vpId : '',
+      body: String(m.body || m.content || '').slice(0, MAX_BODY_CHARS),
+      kind: String(m.kind || ''),
+    }))
+    .filter(m => m.body.trim());
+}
+
+function renderMessages(messages) {
+  return JSON.stringify(messages.map(m => ({
+    id: m.id,
+    role: m.role,
+    vpId: m.vpId || undefined,
+    kind: m.kind || undefined,
+    body: m.body,
+  })), null, 2);
+}
+
+function normalizeExtractedSegment({ item, scope, now }) {
+  if (!item || typeof item !== 'object') return null;
+  const body = String(item.body || item.content || item.summary || '').trim();
+  if (!body) return null;
+  const kind = VALID_KINDS.has(String(item.kind || '')) ? String(item.kind) : 'context';
+  const tags = Array.isArray(item.tags) ? item.tags.map(t => String(t).trim()).filter(Boolean) : [];
+  const sourceMessages = Array.isArray(item.sourceMessages)
+    ? item.sourceMessages.map(id => String(id).trim()).filter(Boolean)
+    : [];
+  return makeSegment({
+    scope,
+    kind,
+    tags: [...new Set(tags)],
+    sourceMessages: [...new Set(sourceMessages)],
+    createdAt: typeof item.createdAt === 'string' ? item.createdAt : now,
+    updatedAt: now,
+    body,
+  });
+}
+
+function buildRecentSegment({ scope, messages, now }) {
+  const recentMessages = messages.slice(-RECENT_MESSAGE_COUNT);
+  const body = [
+    'Recent session details from the latest Dream pass:',
+    ...recentMessages.map(m => `- ${m.id} ${m.role}${m.vpId ? `/${m.vpId}` : ''}: ${oneLine(m.body)}`),
+  ].join('\n');
+  return makeSegment({
+    scope,
+    kind: 'context',
+    tags: ['recent', 'current'],
+    sourceMessages: recentMessages.map(m => m.id),
+    createdAt: now,
+    updatedAt: now,
+    body,
+  });
+}
+
+function mergeSegments(existing, incoming) {
+  const incomingRecent = incoming.filter(isRecentSegment).slice(-1);
+  const incomingPermanent = incoming.filter(seg => !isRecentSegment(seg));
+  const byKey = new Map();
+
+  for (const seg of existing) {
+    if (isRecentSegment(seg)) continue;
+    byKey.set(segmentMergeKey(seg), seg);
+  }
+  for (const seg of incomingPermanent) {
+    byKey.set(segmentMergeKey(seg), seg);
+  }
+
+  const permanent = [...byKey.values()]
+    .sort((a, b) => segmentTime(b).localeCompare(segmentTime(a)))
+    .slice(0, MAX_SEGMENTS_PER_SCOPE)
+    .sort((a, b) => segmentTime(a).localeCompare(segmentTime(b)) || String(a.id).localeCompare(String(b.id)));
+
+  return [...permanent, ...incomingRecent];
+}
+
+function segmentMergeKey(seg) {
+  const sources = Array.isArray(seg.sourceMessages)
+    ? seg.sourceMessages.map(String).filter(Boolean).sort().join(',')
+    : '';
+  const tagFamily = Array.isArray(seg.tags)
+    ? seg.tags.map(String).filter(t => t && t !== 'recent' && t !== 'current').sort().join(',')
+    : '';
+  if (sources) return `src:${seg.kind || 'context'}:${tagFamily}:${sources}`;
+  return `id:${seg.id}`;
+}
+
+function isRecentSegment(seg) {
+  return Array.isArray(seg.tags) && seg.tags.includes('recent');
+}
+
+function segmentTime(seg) {
+  return String(seg.updatedAt || seg.createdAt || '');
+}
+
+function rawSnippet(raw) {
+  return String(raw || '').replace(/\s+/g, ' ').trim().slice(0, 500);
+}
+
+function oneLine(text) {
+  return String(text || '').replace(/\s+/g, ' ').trim().slice(0, 280);
+}
+
+function extractSystem(language) {
+  return String(language || '').toLowerCase().startsWith('zh')
+    ? '你是 Yeaft Dream 记忆抽取器。只输出严格 JSON 数组，不要 Markdown。保留具体事实、决策、偏好、当前状态和证据 message id。'
+    : 'You are the Yeaft Dream memory extractor. Return only a strict JSON array, no Markdown. Preserve concrete facts, decisions, preferences, current status, and evidence message ids.';
+}

package/yeaft/dream/session-wiring.js

@@ -61,10 +61,26 @@ export function buildRunDreamOpts(session, onProgress) {
   // Legacy disk fallback for pre-session transcript directories. New writes and
   // Dream's primary source use `sessions/<sessionId>/conversation`.
   const legacySessionConversationsRoot = join(yeaftDir, 'groups');
+  const loadSessionDiff = async (sessionId, sinceId) => {
+    try {
+      const messages = loadSessionConversationMessages([sessionConversationsRoot, legacySessionConversationsRoot], sessionId);
+      const out = [];
+      let started = !sinceId;
+      for (const m of messages) {
+        if (!started) {
+          if (m.id === sinceId) started = true;
+          continue;
+        }
+        out.push(translateSessionConversationMessage(m));
+      }
+      return out;
+    } catch { return []; }
+  };
 
   return {
     root: memoryRoot,
     language: session.config?.language || 'en',
+    segmentIndex: session.memoryIndex || null,
     llm: makeLlm(session),
     listSessions: async () => {
       try { return listConversationSessions([sessionConversationsRoot, legacySessionConversationsRoot]); }
@@ -74,21 +90,9 @@ export function buildRunDreamOpts(session, onProgress) {
       try { return loadSessionConversationMessages([sessionConversationsRoot, legacySessionConversationsRoot], sessionId).length; }
       catch { return 0; }
     },
-    loadGroupDiff: async (sessionId, sinceId) => {
-      try {
-        const messages = loadSessionConversationMessages([sessionConversationsRoot, legacySessionConversationsRoot], sessionId);
-        const out = [];
-        let started = !sinceId;
-        for (const m of messages) {
-          if (!started) {
-            if (m.id === sinceId) started = true;
-            continue;
-          }
-          out.push(translateSessionConversationMessage(m));
-        }
-        return out;
-      } catch { return []; }
-    },
+    loadSessionDiff,
+    /** Legacy alias for older Dream runner callers; primary name is loadSessionDiff. */
+    loadGroupDiff: loadSessionDiff,
     loadOverlapPreamble: async (sessionId, beforeId, n) => {
       try {
         const messages = loadSessionConversationMessages([sessionConversationsRoot, legacySessionConversationsRoot], sessionId);

package/yeaft/engine.js

@@ -18,7 +18,8 @@
  */
 
 import { randomUUID } from 'crypto';
-import { resolve as resolvePath } from 'path';
+import { promises as fsp } from 'fs';
+import { join, resolve as resolvePath } from 'path';
 import { buildSystemPrompt, buildWorkerPrompt } from './prompts.js';
 import { LLMContextError, LLMAbortError } from './llm/adapter.js';
 import { runMemoryPreflow, buildRelevantScopes } from './sessions/pre-flow.js';
@@ -596,6 +597,14 @@ export class Engine {
     return { user: user || '', session: session || '', vp: vp || '' };
   }
 
+  async #loadSessionTopicLabels(sessionId, limit = 8) {
+    if (!this.#yeaftDir || !sessionId) return [];
+    const topicRoot = join(this.#yeaftDir, 'memory', 'sessions', sessionId, 'topic');
+    const labels = [];
+    await collectTopicLabels(topicRoot, '', labels, limit).catch(() => {});
+    return labels;
+  }
+
   /**
    * Prepare the per-turn AMS for the active group. Idempotent and safe
    * to call when the AMS registry isn't wired (returns null).
@@ -1338,7 +1347,7 @@ export class Engine {
    *   string-prompt shape (no regression for existing callers).
    * @yields {EngineEvent}
    */
-  async *query({ prompt, promptParts = null, messages = [], signal, userEffort = null, scenario = 'chat', vpPersona, router, senderVpId, inboundEnvelope, taskId, taskMembers, sessionId, sessionMembers, vpPlan, sessionAnnouncement, workDir, userAlreadyPersisted = false, getCurrentTodos = null, setCurrentTodos = null, threadId = MAIN_THREAD_ID, drainPendingUserMessages = null, collabToolPolicy = null } = {}) {
+  async *query({ prompt, promptParts = null, messages = [], signal, userEffort = null, scenario = 'chat', vpPersona, router, senderVpId, inboundEnvelope, taskId, taskMembers, sessionId, sessionMembers, sessionTopics = null, vpPlan, sessionAnnouncement, workDir, userAlreadyPersisted = false, getCurrentTodos = null, setCurrentTodos = null, threadId = MAIN_THREAD_ID, drainPendingUserMessages = null, collabToolPolicy = null } = {}) {
     if (!prompt || typeof prompt !== 'string' || !prompt.trim()) {
       yield {
         type: 'error',
@@ -1401,7 +1410,7 @@ export class Engine {
 
     try {
       this.#currentThreadId = threadId || MAIN_THREAD_ID;
-      yield* this.#runQuery({ prompt: effectivePrompt, promptParts, messages, signal: runSignal, userEffort: effectiveUserEffort, scenario, vpPersona, router, senderVpId, inboundEnvelope, taskId, taskMembers, sessionId, sessionMembers, vpPlan, sessionAnnouncement, workDir, userAlreadyPersisted, getCurrentTodos, setCurrentTodos, threadId: this.#currentThreadId, drainPendingUserMessages, collabToolPolicy: effectiveCollabToolPolicy });
+      yield* this.#runQuery({ prompt: effectivePrompt, promptParts, messages, signal: runSignal, userEffort: effectiveUserEffort, scenario, vpPersona, router, senderVpId, inboundEnvelope, taskId, taskMembers, sessionId, sessionMembers, sessionTopics, vpPlan, sessionAnnouncement, workDir, userAlreadyPersisted, getCurrentTodos, setCurrentTodos, threadId: this.#currentThreadId, drainPendingUserMessages, collabToolPolicy: effectiveCollabToolPolicy });
     } finally {
       if (signal) {
         try { signal.removeEventListener('abort', onExternalAbort); } catch { /* ignore */ }
@@ -1421,7 +1430,7 @@ export class Engine {
    * in a try/finally without indenting the whole loop.
    * @private
    */
-  async *#runQuery({ prompt, promptParts = null, messages, signal, userEffort = null, scenario = 'chat', vpPersona, router, senderVpId, inboundEnvelope, taskId, taskMembers, sessionId, sessionMembers, vpPlan, sessionAnnouncement, workDir, userAlreadyPersisted = false, getCurrentTodos = null, setCurrentTodos = null, threadId = MAIN_THREAD_ID, drainPendingUserMessages = null, collabToolPolicy = null }) {
+  async *#runQuery({ prompt, promptParts = null, messages, signal, userEffort = null, scenario = 'chat', vpPersona, router, senderVpId, inboundEnvelope, taskId, taskMembers, sessionId, sessionMembers, sessionTopics = null, vpPlan, sessionAnnouncement, workDir, userAlreadyPersisted = false, getCurrentTodos = null, setCurrentTodos = null, threadId = MAIN_THREAD_ID, drainPendingUserMessages = null, collabToolPolicy = null }) {
 
     const effectiveCollabToolPolicy = collabToolPolicy === COLLAB_TOOL_POLICY.SINGLE_VP || collabToolPolicy === COLLAB_TOOL_POLICY.MULTI_VP
       ? collabToolPolicy
@@ -1513,10 +1522,14 @@ export class Engine {
     // Structured per-turn scope summary: session + vp + members + envelope routing
     // info. Long-form scope content lives in AMS — this block carries
     // only IDs + tiny labels. (Feature scope retired 2026-05-13.)
+    const activeSessionTopics = Array.isArray(sessionTopics)
+      ? sessionTopics
+      : await this.#loadSessionTopicLabels(sessionId);
     const activeScope = {
       sessionId: sessionId || '',
-      vpId: ownVpIdForAms || '',
-      members: Array.isArray(sessionMembers) ? sessionMembers : [],
+      sessionMember: ownVpIdForAms || '',
+      sessionMembers: Array.isArray(sessionMembers) ? sessionMembers : [],
+      sessionTopics: activeSessionTopics,
       envelope: inboundEnvelope || null,
     };
 
@@ -2907,3 +2920,22 @@ export class Engine {
     }
   }
 }
+
+async function collectTopicLabels(dir, prefix, labels, limit) {
+  if (labels.length >= limit) return;
+  let entries;
+  try { entries = await fsp.readdir(dir, { withFileTypes: true }); } catch { return; }
+  const hasMemory = entries.some(entry => entry.isFile() && entry.name === 'memory.md');
+  const hasSummary = entries.some(entry => entry.isFile() && entry.name === 'summary.md');
+  if (prefix && (hasMemory || hasSummary)) labels.push(prefix);
+  if (labels.length >= limit) return;
+  const dirs = entries
+    .filter(entry => entry.isDirectory() && !entry.name.startsWith('.'))
+    .map(entry => entry.name)
+    .sort();
+  for (const name of dirs) {
+    const nextPrefix = prefix ? `${prefix}/${name}` : name;
+    await collectTopicLabels(join(dir, name), nextPrefix, labels, limit);
+    if (labels.length >= limit) return;
+  }
+}

package/yeaft/memory/segment.js

@@ -51,7 +51,7 @@ export const KIND_VALUES = new Set([
   'fact', 'preference', 'decision', 'lesson', 'relation', 'goal', 'context',
 ]);
 
-const SCOPE_RE = /^(user|group\/[\w-]+(?:\/(?:user|vp\/[\w-]+|feature\/[\w-]+|topic\/[\w-]+(?:\/[\w-]+)?))?|chat\/[\w-]+(?:\/vp\/[\w-]+)?|session\/[\w-]+(?:\/vp\/[\w-]+)?)$/;
+const SCOPE_RE = /^(user|group\/[\w-]+(?:\/(?:user|vp\/[\w-]+|feature\/[\w-]+|topic\/[\w-]+(?:\/[\w-]+)?))?|sessions\/[\w-]+(?:\/(?:user|vp\/[\w-]+|feature\/[\w-]+|topic\/[\w-]+(?:\/[\w-]+)?))?|chat\/[\w-]+(?:\/vp\/[\w-]+)?|session\/[\w-]+(?:\/vp\/[\w-]+)?)$/;
 
 /**
  * Compute a stable id from segment content. Same body + scope + kind →

package/yeaft/prompts.js

@@ -272,8 +272,9 @@ export function normalizePromptLanguage(language) {
  *   Active Scope params (DESIGN-PROMPT §3 ④):
  *   @param {object} [activeScope] — structured scope summary for this turn
  *   @param {string} [activeScope.sessionId]
- *   @param {string} [activeScope.vpId]
- *   @param {string[]} [activeScope.members]          current session roster
+ *   @param {string} [activeScope.sessionMember]
+ *   @param {string[]} [activeScope.sessionMembers]  current session roster
+ *   @param {string[]} [activeScope.sessionTopics]   bounded topic labels for this session
  *   @param {object} [activeScope.envelope]          inbound routing info (sender, intent)
  *
  * @param {{
@@ -571,10 +572,11 @@ const OMNI_PERSONA_ZH = `你是全能助手，一个跨领域、偏执行的通
  *
  * Schema:
  *   ## active_scope
- *   session: <sessionId>                    (omitted when missing)
- *   vp:      <vpId>                         (omitted when missing)
- *   members: <vpId>, <vpId>                 (omitted when missing)
- *   envelope: from=<sender> intent=<intent> (omitted when no envelope)
+ *   session_id:      <sessionId>                    (omitted when missing)
+ *   session_member:  <vpId>                         (omitted when missing)
+ *   session_members: <vpId>, <vpId>                 (omitted when missing)
+ *   session_topics:  <topic>, <topic>               (omitted when missing)
+ *   envelope: from=<sender> intent=<intent>         (omitted when no envelope)
  *
  * Returns '' when the input has no useful field — we don't emit an empty
  * header. (`featureId`/`featureTitle` fields were removed 2026-05-13 along
@@ -582,8 +584,9 @@ const OMNI_PERSONA_ZH = `你是全能助手，一个跨领域、偏执行的通
  *
  * @param {object} [activeScope]
  * @param {string} [activeScope.sessionId]
- * @param {string} [activeScope.vpId]
- * @param {string[]} [activeScope.members]  current session roster
+ * @param {string} [activeScope.sessionMember]
+ * @param {string[]} [activeScope.sessionMembers]  current session roster
+ * @param {string[]} [activeScope.sessionTopics]   bounded topic labels
  * @param {object} [activeScope.envelope]   inbound routing summary
  * @param {object} lang
  * @returns {string}
@@ -595,15 +598,16 @@ function renderActiveScope(activeScope, lang) {
   const session = typeof activeScope.sessionId === 'string' && activeScope.sessionId.trim()
     ? activeScope.sessionId.trim()
     : '';
-  if (session) lines.push(`session: ${session}`);
+  if (session) lines.push(`session_id: ${session}`);
 
-  const vp = typeof activeScope.vpId === 'string' && activeScope.vpId.trim()
-    ? activeScope.vpId.trim()
-    : '';
-  if (vp) lines.push(`vp: ${vp}`);
+  const sessionMember = firstNonEmptyString(activeScope.sessionMember, activeScope.vpId);
+  if (sessionMember) lines.push(`session_member: ${sessionMember}`);
+
+  const membersLine = renderSessionMembersLine(activeScope.sessionMembers || activeScope.members);
+  if (membersLine) lines.push(`session_members: ${membersLine}`);
 
-  const membersLine = renderSessionMembersLine(activeScope.members);
-  if (membersLine) lines.push(`members: ${membersLine}`);
+  const topicsLine = renderSessionMembersLine(activeScope.sessionTopics);
+  if (topicsLine) lines.push(`session_topics: ${topicsLine}`);
 
   const envLine = renderEnvelopeLine(activeScope.envelope);
   if (envLine) lines.push(`envelope: ${envLine}`);
@@ -614,6 +618,13 @@ function renderActiveScope(activeScope, lang) {
 }
 
 
+function firstNonEmptyString(...values) {
+  for (const value of values) {
+    if (typeof value === 'string' && value.trim()) return value.trim();
+  }
+  return '';
+}
+
 function renderSessionMembersLine(members) {
   if (!Array.isArray(members)) return '';
   const clean = [];