@yeaft/webchat-agent 0.1.940 → 0.1.942

package/package.json

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

package/yeaft/debug-trace.js

@@ -529,7 +529,7 @@ export class DebugTrace {
         const target = typeof data.target === 'string' ? data.target : '';
         if (sessionId) {
           const isBroadcast = !evtGroupId && !target;
-          const isThisGroup = evtGroupId === sessionId || target === `group/${sessionId}` || target === `session/${sessionId}`;
+          const isThisGroup = evtGroupId === sessionId || target === `sessions/${sessionId}`;
           if (!isBroadcast && !isThisGroup) continue;
         }
         dreamEvents.push({

package/yeaft/dream/apply.js

@@ -99,7 +99,7 @@ function renderSourceBlocks(sources, language) {
   const out = [];
   for (const src of (sources || [])) {
     out.push('');
-    out.push(`[group/${src.sessionId}]`);
+    out.push(`[sessions/${src.sessionId}]`);
     for (const m of (src.diff || [])) {
       const head = `[${m.role || 'message'}${m.kind === 'overlap' ? (String(language || '').toLowerCase().startsWith('zh') ? '（已处理）' : ' (already processed)') : ''}]`;
       out.push(head);
@@ -110,7 +110,7 @@ function renderSourceBlocks(sources, language) {
 }
 
 /**
- * Translate `target` like 'group/g-eng' or 'topic/sci/phys' to a Scope
+ * Translate `target` like 'sessions/g-eng' to a Scope
  * understood by store. Throws if the path is malformed.
  *
  * @param {string} target
@@ -121,26 +121,22 @@ export function targetToScope(target) {
   if (target === 'user') return { kind: 'user' };
   const segs = target.split('/').filter(Boolean);
   // Legacy scopes — explicitly rejected. Old data lives under .legacy/.
-  if (segs[0] === 'vp' || segs[0] === 'feature' || segs[0] === 'topic') {
-    throw new Error(`apply.targetToScope: legacy root scope ${JSON.stringify(target)} rejected — use group/<g>/${segs[0]}/...`);
+  if (segs[0] === 'group' || segs[0] === 'vp' || segs[0] === 'feature' || segs[0] === 'topic') {
+    throw new Error(`apply.targetToScope: legacy root scope ${JSON.stringify(target)} rejected — use sessions/<sessionId>`);
   }
-  if (segs[0] === 'group') {
-    if (segs.length === 2) return { kind: 'group', id: segs[1] };
-    // group/<g>/user
+  if (segs[0] === 'sessions') {
+    if (segs.length === 2) return { kind: 'session', id: segs[1] };
     if (segs.length === 3 && segs[2] === 'user') {
-      return { kind: 'group-user', sessionId: segs[1] };
+      return { kind: 'session-user', sessionId: segs[1] };
     }
-    // group/<g>/vp/<v>
     if (segs.length === 4 && segs[2] === 'vp') {
-      return { kind: 'group-vp', sessionId: segs[1], id: segs[3] };
+      return { kind: 'session-vp', sessionId: segs[1], id: segs[3] };
     }
-    // group/<g>/feature/<f>
     if (segs.length === 4 && segs[2] === 'feature') {
-      return { kind: 'group-feature', sessionId: segs[1], id: segs[3] };
+      return { kind: 'session-feature', sessionId: segs[1], id: segs[3] };
     }
-    // group/<g>/topic/<l1>[/<l2>]
     if (segs[2] === 'topic' && (segs.length === 4 || segs.length === 5)) {
-      return { kind: 'group-topic', sessionId: segs[1], path: segs.slice(3) };
+      return { kind: 'session-topic', sessionId: segs[1], path: segs.slice(3) };
     }
   }
   if (segs[0] === 'chat') {
@@ -275,11 +271,11 @@ export async function applyMergedTarget(merged, opts) {
 function scopeRelDir(scope) {
   switch (scope.kind) {
     case 'user':          return 'user';
-    case 'group':         return `group/${scope.id}`;
-    case 'group-user':    return `group/${scope.sessionId}/user`;
-    case 'group-vp':      return `group/${scope.sessionId}/vp/${scope.id}`;
-    case 'group-feature': return `group/${scope.sessionId}/feature/${scope.id}`;
-    case 'group-topic':   return `group/${scope.sessionId}/topic/${scope.path.join('/')}`;
+    case 'session':         return `sessions/${scope.id}`;
+    case 'session-user':    return `sessions/${scope.sessionId}/user`;
+    case 'session-vp':      return `sessions/${scope.sessionId}/vp/${scope.id}`;
+    case 'session-feature': return `sessions/${scope.sessionId}/feature/${scope.id}`;
+    case 'session-topic':   return `sessions/${scope.sessionId}/topic/${scope.path.join('/')}`;
     case 'chat':          return `chat/${scope.id}`;
     case 'chat-vp':       return `chat/${scope.chatId}/vp/${scope.id}`;
     default: throw new Error(`apply.scopeRelDir: unknown kind ${scope.kind}`);

package/yeaft/dream/output-snapshot.js

@@ -10,7 +10,7 @@
 import { join } from 'node:path';
 
 import { readMemory, readSummary } from '../memory/store.js';
-import { readGroupState } from './state.js';
+import { readSessionState } from './state.js';
 
 export const DREAM_SNAPSHOT_TEXT_LIMIT = 6000;
 
@@ -30,15 +30,12 @@ export function truncateDreamText(value, limit = DREAM_SNAPSHOT_TEXT_LIMIT) {
 export async function buildDreamOutputSnapshot(sessionLike, sessionId) {
   if (!sessionId || !sessionLike?.yeaftDir) return null;
   const scope = `sessions/${sessionId}`;
-  // Disk compatibility: Dream currently writes session summaries through
-  // the historical kind:'group' store path. The snapshot's public scope label
-  // is still sessions/<id>.
-  const memoryScope = { kind: 'group', id: sessionId };
+  const memoryScope = { kind: 'session', id: sessionId };
   const root = join(sessionLike.yeaftDir, 'memory');
   const [memoryRaw, summaryRaw, state] = await Promise.all([
     readMemory(memoryScope, { root }).catch(() => ''),
     readSummary(memoryScope, { root }).catch(() => ''),
-    readGroupState(root, sessionId).catch(() => ({
+    readSessionState(root, sessionId).catch(() => ({
       lastDreamMessageId: null,
       lastDreamAt: null,
       messageCount: 0,

package/yeaft/dream/prompts/extract-session.md

@@ -2,12 +2,12 @@
 
 You are extracting **memory segments** from a conversation between the
 user and a Yeaft AI companion. This pass focuses on a specific
-**`session/<id>` scope**: long-lived facts about one collaboration session
+**`sessions/<id>` scope**: long-lived facts about one collaboration session
 (a project team, a study cohort, a working set of people/agents).
 
 The target session id is provided as `{{sessionId}}`.
 
-## What to extract for `session/<id>` scope
+## What to extract for `sessions/<id>` scope
 
 - **purpose** — what this session exists to do, its charter / mission
 - **members** — people, VPs, and roles in the session, and what each is

package/yeaft/dream/prompts/extract-topic.md

@@ -26,7 +26,7 @@ The target topic id is provided as `{{topicId}}`.
 
 - Facts about the user as a person — `user` scope.
 - Facts specific to one feature implementation — `feature/<id>`.
-- Group conventions — `group/<id>`.
+- Group conventions — `sessions/<id>`.
 - Generic encyclopedia facts the assistant already knows — only the
   user's *durable views and confirmed knowledge* about the topic.
 

package/yeaft/dream/prompts/index.js

@@ -41,12 +41,10 @@ const FILES = {
 export function extractTemplateForScope(scope) {
   if (!scope || typeof scope !== 'string') return 'extractTopic';
   if (scope === 'user') return 'extractUser';
-  // Nested group-isolated scopes must be matched BEFORE the bare `group/<g>`
-  // branch so VPs/topics/features under a group don't get the group template.
-  if (/^group\/[^/]+\/vp\//.test(scope)) return 'extractVp';
-  if (/^group\/[^/]+\/topic\//.test(scope)) return 'extractTopic';
-  if (/^group\/[^/]+\/user(?:\/|$)/.test(scope)) return 'extractUser';
-  if (scope.startsWith('group/')) return 'extractSession';
+  if (/^sessions\/[^/]+\/vp\//.test(scope)) return 'extractVp';
+  if (/^sessions\/[^/]+\/topic\//.test(scope)) return 'extractTopic';
+  if (/^sessions\/[^/]+\/user(?:\/|$)/.test(scope)) return 'extractUser';
+  if (scope.startsWith('sessions/')) return 'extractSession';
   // Chat-isolated scopes: same template family as groups.
   if (/^chat\/[^/]+\/vp\//.test(scope)) return 'extractVp';
   if (scope.startsWith('chat/')) return 'extractSession';

package/yeaft/dream/prompts/triage-pass1.md

@@ -2,7 +2,7 @@ You are deciding whether a recent group conversation carries:
   - signals that should update the USER profile, and/or
   - signals that should update one or more TOPIC scopes.
 
-Do NOT mention vp/, group/, or feature/ scopes — those are handled by hard rules.
+Do NOT mention vp/, group/, feature/, or topic/ scopes — those are handled by hard rules.
 
 Session: {{sessionId}}
 

package/yeaft/dream/runner.js

@@ -5,11 +5,11 @@
  *
  *   trigger
  *     ↓
- *   enumerateGroups()                  via opts.listSessions()
+ *   enumerateSessions()                  via opts.listSessions()
  *     ↓
- *   for each group with newCount ≥ MIN_NEW_PER_GROUP (auto)
+ *   for each session with newCount ≥ MIN_NEW_PER_GROUP (auto)
  *                    or > 0 (manual)
- *                    or prior messages in a scoped manual group rerun:
+ *                    or prior messages in a scoped manual session rerun:
  *       loadDiff()                     via opts.loadGroupDiff(sessionId, sinceId)
  *       applyOverlap()                 via opts.loadOverlapPreamble(...)
  *       segment()                      segmentDiff(...)
@@ -21,7 +21,7 @@
  *
  *   bookkeep:
  *     for each processed group:
- *       group .dream-state ←
+ *       session .dream-state ←
  *         { lastDreamMessageId: tail of real diff,
  *           lastDreamAt: nowIso,
  *           messageCount: <after> }
@@ -45,7 +45,7 @@ import { listScopes, readSummary } from '../memory/store.js';
 import {
   DEFAULT_LIMITS,
 } from './limits.js';
-import { readGroupState, writeGroupState, writeDreamError } from './state.js';
+import { readSessionState, writeSessionState, writeDreamError } from './state.js';
 import { segmentDiff, truncateMessage, estimateMessagesTokens } from './segment.js';
 import { triageGroupSegments } from './triage.js';
 import { mergeByTarget } from './merge.js';
@@ -56,9 +56,9 @@ import { tsForBackup, pruneOldSnapshots } from './snapshot.js';
  * @typedef {Object} RunDreamOpts
  * @property {string} root                    — memory root, e.g. ~/.yeaft/memory
  * @property {boolean} [manual=false]         — manual trigger overrides newCount<20 skip
- * @property {string[]} [scopeFilter]         — optional: only dream these targets; scoped manual group triggers rerun the current group when there are prior messages but no new cursor delta ('*' allowed)
+ * @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 group ids (incl. '_no-group')
+ * @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 {(sessionId: string, beforeMessageId: string|null, count: number) => Promise<Array<object>>} loadOverlapPreamble
@@ -89,14 +89,14 @@ export async function runDream(opts) {
   // 1. enumerate groups
   const sessionIds = await safeCall(opts.listSessions, []);
   const filter = Array.isArray(opts.scopeFilter) ? new Set(opts.scopeFilter) : null;
-  const groupFilter = deriveGroupFilter(filter);
-  const groupsReport = [];
-  const groupTriages = [];
-  const processedGroups = [];
+  const sessionFilter = deriveSessionFilter(filter);
+  const sessionsReport = [];
+  const sessionTriages = [];
+  const processedSessions = [];
 
-  // 2. per-group: skip / segment / triage
-  // Topic summaries are now per-group (group/<g>/topic/...), so resolve
-  // them inside the per-group loop instead of once up front.
+  // 2. per-session: skip / segment / triage
+  // Topic summaries are resolved inside the per-session loop
+  // them inside the per-session loop instead of once up front.
   const resolveTopicSummaries = async (sessionId) => {
     if (opts.listTopicSummaries) {
       return await safeCall(() => opts.listTopicSummaries(sessionId), []);
@@ -105,31 +105,31 @@ export async function runDream(opts) {
   };
 
   for (const sessionId of sessionIds) {
-    // Current-group manual dream passes are the one case where scopeFilter
+    // Current-session manual dream passes are the one case where scopeFilter
     // must constrain enumeration too: clicking the conversation header means
-    // "dream this group now", not "triage every group and then only apply
-    // group/<id>". Pure target filters such as ['user'] still triage every
-    // group so their hard-rule actions can contribute to the requested scope.
-    if (groupFilter && !groupFilter.has(sessionId)) {
-      groupsReport.push({ sessionId, new: 0, status: 'skipped', reason: 'scope-filtered' });
+    // "dream this session now", not "triage every session and then only apply
+    // sessions/<id>". Pure target filters such as ['user'] still triage every
+    // session so their hard-rule actions can contribute to the requested scope.
+    if (sessionFilter && !sessionFilter.has(sessionId)) {
+      sessionsReport.push({ sessionId, new: 0, status: 'skipped', reason: 'scope-filtered' });
       continue;
     }
-    const state = await readGroupState(opts.root, sessionId);
+    const state = await readSessionState(opts.root, sessionId);
     const beforeCount = await safeCall(() => opts.countMessages(sessionId), 0);
     const newCount = Math.max(0, beforeCount - (state.messageCount || 0));
 
     const rerunScopedManual = !!opts.manual
-      && groupFilter
-      && groupFilter.has(sessionId)
+      && sessionFilter
+      && sessionFilter.has(sessionId)
       && newCount === 0
       && beforeCount > 0;
 
     if (newCount === 0 && !rerunScopedManual) {
-      groupsReport.push({ sessionId, new: 0, status: 'skipped', reason: 'no-new-messages' });
+      sessionsReport.push({ sessionId, new: 0, status: 'skipped', reason: 'no-new-messages' });
       continue;
     }
     if (!opts.manual && newCount < limits.MIN_NEW_PER_GROUP) {
-      groupsReport.push({ sessionId, new: newCount, status: 'skipped', reason: 'below-threshold' });
+      sessionsReport.push({ sessionId, new: newCount, status: 'skipped', reason: 'below-threshold' });
       continue;
     }
 
@@ -137,7 +137,7 @@ export async function runDream(opts) {
     const diffCursor = rerunScopedManual ? null : state.lastDreamMessageId;
     const diffNew = await safeCall(() => opts.loadGroupDiff(sessionId, diffCursor), []);
     if (!diffNew || diffNew.length === 0) {
-      groupsReport.push({ sessionId, new: newCount, status: 'skipped', reason: 'empty-diff' });
+      sessionsReport.push({ sessionId, new: newCount, status: 'skipped', reason: 'empty-diff' });
       continue;
     }
     const overlapMessages = state.lastDreamMessageId && !rerunScopedManual
@@ -167,12 +167,12 @@ export async function runDream(opts) {
         language: opts.language,
       });
     } catch (err) {
-      groupsReport.push({ sessionId, new: newCount, status: 'error', error: err.message });
+      sessionsReport.push({ sessionId, new: newCount, status: 'error', error: err.message });
       onProgress({ phase: 'triage', sessionId, status: 'error', error: err.message });
       // Journal the failure on disk so operators can see WHY dream is
       // not advancing without having to enable `config.debug`. Best-
       // effort — `writeDreamError` swallows its own I/O errors.
-      await writeDreamError(opts.root, `group/${sessionId}`, {
+      await writeDreamError(opts.root, `sessions/${sessionId}`, {
         phase: 'triage',
         message: err.message,
         stack: err.stack,
@@ -181,17 +181,17 @@ export async function runDream(opts) {
     }
 
     onProgress({ phase: 'triage', sessionId, status: 'done', actions: actions.length });
-    groupTriages.push({ sessionId, diff: fullDiff, actions });
+    sessionTriages.push({ sessionId, diff: fullDiff, actions });
 
     const tailId = lastMessageId(diffNew);
-    processedGroups.push({ sessionId, tailId, beforeCount, newCount, segments: segments.length, actions: actions.length });
-    groupsReport.push({ sessionId, new: newCount, segments: segments.length, actions: actions.length, status: 'triaged', rerun: rerunScopedManual || undefined });
+    processedSessions.push({ sessionId, tailId, beforeCount, newCount, segments: segments.length, actions: actions.length });
+    sessionsReport.push({ sessionId, new: newCount, segments: segments.length, actions: actions.length, status: 'triaged', rerun: rerunScopedManual || undefined });
   }
 
   // 3. merge
-  const mergedTargets = mergeByTarget(groupTriages);
+  const mergedTargets = mergeByTarget(sessionTriages);
   const targetsToApply = filter && filter.size > 0 && !filter.has('*')
-    ? mergedTargets.filter(t => filter.has(t.target) || filter.has(`group/${sourceGroupId(t)}`))
+    ? mergedTargets.filter(t => filter.has(t.target) || filter.has(`sessions/${sourceSessionId(t)}`))
     : mergedTargets;
 
   onProgress({ phase: 'merge', targets: targetsToApply.length });
@@ -237,13 +237,13 @@ export async function runDream(opts) {
   // 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));
-  for (const pg of processedGroups) {
-    const contributed = (groupTriages.find(g => g.sessionId === pg.sessionId) || { actions: [] })
+  for (const pg of processedSessions) {
+    const contributed = (sessionTriages.find(g => g.sessionId === pg.sessionId) || { actions: [] })
       .actions.map(a => a.scope);
     const anySuccess = contributed.some(t => successfulTargets.has(t));
     if (!anySuccess) continue;
     if (pg.tailId) {
-      await writeGroupState(opts.root, pg.sessionId, {
+      await writeSessionState(opts.root, pg.sessionId, {
         lastDreamMessageId: pg.tailId,
         lastDreamAt: nowIso,
         messageCount: pg.beforeCount,
@@ -257,7 +257,7 @@ export async function runDream(opts) {
   const duration = Date.now() - startedAt;
   onProgress({
     phase: 'done',
-    groups: processedGroups.length,
+    sessions: processedSessions.length,
     targets: targetsReport.length,
     duration,
     backupsKept: pruned.kept.length,
@@ -267,7 +267,7 @@ export async function runDream(opts) {
   return {
     startedAt: nowIso,
     durationMs: duration,
-    groups: groupsReport,
+    sessions: sessionsReport,
     targets: targetsReport,
     backups: pruned,
     ts,
@@ -284,18 +284,18 @@ function lastMessageId(messages) {
   return null;
 }
 
-function deriveGroupFilter(filter) {
+function deriveSessionFilter(filter) {
   if (!filter || filter.size === 0 || filter.has('*')) return null;
-  const groups = [];
+  const sessions = [];
   for (const scope of filter) {
     if (typeof scope !== 'string') continue;
-    const m = /^group\/([^/]+)$/.exec(scope);
-    if (m && m[1]) groups.push(m[1]);
+    const m = /^sessions\/([^/]+)$/.exec(scope);
+    if (m && m[1]) sessions.push(m[1]);
   }
-  return groups.length > 0 ? new Set(groups) : null;
+  return sessions.length > 0 ? new Set(sessions) : null;
 }
 
-function sourceGroupId(mergedTarget) {
+function sourceSessionId(mergedTarget) {
   const src = Array.isArray(mergedTarget?.sources) ? mergedTarget.sources[0] : null;
   return src && typeof src.sessionId === 'string' ? src.sessionId : '';
 }

package/yeaft/dream/session-wiring.js

@@ -42,7 +42,7 @@ import { join } from 'path';
 import { runDream } from './runner.js';
 import { createDreamScheduler } from './schedule.js';
 import { listSessions, openSession } from '../sessions/session-store.js';
-import { readGroupState } from './state.js';
+import { readSessionState } from './state.js';
 import { DREAM_NUDGE_AFTER_MESSAGES, DREAM_INTERVAL_HOURS } from './limits.js';
 
 /**
@@ -262,7 +262,7 @@ function finalizeDreamMetrics(metrics, durationMs) {
 
 function summarizeDreamResult(result = {}) {
   return {
-    groups: Array.isArray(result.groups) ? result.groups.length : 0,
+    sessions: Array.isArray(result.sessions) ? result.sessions.length : 0,
     targets: Array.isArray(result.targets) ? result.targets.length : 0,
     error: result.error || null,
     skipped: !!result.skipped,
@@ -461,7 +461,7 @@ export async function bootInitEmptyGroups(args) {
   const empty = [];
   for (const gid of ids) {
     let segCount;
-    try { segCount = args.memoryIndex.listByScope(`group/${gid}`).length; }
+    try { segCount = args.memoryIndex.listByScope(`sessions/${gid}`).length; }
     catch { continue; }
     if (segCount > 0) continue;
     let hasMessages = false;
@@ -473,7 +473,7 @@ export async function bootInitEmptyGroups(args) {
       hasMessages = !first.done;
     } catch { continue; }
     if (!hasMessages) continue;
-    empty.push(`group/${gid}`);
+    empty.push(`sessions/${gid}`);
   }
   if (empty.length === 0) return out;
   if (args.config?.debug) {
@@ -534,7 +534,7 @@ export async function bootCatchUpStaleDream(args) {
   let anyTraffic = false;
   for (const gid of sessionIds) {
     let st;
-    try { st = await readGroupState(memoryRoot, gid); }
+    try { st = await readSessionState(memoryRoot, gid); }
     catch { continue; }
     if (st.lastDreamAt) {
       const t = Date.parse(st.lastDreamAt);

package/yeaft/dream/state.js

@@ -3,10 +3,10 @@
  *
  * Three pieces of state, tracked separately:
  *
- *   1. Per-group control state (used to decide whether a group enters
+ *   1. Per-session control state (used to decide whether a session enters
  *      triage and how far to advance the cursor):
  *
- *        ~/.yeaft/memory/session/<id>/.dream-state
+ *        ~/.yeaft/memory/sessions/<id>/.dream-state
  *
  *      A 3-line text file:
  *
@@ -17,8 +17,8 @@
  *      Fields are independent of each other; missing fields default to
  *      empty / null / 0. The file is rewritten atomically every dream.
  *
- *      The virtual `_no-group/` group lives at the same path layout
- *      (`session/_no-group/.dream-state`) and uses the same accessor.
+ *      The virtual `_no-session/` session lives at the same path layout
+ *      (`sessions/_no-session/.dream-state`) and uses the same accessor.
  *
  *   2. Per-scope observability marker, embedded inside the scope's
  *      `memory.md` between two HTML comments at the file's tail:
@@ -53,42 +53,37 @@ const ERROR_FILE = '.dream-last-error.json';
 const DREAM_BLOCK_OPEN = '<!-- dream-state -->';
 const DREAM_BLOCK_CLOSE = '<!-- /dream-state -->';
 
-// ─── per-group ────────────────────────────────────────────────
+// ─── per-session ────────────────────────────────────────────────
 
 /**
- * Read a group's .dream-state. Missing file → defaults.
+ * Read a session's .dream-state. Missing file → defaults.
  *
  * @param {string} root — memory root, e.g. ~/.yeaft/memory
  * @param {string} sessionId
  * @returns {Promise<{ lastDreamMessageId: string|null, lastDreamAt: string|null, messageCount: number }>}
  */
-export async function readGroupState(root, sessionId) {
-  const abs = join(root, 'session', sessionId, STATE_FILE);
-  const legacyAbs = join(root, 'group', sessionId, STATE_FILE);
+export async function readSessionState(root, sessionId) {
+  const abs = join(root, 'sessions', sessionId, STATE_FILE);
   const empty = { lastDreamMessageId: null, lastDreamAt: null, messageCount: 0 };
   let raw;
   try { raw = await fsp.readFile(abs, 'utf8'); }
   catch (err) {
-    if (!err || err.code !== 'ENOENT') throw err;
-    try { raw = await fsp.readFile(legacyAbs, 'utf8'); }
-    catch (legacyErr) {
-      if (legacyErr && legacyErr.code === 'ENOENT') return empty;
-      throw legacyErr;
-    }
+    if (err && err.code === 'ENOENT') return empty;
+    throw err;
   }
-  return parseGroupState(raw);
+  return parseSessionState(raw);
 }
 
 /**
- * Atomically rewrite a group's .dream-state. Creates the group dir if
+ * Atomically rewrite a session's .dream-state. Creates the session dir if
  * absent. Unknown fields are ignored.
  *
  * @param {string} root
  * @param {string} sessionId
  * @param {{ lastDreamMessageId?: string|null, lastDreamAt?: string|null, messageCount?: number }} state
  */
-export async function writeGroupState(root, sessionId, state) {
-  const dir = join(root, 'session', sessionId);
+export async function writeSessionState(root, sessionId, state) {
+  const dir = join(root, 'sessions', sessionId);
   await fsp.mkdir(dir, { recursive: true });
   const abs = join(dir, STATE_FILE);
   const body =
@@ -103,7 +98,7 @@ export async function writeGroupState(root, sessionId, state) {
  * empty values.
  * @param {string} raw
  */
-function parseGroupState(raw) {
+function parseSessionState(raw) {
   const out = { lastDreamMessageId: null, lastDreamAt: null, messageCount: 0 };
   const lines = String(raw || '').split(/\r?\n/);
   for (const ln of lines) {
@@ -134,12 +129,12 @@ function parseGroupState(raw) {
 // `writeDreamError` writes `<memoryRoot>/<scope>/.dream-last-error.json`
 // unconditionally on every catch (best-effort — write failures must not
 // shadow the original error). Operators can then `ls ~/.yeaft/memory/
-// group/<id>/` and see what blew up, without having to re-enable debug.
+// sessions/<id>/` and see what blew up, without having to re-enable debug.
 
 /**
  * Resolve a memoryRoot + scope-string to the scope directory.
  * The scope string is the same shape dream already uses internally:
- * `'user'`, `'vp/<vpId>'`, `'group/<sessionId>'`, `'feature/<id>'`, etc.
+ * `'user'`, `'sessions/<sessionId>'`, `'sessions/<sessionId>/vp/<vpId>'`, etc.
  *
  * Pure path-join; does NOT create the directory. The writer creates it.
  *
@@ -149,7 +144,7 @@ function parseGroupState(raw) {
  */
 export function scopeDirFor(root, scope) {
   // Defensive: trim leading/trailing slashes so callers can pass either
-  // `'group/grp_fun'` or `/group/grp_fun/` — both land on the same dir.
+  // `'sessions/grp_fun'` or `/sessions/grp_fun/` — both land on the same dir.
   const clean = String(scope || '').replace(/^\/+|\/+$/g, '');
   return join(root, clean);
 }
@@ -160,7 +155,7 @@ export function scopeDirFor(root, scope) {
  * error-handling path and we must not mask the original failure.
  *
  * @param {string} root         — memory root, e.g. ~/.yeaft/memory
- * @param {string} scope        — `'group/<id>'` for triage failures,
+ * @param {string} scope        — `'sessions/<id>'` for triage failures,
  *                                `merged.target` for apply failures.
  * @param {{ phase: string, message: string, stack?: string|null, at?: string }} info
  * @returns {Promise<void>}
@@ -283,4 +278,4 @@ async function atomicWrite(absPath, content) {
 }
 
 // re-exported for tests
-export const _internals = { parseGroupState, extractDreamBlock };
+export const _internals = { parseSessionState, extractDreamBlock };

package/yeaft/dream/triage.js

@@ -1,3 +1,4 @@
+import { isValidTopic } from '../memory/store.js';
 /**
  * dream/triage.js.
  *
@@ -5,7 +6,7 @@
  * The decision is two-staged on purpose:
  *
  *   1. **Hard rules** (this module, no LLM): everything we can determine
- *      from message metadata. Always include the active group, every VP
+ *      from message metadata. Always include the active session, every VP
  *      that spoke as an assistant in the diff, and `user` (so painted-over
  *      user-profile signals can't be missed). (Feature scope was dropped
  *      2026-05-13 along with the rest of the Feature system.)
@@ -35,7 +36,6 @@
  * below.)
  */
 
-import { isValidTopic } from '../memory/store.js';
 import { truncateMessage } from './segment.js';
 import { render } from './prompts/index.js';
 
@@ -50,8 +50,8 @@ function triageSystem(language) {
  * structure of the diff.
  *
  * Inputs:
- *   - sessionId: the active group ('_no-session' is allowed and skips the
- *     `group/<id>` entry — by convention the virtual group has no scope
+ *   - sessionId: the active session ('_no-session' is allowed and skips the
+ *     `sessions/<id>` entry — by convention the virtual session has no scope
  *     of its own).
  *   - messages: the diff (already overlap-prefixed if applicable).
  *
@@ -65,7 +65,7 @@ export function applyHardRules({ sessionId, chatId, messages }) {
   // global user is always in.
   add('user');
 
-  // chat path takes precedence: chat sessions have no group context.
+  // chat path takes precedence: chat sessions have no collaborative session context.
   if (chatId) {
     add(`chat/${chatId}`);
     for (const m of (messages || [])) {
@@ -80,19 +80,19 @@ export function applyHardRules({ sessionId, chatId, messages }) {
     return Array.from(out.values());
   }
 
-  // active group + its per-group user layer, except the virtual _no-group bucket.
+  // active collaborative session, except the virtual _no-session bucket.
   if (sessionId && sessionId !== '_no-session') {
-    add(`group/${sessionId}`);
-    add(`group/${sessionId}/user`);
+    add(`sessions/${sessionId}`);
+    add(`sessions/${sessionId}/user`);
   }
 
   for (const m of (messages || [])) {
     if (!m || typeof m !== 'object') continue;
-    // Active VP: any assistant message's vpId — now group-internal.
+    // Active VP: any assistant message's vpId, isolated inside this session.
     if (m.role === 'assistant') {
       const vp = m.vpId || (m.author && /^vp:(.+)$/.exec(m.author)?.[1]);
       if (vp && /^[A-Za-z0-9_\-.一-鿿]+$/.test(vp) && sessionId && sessionId !== '_no-session') {
-        add(`group/${sessionId}/vp/${vp}`);
+        add(`sessions/${sessionId}/vp/${vp}`);
       }
     }
   }
@@ -181,8 +181,8 @@ export async function classifySoft({ sessionId, messages, topicSummaries, llm, l
     if (!path) continue;
     const segs = path.split('/').filter(Boolean);
     if (!sessionId || sessionId === '_no-session') continue;
-    if (!isValidTopic({ kind: 'group-topic', sessionId, path: segs })) continue;
-    const scope = `group/${sessionId}/topic/${segs.join('/')}`;
+    if (!isValidTopic({ kind: 'session-topic', sessionId, path: segs })) continue;
+    const scope = `sessions/${sessionId}/topic/${segs.join('/')}`;
     if (pass2.decision === 'match') {
       out.push({ kind: 'update', scope });
     } else if (pass2.decision === 'new') {

package/yeaft/engine.js

@@ -251,7 +251,7 @@ export function shouldAllowGroupReflection({
  * @param {{
  *   sessionId?: string|null,
  *   ownVpId?: string|null,
- *   summaries: { user?: string, group?: string, vp?: string }
+ *   summaries: { user?: string, session?: string, vp?: string }
  * }} args
  * @returns {Array<{scope: string, summary: string}>}
  */
@@ -259,15 +259,12 @@ export function buildResidentEntries(args) {
   const summaries = (args && args.summaries) || {};
   const out = [];
   if (summaries.user) out.push({ scope: 'user', summary: summaries.user });
-  if (args.sessionId && summaries.group) {
-    // Presentation label: product-facing prompt scopes are sessions, even
-    // though the current disk compatibility path still reads kind:'group'.
-    out.push({ scope: `sessions/${args.sessionId}`, summary: summaries.group });
+  if (args.sessionId && summaries.session) {
+    out.push({ scope: `sessions/${args.sessionId}`, summary: summaries.session });
   }
   // VP per-session isolation (2026-06-09): the VP summary scope MUST be
   // session-qualified. The legacy bare `vp/<id>` scope was a structural
-  // bug — `summaries.vp` is actually loaded from `group/<sessionId>/vp/<id>/summary.md`
-  // (see #loadLayerASummaries, kind:'group-vp'), so labelling it `vp/<id>`
+    // (see #loadLayerASummaries, kind:'group-vp'), so labelling it `vp/<id>`
   // in the Resident layer (a) collides with the ACL regex in store
   // (which only recognises `<root>/<sid>/vp/...`) and (b) makes the same
   // VP persona leak across DIFFERENT sessions whenever the AMS rehydrates
@@ -394,7 +391,7 @@ export class Engine {
    * subsequent turns only run on budget pressure or new memory.
    * @type {Map<string, boolean>}
    */
-  #adjustRanByGroup = new Map();
+  #adjustRanBySession = new Map();
 
   /** @type {string|null} */
   #abortReason = null;
@@ -572,30 +569,30 @@ export class Engine {
    *
    * Scopes:
    *   - user           → `user/summary.md`            (always attempted)
-   *   - group <gid>    → `groups/<gid>/summary.md`    (if sessionId)
-   *   - vp <vpId>      → `vp/<vpId>/summary.md`       (if vpId)
+   *   - session <sid>  → `sessions/<sid>/summary.md`   (if sessionId)
+   *   - session-vp     → `sessions/<sid>/vp/<vpId>/summary.md` (if vpId)
    *
    * Each fetch is best-effort — missing files / read errors return ''. The
    * dream tick (Phase 6) is what populates these; on a fresh install they
    * all return ''.
    *
    * @param {{sessionId?: string, vpId?: string, language?: string}} ctx
-   * @returns {Promise<{user:string, group:string, vp:string}>}
+   * @returns {Promise<{user:string, session:string, vp:string}>}
    */
   async #loadLayerASummaries({ sessionId, vpId, language } = {}) {
-    if (!this.#yeaftDir) return { user: '', group: '', vp: '' };
+    if (!this.#yeaftDir) return { user: '', session: '', vp: '' };
     const memoryRoot = `${this.#yeaftDir}/memory`;
     const tasks = [
       readScopeSummary({ kind: 'user' }, { root: memoryRoot, language }).catch(() => ''),
       sessionId
-        ? readScopeSummary({ kind: 'group', id: sessionId }, { root: memoryRoot, language }).catch(() => '')
+        ? readScopeSummary({ kind: 'session', id: sessionId }, { root: memoryRoot, language }).catch(() => '')
         : Promise.resolve(''),
       vpId && sessionId
-        ? readScopeSummary({ kind: 'group-vp', sessionId, id: vpId }, { root: memoryRoot, language }).catch(() => '')
+        ? readScopeSummary({ kind: 'session-vp', sessionId, id: vpId }, { root: memoryRoot, language }).catch(() => '')
         : Promise.resolve(''),
     ];
-    const [user, group, vp] = await Promise.all(tasks);
-    return { user: user || '', group: group || '', vp: vp || '' };
+    const [user, session, vp] = await Promise.all(tasks);
+    return { user: user || '', session: session || '', vp: vp || '' };
   }
 
   /**
@@ -605,12 +602,12 @@ export class Engine {
    * @param {{
    *   sessionId?: string,
    *   ownVpId?: string|null,
-   *   summaries: { user?: string, group?: string, vp?: string },
+   *   summaries: { user?: string, session?: string, vp?: string },
    *   recallEntries: object[],
    * }} args
    * @returns {{
    *   ams: import('./memory/ams.js').ActiveMemorySet,
-   *   groupKey: string,
+   *   sessionKey: string,
    *   ownVpId: string|null,
    *   scopes: string[],
    *   snapshotBlock: string,
@@ -619,17 +616,17 @@ export class Engine {
    */
   #prepareAms(args) {
     if (!this.#amsRegistry) return null;
-    const groupKey = args.sessionId || 'default';
+    const sessionKey = args.sessionId || 'default';
     const ownVpId = args.ownVpId || null;
-    const ams = this.#amsRegistry.getOrCreate(groupKey, { ownVpId });
+    const ams = this.#amsRegistry.getOrCreate(sessionKey, { ownVpId });
 
-    // Prime #adjustRanByGroup from disk-hydrated state on first access:
+    // 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.#adjustRanByGroup.has(groupKey)
-        && this.#amsRegistry.adjustRanThisSession(groupKey)) {
-      this.#adjustRanByGroup.set(groupKey, true);
+    if (!this.#adjustRanBySession.has(sessionKey)
+        && this.#amsRegistry.adjustRanThisSession(sessionKey)) {
+      this.#adjustRanBySession.set(sessionKey, true);
     }
 
     // (a) Resident: rebuild from the same scope summaries the worker
@@ -653,7 +650,7 @@ export class Engine {
       vpId: ownVpId,
     });
 
-    return { ams, groupKey, ownVpId, scopes, snapshotBlock, residentEntries };
+    return { ams, sessionKey, ownVpId, scopes, snapshotBlock, residentEntries };
   }
 
   /**
@@ -708,7 +705,7 @@ export class Engine {
    * surface as a turn failure.
    *
    * @param {{
-   *   amsContext: { ams: import('./memory/ams.js').ActiveMemorySet, groupKey: string, ownVpId: string|null, scopes: string[] }|null,
+   *   amsContext: { ams: import('./memory/ams.js').ActiveMemorySet, sessionKey: string, ownVpId: string|null, scopes: string[] }|null,
    *   userMsg: string,
    *   assistantReply: string,
    *   turnTokenUsage: number,
@@ -721,7 +718,7 @@ export class Engine {
     const totalBudget = ctx.ams.budget?.total || 0;
     if (!totalBudget) return null;
 
-    const adjustRanThisSession = this.#adjustRanByGroup.get(ctx.groupKey) === true;
+    const adjustRanThisSession = this.#adjustRanBySession.get(ctx.sessionKey) === true;
     try {
       const result = await runAdjust({
         trigger: {
@@ -748,12 +745,12 @@ export class Engine {
         },
       });
       if (result?.ran) {
-        this.#adjustRanByGroup.set(ctx.groupKey, true);
+        this.#adjustRanBySession.set(ctx.sessionKey, true);
         // Always persist when we ran — even with no membership change,
         // the adjustRanThisSession bit is part of the on-disk state we
         // want to preserve.
-        this.#amsRegistry.markDirty(ctx.groupKey);
-        this.#amsRegistry.persist(ctx.groupKey, {
+        this.#amsRegistry.markDirty(ctx.sessionKey);
+        this.#amsRegistry.persist(ctx.sessionKey, {
           adjustRanThisSession: true,
         });
       }
@@ -2262,7 +2259,7 @@ export class Engine {
               type: 'memory_adjust',
               turnId: queryTurnId,
               threadId,
-              groupKey: amsContext.groupKey,
+              sessionKey: amsContext.sessionKey,
               added: adjustResult.added,
               evicted: adjustResult.evicted,
               skipped: adjustResult.skipped || 0,

package/yeaft/memory/store.js

@@ -65,10 +65,13 @@ export const SCOPE_KINDS = Object.freeze([
   'chat',
   'chat-vp',
   'session',
+  'session-user',
   'session-vp',
+  'session-feature',
+  'session-topic',
 ]);
 
-/** @typedef {'user'|'group'|'group-user'|'group-vp'|'group-feature'|'group-topic'|'chat'|'chat-vp'|'session'|'session-vp'} ScopeKind */
+/** @typedef {'user'|'group'|'group-user'|'group-vp'|'group-feature'|'group-topic'|'chat'|'chat-vp'|'session'|'session-user'|'session-vp'|'session-feature'|'session-topic'} ScopeKind */
 
 /**
  * @typedef {Object} Scope
@@ -141,14 +144,36 @@ export function scopeDir(scope) {
     case 'session': {
       if (!scope.id) throw new Error('scopeDir: session scope requires id');
       assertSafeSegment(scope.id, 'session.id');
-      return `session/${scope.id}`;
+      return `sessions/${scope.id}`;
+    }
+    case 'session-user': {
+      if (!scope.sessionId) throw new Error('scopeDir: session-user scope requires sessionId');
+      assertSafeSegment(scope.sessionId, 'session-user.sessionId');
+      return `sessions/${scope.sessionId}/user`;
     }
     case 'session-vp': {
       if (!scope.sessionId) throw new Error('scopeDir: session-vp scope requires sessionId');
       if (!scope.id) throw new Error('scopeDir: session-vp scope requires id');
       assertSafeSegment(scope.sessionId, 'session-vp.sessionId');
       assertSafeSegment(scope.id, 'session-vp.id');
-      return `session/${scope.sessionId}/vp/${scope.id}`;
+      return `sessions/${scope.sessionId}/vp/${scope.id}`;
+    }
+    case 'session-feature': {
+      if (!scope.sessionId) throw new Error('scopeDir: session-feature scope requires sessionId');
+      if (!scope.id) throw new Error('scopeDir: session-feature scope requires id');
+      assertSafeSegment(scope.sessionId, 'session-feature.sessionId');
+      assertSafeSegment(scope.id, 'session-feature.id');
+      return `sessions/${scope.sessionId}/feature/${scope.id}`;
+    }
+    case 'session-topic': {
+      if (!scope.sessionId) throw new Error('scopeDir: session-topic scope requires sessionId');
+      assertSafeSegment(scope.sessionId, 'session-topic.sessionId');
+      const segs = Array.isArray(scope.path) ? scope.path : [];
+      if (segs.length === 0 || segs.length > 2) {
+        throw new Error('scopeDir: session-topic.path must have 1 or 2 segments');
+      }
+      for (const seg of segs) assertSafeSegment(seg, 'session-topic.path');
+      return `sessions/${scope.sessionId}/topic/${segs.join('/')}`;
     }
     default:
       throw new Error(`scopeDir: unknown kind ${JSON.stringify(scope.kind)}`);
@@ -189,7 +214,7 @@ function assertSafeSegment(s, ctx) {
  * @returns {boolean}
  */
 export function isValidTopic(scope) {
-  if (!scope || scope.kind !== 'group-topic') return false;
+  if (!scope || (scope.kind !== 'group-topic' && scope.kind !== 'session-topic')) return false;
   if (!scope.sessionId || typeof scope.sessionId !== 'string') return false;
   if (!Array.isArray(scope.path)) return false;
   if (scope.path.length < 1 || scope.path.length > 2) return false;
@@ -578,8 +603,8 @@ export async function listScopes(opts = {}) {
     }
   }
 
-  // session/<s>/  and  session/<s>/vp/<v>/
-  const sessionRoot = join(root, 'session');
+  // sessions/<s>/  and  sessions/<s>/vp/<v>/
+  const sessionRoot = join(root, 'sessions');
   let sessions;
   try { sessions = await fsp.readdir(sessionRoot, { withFileTypes: true }); }
   catch (err) {
@@ -592,6 +617,8 @@ export async function listScopes(opts = {}) {
     if (!isSafeId(sent.name)) continue;
     const s = sent.name;
     out.push({ kind: 'session', id: s });
+    if (existsSync(join(sessionRoot, s, 'user'))) out.push({ kind: 'session-user', sessionId: s });
+
     const vpDir = join(sessionRoot, s, 'vp');
     let vps;
     try { vps = await fsp.readdir(vpDir, { withFileTypes: true }); }
@@ -601,6 +628,34 @@ export async function listScopes(opts = {}) {
       if (!isSafeId(vent.name)) continue;
       out.push({ kind: 'session-vp', sessionId: s, id: vent.name });
     }
+
+    const featureDir = join(sessionRoot, s, 'feature');
+    let features;
+    try { features = await fsp.readdir(featureDir, { withFileTypes: true }); }
+    catch { features = []; }
+    for (const fent of features) {
+      if (!fent.isDirectory()) continue;
+      if (!isSafeId(fent.name)) continue;
+      out.push({ kind: 'session-feature', sessionId: s, id: fent.name });
+    }
+
+    const topicDir = join(sessionRoot, s, 'topic');
+    let topics;
+    try { topics = await fsp.readdir(topicDir, { withFileTypes: true }); }
+    catch { topics = []; }
+    for (const tent of topics) {
+      if (!tent.isDirectory()) continue;
+      if (!isSafeId(tent.name)) continue;
+      out.push({ kind: 'session-topic', sessionId: s, path: [tent.name] });
+      let subTopics;
+      try { subTopics = await fsp.readdir(join(topicDir, tent.name), { withFileTypes: true }); }
+      catch { subTopics = []; }
+      for (const sub of subTopics) {
+        if (!sub.isDirectory()) continue;
+        if (!isSafeId(sub.name)) continue;
+        out.push({ kind: 'session-topic', sessionId: s, path: [tent.name, sub.name] });
+      }
+    }
   }
 
   return out;

package/yeaft/sessions/seed-default.js

@@ -83,7 +83,7 @@ export function seedDefaultSession(yeaftDir, spec = {}) {
   // root permission failure must NOT break the bootstrap flow.
   try {
     seedSummaryIfMissingSync(
-      { kind: 'group', id: DEFAULT_SESSION_ID },
+      { kind: 'session', id: DEFAULT_SESSION_ID },
       buildDefaultSessionSeedSummary({ name, roster, defaultVpId }),
       { root: memoryRoot },
     );

package/yeaft/sessions/session-crud.js

@@ -497,14 +497,10 @@ export function deleteSession(yeaftDir, sessionId, options = {}) {
     rmSync(dir, { recursive: true, force: true });
   }
 
-  // Cascade: drop the group's memory scope so a recreate with the same id
+  // Cascade: drop the session memory scope so a recreate with the same id
   // starts clean. Best-effort — never let memory cleanup fail the CRUD op.
-  // Runs unconditionally so the idempotent path also clears stale memory.
   try {
     removeScopeDirSync({ kind: 'session', id: sessionId }, { root: memoryRoot });
-    // Legacy pre-session memory scopes used memory/group/<id>. Delete both so
-    // idempotent removal clears stale summaries for old grp_* sessions too.
-    removeScopeDirSync({ kind: 'group', id: sessionId }, { root: memoryRoot });
   } catch (err) {
     console.warn(`[session-crud] failed to remove memory dir for ${sessionId}:`, err?.message || err);
   }

package/yeaft/web-bridge.js

@@ -205,11 +205,11 @@ function getVpStatusBroker() {
  *      the target VP's driver instead of being dropped.
  *   2. Each VP thread gets its own Engine (via `vpEngines`) so private state
  *      (`#currentAbortCtrl`, `#__queryCounter`, `#pendingT2`,
- *      `#abortReason`, `#adjustRanByGroup`, `#execLog`, `#currentThreadId`)
+ *      `#abortReason`, `#adjustRanBySession`, `#execLog`, `#currentThreadId`)
  *      does not collide across concurrent VP turns. Engines are keyed by
  *      `${sessionId}::${vpId}::${threadId}` rather than vpId alone because
  *      Engine cannot serve two concurrent queries safely — even if AMS state
- *      partitions correctly by groupKey, the non-group-keyed private state
+ *      partitions correctly by sessionKey, the non-session-keyed private state
  *      would collide if the same VP ran turns in two groups or two threads
  *      in parallel.
  */
@@ -859,7 +859,7 @@ function isPermissionErrorMsg(msg) {
 /**
  * Get-or-create the per-VP Engine. Each VP owns its own Engine instance
  * so private state (`#currentAbortCtrl`, `#__queryCounter`, `#pendingT2`,
- * `#abortReason`, `#adjustRanByGroup`, `#execLog`) doesn't collide when
+ * `#abortReason`, `#adjustRanBySession`, `#execLog`) doesn't collide when
  * VP-A and VP-B run concurrent turns. All engines share the session's
  * adapter / trace / config / stores so memory recall, conversation
  * persistence, and tool registry remain consistent.
@@ -1599,16 +1599,7 @@ export function handleYeaftRestoreSession(msg) {
 
 export function handleYeaftRenameSession(msg) {
   const requestId = msg && msg.requestId;
-  // fix-yeaft-delete-and-agent-revert: accept legacy `groupId` in
-  // addition to `sessionId`. The contract documented in
-  // `web/stores/sessions.js` header ("Inbound payloads may carry
-  // either sessionId (new) or groupId (legacy); both are accepted,
-  // prefer sessionId") was only honored on web-side reads; the agent
-  // handlers were silently rejecting the older wire shape that today's
-  // SessionSettingsModal still sends. That's what made delete/rename/
-  // archive/update_config/add_member/remove_member/set_default_vp
-  // all throw `not_found` on undefined ids.
-  const sessionId = (msg && (msg.sessionId || msg.groupId)) || null;
+  const sessionId = (msg && msg.sessionId) || null;
   const name = msg && msg.name;
   try {
     const yeaftDir = ctx.CONFIG?.yeaftDir;
@@ -1638,7 +1629,7 @@ export function handleYeaftRenameSession(msg) {
 export function handleYeaftUpdateSession(msg) {
   const requestId = msg && msg.requestId;
   // wire-compat: accept legacy `groupId` (see handleYeaftRenameSession).
-  const sessionId = (msg && (msg.sessionId || msg.groupId)) || null;
+  const sessionId = (msg && msg.sessionId) || null;
   const patch = (msg && msg.patch && typeof msg.patch === 'object') ? msg.patch : null;
   try {
     const hasName = patch && typeof patch.name === 'string' && patch.name.trim().length > 0;
@@ -1673,7 +1664,7 @@ export function handleYeaftUpdateSession(msg) {
 export function handleYeaftUpdateSessionConfig(msg) {
   const requestId = msg && msg.requestId;
   // wire-compat: accept legacy `groupId` (see handleYeaftRenameSession).
-  const sessionId = (msg && (msg.sessionId || msg.groupId)) || null;
+  const sessionId = (msg && msg.sessionId) || null;
   const partial = (msg && msg.config && typeof msg.config === 'object') ? msg.config : null;
   try {
     if (!sessionId) throw new SessionConfigError('missing_group_id', 'sessionId required');
@@ -1696,7 +1687,7 @@ export function handleYeaftUpdateSessionConfig(msg) {
 export function handleYeaftArchiveSession(msg) {
   const requestId = msg && msg.requestId;
   // wire-compat: accept legacy `groupId` (see handleYeaftRenameSession).
-  const sessionId = (msg && (msg.sessionId || msg.groupId)) || null;
+  const sessionId = (msg && msg.sessionId) || null;
   try {
     const yeaftDir = ctx.CONFIG?.yeaftDir;
     const result = archiveSession(yeaftDir, sessionId);
@@ -1717,7 +1708,7 @@ export function handleYeaftArchiveSession(msg) {
 export function handleYeaftDeleteSession(msg) {
   const requestId = msg && msg.requestId;
   // wire-compat: accept legacy `groupId` (see handleYeaftRenameSession).
-  const sessionId = (msg && (msg.sessionId || msg.groupId)) || null;
+  const sessionId = (msg && msg.sessionId) || null;
   try {
     const yeaftDir = ctx.CONFIG?.yeaftDir;
     const result = deleteSession(yeaftDir, sessionId);
@@ -1759,7 +1750,7 @@ export function handleYeaftDeleteSession(msg) {
 export function handleYeaftSessionAddMember(msg) {
   const requestId = msg && msg.requestId;
   // wire-compat: accept legacy `groupId` (see handleYeaftRenameSession).
-  const sessionId = (msg && (msg.sessionId || msg.groupId)) || null;
+  const sessionId = (msg && msg.sessionId) || null;
   const vpId = msg && msg.vpId;
   try {
     const yeaftDir = ctx.CONFIG?.yeaftDir;
@@ -1775,7 +1766,7 @@ export function handleYeaftSessionAddMember(msg) {
 export function handleYeaftSessionRemoveMember(msg) {
   const requestId = msg && msg.requestId;
   // wire-compat: accept legacy `groupId` (see handleYeaftRenameSession).
-  const sessionId = (msg && (msg.sessionId || msg.groupId)) || null;
+  const sessionId = (msg && msg.sessionId) || null;
   const vpId = msg && msg.vpId;
   try {
     const yeaftDir = ctx.CONFIG?.yeaftDir;
@@ -1797,7 +1788,7 @@ export function handleYeaftSessionRemoveMember(msg) {
 export function handleYeaftSessionSetDefaultVp(msg) {
   const requestId = msg && msg.requestId;
   // wire-compat: accept legacy `groupId` (see handleYeaftRenameSession).
-  const sessionId = (msg && (msg.sessionId || msg.groupId)) || null;
+  const sessionId = (msg && msg.sessionId) || null;
   const vpId = msg && msg.vpId;
   try {
     const yeaftDir = ctx.CONFIG?.yeaftDir;
@@ -1885,11 +1876,11 @@ export function installYeaftRuntimeBridge(s) {
   s._dreamResultSink = async (result = {}) => {
     if (result?.trigger !== 'auto') return;
     const normalized = normalizeDreamResult(result);
-    const processed = Array.isArray(result.groups)
-      ? result.groups.filter(g => g && g.status === 'processed' && g.sessionId)
+    const processed = Array.isArray(result.sessions)
+      ? result.sessions.filter(row => row && row.status === 'triaged' && row.sessionId)
       : [];
-    for (const group of processed) {
-      const sessionId = group.sessionId;
+    for (const sessionRow of processed) {
+      const sessionId = sessionRow.sessionId;
       const snapshot = await buildDreamOutputSnapshot(session, sessionId).catch(() => null);
       sendToServer({
         type: 'yeaft_dream_result',
@@ -2230,7 +2221,7 @@ function handleEngineEvent(event, hctx) {
       sendYeaftEvent({
         type: 'memory_adjust',
         turnId: event.turnId,
-        groupKey: event.groupKey,
+        sessionKey: event.sessionKey,
         added: event.added,
         evicted: event.evicted,
         skipped: event.skipped,
@@ -2902,7 +2893,7 @@ async function raceWithEscalation(inner, { deadlineMs, onEscalate }) {
  * itself; the persistent coord lives in `sessionContexts[sessionId]`. Uses
  * `getOrCreateVpEngine(sessionId, vpId)` so each VP runs against its own
  * Engine instance — private state (`#currentAbortCtrl`, `#__queryCounter`,
- * `#pendingT2`, `#abortReason`, `#adjustRanByGroup`, `#execLog`) does not
+ * `#pendingT2`, `#abortReason`, `#adjustRanBySession`, `#execLog`) does not
  * collide when VP-A and VP-B run concurrent turns.
  *
  * @param {{ prompt: string, sessionId: string, vpId: string, turnId: string, envelope: object, vpAbort: AbortController, baseSnapshot: Array }} args
@@ -3523,28 +3514,28 @@ export function __testAppendTurnToSessionHistory(...args) {
  *   { type: 'yeaft_dream_trigger', sessionId }  — per-GROUP trigger (new
  *     in v0.1.754 — added so users can manually kick dream for a group
  *     after seeing the Resident layer stuck on the bootstrap seed).
- *     Fires a scope-filtered pass via `triggerDreamForScopes(['group/X'])`
+ *     Fires a scope-filtered pass via `triggerDreamForScopes(['sessions/X'])`
  *     so unrelated groups don't get processed; the result event is
- *     tagged with `sessionId` for the per-group UI row.
+ *     tagged with `sessionId` for the per-session UI row.
  *
  * Backwards-compat: when neither field is set, defaults to `vpId='default'`
  * which matches the pre-v0.1.754 behavior.
  */
 export function normalizeDreamResult(result) {
-  const groups = Array.isArray(result?.groups) ? result.groups : [];
+  const sessions = Array.isArray(result?.sessions) ? result.sessions : [];
   const targets = Array.isArray(result?.targets) ? result.targets : [];
-  const groupsProcessed = groups.filter(g => g && g.status === 'triaged').length;
-  const skippedGroups = groups.filter(g => g && g.status === 'skipped');
-  const groupsSkipped = skippedGroups.length;
+  const sessionsProcessed = sessions.filter(g => g && g.status === 'triaged').length;
+  const skippedSessions = sessions.filter(g => g && g.status === 'skipped');
+  const sessionsSkipped = skippedSessions.length;
   const targetsApplied = targets.filter(t => t && t.status === 'done').length;
   const targetErrors = targets
     .filter(t => t && t.status === 'error')
     .map(t => ({ target: t.target || null, error: t.error || 'unknown' }));
   const hardError = result?.error || null;
   const explicitSkipped = result?.skipped === true;
-  const skipped = !hardError && (explicitSkipped || (groupsProcessed === 0 && targetsApplied === 0));
+  const skipped = !hardError && (explicitSkipped || (sessionsProcessed === 0 && targetsApplied === 0));
   const skippedReason = skipped
-    ? (result?.skippedReason || skippedGroups[0]?.reason || 'no-targets-applied')
+    ? (result?.skippedReason || skippedSessions[0]?.reason || 'no-targets-applied')
     : null;
   const trigger = result?.trigger || null;
   const success = !hardError && targetErrors.length === 0 && !skipped && targetsApplied > 0;
@@ -3560,8 +3551,8 @@ export function normalizeDreamResult(result) {
     passBreakdown: result?.passBreakdown || result?.metrics?.passBreakdown || null,
     skipped,
     skippedReason,
-    groupsProcessed,
-    groupsSkipped,
+    sessionsProcessed,
+    sessionsSkipped,
     targetsApplied,
     targetErrors,
     entriesCreated: targetsApplied,
@@ -3648,7 +3639,7 @@ export async function handleYeaftDreamTrigger(msg = {}) {
     });
 
     const result = sessionId
-      ? await session.dreamScheduler.triggerDreamForScopes([`group/${sessionId}`])
+      ? await session.dreamScheduler.triggerDreamForScopes([`sessions/${sessionId}`])
       : await session.dreamScheduler.triggerDreamNow();
 
     const normalized = normalizeDreamResult(result);
@@ -3657,7 +3648,7 @@ export async function handleYeaftDreamTrigger(msg = {}) {
       : null;
 
     // Spread `result` FIRST so normalized fields (success, skipped,
-    // skippedReason, groupsProcessed, groupsSkipped, targetsApplied,
+    // skippedReason, sessionsProcessed, sessionsSkipped, targetsApplied,
     // targetErrors, entriesCreated, lastDreamAt) authoritatively shadow
     // anything the runner might grow
     // with the same name. Today there is no collision (runner.js returns