@yeaft/webchat-agent 0.1.874 → 0.1.875

package/yeaft/dream-v2/merge.js

@@ -12,7 +12,7 @@
  *
  *   [
  *     {
- *       groupId: 'g-eng',
+ *       sessionId: 'g-eng',
  *       diff: [<message>, ...],            // the per-group source diff
  *                                          // (already truncated/segmented if needed)
  *       actions: [
@@ -32,36 +32,36 @@
  *     { target: 'user',
  *       kind: 'update',                    // 'update' wins over 'create' if any group says update
  *       sources: [
- *         { groupId: 'g-eng',  diff: [...] },
- *         { groupId: 'g-life', diff: [...] },
+ *         { sessionId: 'g-eng',  diff: [...] },
+ *         { sessionId: 'g-life', diff: [...] },
  *       ],
  *     },
  *     { target: 'topic/life/parenting',
  *       kind: 'create',                    // create only if every contributing group said create
- *       sources: [{ groupId: 'g-life', diff: [...] }],
+ *       sources: [{ sessionId: 'g-life', diff: [...] }],
  *     },
  *     ...
  *   ]
  *
  * Determinism contract:
  *   - Targets are returned sorted alphabetically by target path.
- *   - Within a target, sources are sorted by groupId.
+ *   - Within a target, sources are sorted by sessionId.
  *   This makes the debug-panel output predictable across runs.
  */
 
 /**
  * Merge per-group triage outputs into per-target apply units.
  *
- * @param {Array<{ groupId: string, diff: any, actions: Array<{ kind: 'update'|'create', scope: string }> }>} groupTriages
- * @returns {Array<{ target: string, kind: 'update'|'create', sources: Array<{ groupId: string, diff: any }> }>}
+ * @param {Array<{ sessionId: string, diff: any, actions: Array<{ kind: 'update'|'create', scope: string }> }>} groupTriages
+ * @returns {Array<{ target: string, kind: 'update'|'create', sources: Array<{ sessionId: string, diff: any }> }>}
  */
 export function mergeByTarget(groupTriages) {
   const byTarget = new Map();
   for (const g of (groupTriages || [])) {
-    const groupId = g && g.groupId;
+    const sessionId = g && g.sessionId;
     const diff = g && g.diff;
     const actions = Array.isArray(g && g.actions) ? g.actions : [];
-    if (!groupId) continue;
+    if (!sessionId) continue;
     for (const a of actions) {
       if (!a || !a.scope) continue;
       const k = a.kind === 'create' ? 'create' : 'update';
@@ -75,13 +75,13 @@ export function mergeByTarget(groupTriages) {
       if (k === 'update') entry.kind = 'update';
       // Avoid duplicate (target, group) pairs — should never happen
       // in normal triage but be defensive.
-      if (!entry.sources.some(s => s.groupId === groupId)) {
-        entry.sources.push({ groupId, diff });
+      if (!entry.sources.some(s => s.sessionId === sessionId)) {
+        entry.sources.push({ sessionId, diff });
       }
     }
   }
   const out = Array.from(byTarget.values());
   out.sort((a, b) => a.target.localeCompare(b.target));
-  for (const e of out) e.sources.sort((a, b) => a.groupId.localeCompare(b.groupId));
+  for (const e of out) e.sources.sort((a, b) => a.sessionId.localeCompare(b.sessionId));
   return out;
 }

package/yeaft/dream-v2/prompts/{extract-group.md → extract-session.md}

@@ -1,23 +1,23 @@
-# Dream Extract — Group Scope
+# Dream Extract — Session Scope
 
 You are extracting **memory segments** from a conversation between the
 user and a Yeaft AI companion. This pass focuses on a specific
-**`group/<id>` scope**: long-lived facts about one collaboration group
+**`session/<id>` scope**: long-lived facts about one collaboration session
 (a project team, a study cohort, a working set of people/agents).
 
-The target group id is provided as `{{groupId}}`.
+The target session id is provided as `{{sessionId}}`.
 
-## What to extract for `group/<id>` scope
+## What to extract for `session/<id>` scope
 
-- **purpose** — what this group exists to do, its charter / mission
-- **members** — people, VPs, and roles in the group, and what each is
+- **purpose** — what this session exists to do, its charter / mission
+- **members** — people, VPs, and roles in the session, and what each is
   responsible for
-- **conventions** — how the group works (rituals, cadences, naming,
+- **conventions** — how the session works (rituals, cadences, naming,
   channels, languages used)
 - **shared decisions** — durable agreements ("we ship on Fridays",
   "all PRs need two reviewers")
-- **shared context** — domain knowledge the whole group relies on
-- **relations** — other groups, features, or topics this group owns or
+- **shared context** — domain knowledge the whole session relies on
+- **relations** — other sessions, features, or topics this session owns or
   depends on
 - **lessons** — collective takeaways ("we tried X in Q1, it didn't
   scale, switched to Y")
@@ -28,7 +28,7 @@ The target group id is provided as `{{groupId}}`.
 - Single-VP traits — those go to that VP's `vp/<id>` scope.
 - Feature-specific implementation detail — those go to
   `feature/<id>` scope.
-- Transient status updates — only durable group facts.
+- Transient status updates — only durable session facts.
 
 ## Segment shape
 
@@ -45,7 +45,7 @@ Reply with a JSON array of segment objects:
     "kind": "decision",
     "tags": ["process", "review"],
     "sourceMessages": ["m_201"],
-    "body": "Group {{groupId}} decided every PR touching the payments
+    "body": "Session {{sessionId}} decided every PR touching the payments
     module needs sign-off from both the security VP and the payments
     feature owner before merge. Rationale: a near-miss in March."
   }
@@ -54,4 +54,4 @@ Reply with a JSON array of segment objects:
 
 `kind` ∈ {`fact`, `preference`, `decision`, `lesson`, `relation`,
 `goal`, `context`}. `scope` is filled in by the runner — do not include
-it. If nothing group-scope is in this batch, return `[]`.
+it. If nothing session-scope is in this batch, return `[]`.

package/yeaft/dream-v2/prompts/index.js

@@ -20,7 +20,7 @@ const FILES = {
   // H2.e — per-scope segment extraction prompts (one per scope family)
   extractUser: 'extract-user.md',
   extractVp: 'extract-vp.md',
-  extractGroup: 'extract-group.md',
+  extractSession: 'extract-session.md',
   extractTopic: 'extract-topic.md',
   // H2.e — per-scope summary compression
   summarizeScope: 'summarize-scope.md',
@@ -46,10 +46,10 @@ export function extractTemplateForScope(scope) {
   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 'extractGroup';
+  if (scope.startsWith('group/')) return 'extractSession';
   // Chat-isolated scopes: same template family as groups.
   if (/^chat\/[^/]+\/vp\//.test(scope)) return 'extractVp';
-  if (scope.startsWith('chat/')) return 'extractGroup';
+  if (scope.startsWith('chat/')) return 'extractSession';
   // Legacy top-level vp/topic scopes (archived to .legacy/ on boot — kept
   // here defensively in case something still constructs the old strings).
   if (scope.startsWith('vp/')) return 'extractVp';

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

@@ -4,7 +4,7 @@ You are deciding whether a recent group conversation carries:
 
 Do NOT mention vp/, group/, or feature/ scopes — those are handled by hard rules.
 
-Group: {{groupId}}
+Session: {{sessionId}}
 
 Existing topic scopes (path — summary):
 {{topicSummaries}}

package/yeaft/dream-v2/runner.js

@@ -5,12 +5,12 @@
  *
  *   trigger
  *     ↓
- *   enumerateGroups()                  via opts.listGroups()
+ *   enumerateGroups()                  via opts.listSessions()
  *     ↓
  *   for each group with newCount ≥ MIN_NEW_PER_GROUP (auto)
  *                    or > 0 (manual)
  *                    or prior messages in a scoped manual group rerun:
- *       loadDiff()                     via opts.loadGroupDiff(groupId, sinceId)
+ *       loadDiff()                     via opts.loadGroupDiff(sessionId, sinceId)
  *       applyOverlap()                 via opts.loadOverlapPreamble(...)
  *       segment()                      segmentDiff(...)
  *       triageGroupSegments()          → group-local actions[]
@@ -58,10 +58,10 @@ 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 group triggers rerun the current group 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>>} listGroups   — return all group ids (incl. '_no-group')
- * @property {(groupId: string) => Promise<number>} countMessages   — total message count for a group
- * @property {(groupId: string, sinceMessageId: string|null) => Promise<Array<object>>} loadGroupDiff
- * @property {(groupId: string, beforeMessageId: string|null, count: number) => Promise<Array<object>>} loadOverlapPreamble
+ * @property {() => Promise<Array<string>>} listSessions   — return all group 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
  * @property {() => Promise<Array<{path:string, summary:string}>>} [listTopicSummaries]
  * @property {(target: string) => Promise<Array<{path:string, summary:string}>>} [siblingTopicsFor]
  * @property {(event: object) => void} [onProgress]
@@ -87,7 +87,7 @@ export async function runDream(opts) {
   onProgress({ phase: 'start', manual: !!opts.manual, ts });
 
   // 1. enumerate groups
-  const groupIds = await safeCall(opts.listGroups, []);
+  const sessionIds = await safeCall(opts.listSessions, []);
   const filter = Array.isArray(opts.scopeFilter) ? new Set(opts.scopeFilter) : null;
   const groupFilter = deriveGroupFilter(filter);
   const groupsReport = [];
@@ -97,53 +97,53 @@ export async function runDream(opts) {
   // 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.
-  const resolveTopicSummaries = async (groupId) => {
+  const resolveTopicSummaries = async (sessionId) => {
     if (opts.listTopicSummaries) {
-      return await safeCall(() => opts.listTopicSummaries(groupId), []);
+      return await safeCall(() => opts.listTopicSummaries(sessionId), []);
     }
-    return await defaultListTopicSummaries(opts.root, groupId, opts.language).catch(() => []);
+    return await defaultListTopicSummaries(opts.root, sessionId, opts.language).catch(() => []);
   };
 
-  for (const groupId of groupIds) {
+  for (const sessionId of sessionIds) {
     // Current-group 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(groupId)) {
-      groupsReport.push({ groupId, new: 0, status: 'skipped', reason: 'scope-filtered' });
+    if (groupFilter && !groupFilter.has(sessionId)) {
+      groupsReport.push({ sessionId, new: 0, status: 'skipped', reason: 'scope-filtered' });
       continue;
     }
-    const state = await readGroupState(opts.root, groupId);
-    const beforeCount = await safeCall(() => opts.countMessages(groupId), 0);
+    const state = await readGroupState(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(groupId)
+      && groupFilter.has(sessionId)
       && newCount === 0
       && beforeCount > 0;
 
     if (newCount === 0 && !rerunScopedManual) {
-      groupsReport.push({ groupId, new: 0, status: 'skipped', reason: 'no-new-messages' });
+      groupsReport.push({ sessionId, new: 0, status: 'skipped', reason: 'no-new-messages' });
       continue;
     }
     if (!opts.manual && newCount < limits.MIN_NEW_PER_GROUP) {
-      groupsReport.push({ groupId, new: newCount, status: 'skipped', reason: 'below-threshold' });
+      groupsReport.push({ sessionId, new: newCount, status: 'skipped', reason: 'below-threshold' });
       continue;
     }
 
-    onProgress({ phase: 'load-diff', groupId });
+    onProgress({ phase: 'load-diff', sessionId });
     const diffCursor = rerunScopedManual ? null : state.lastDreamMessageId;
-    const diffNew = await safeCall(() => opts.loadGroupDiff(groupId, diffCursor), []);
+    const diffNew = await safeCall(() => opts.loadGroupDiff(sessionId, diffCursor), []);
     if (!diffNew || diffNew.length === 0) {
-      groupsReport.push({ groupId, new: newCount, status: 'skipped', reason: 'empty-diff' });
+      groupsReport.push({ sessionId, new: newCount, status: 'skipped', reason: 'empty-diff' });
       continue;
     }
     const overlapMessages = state.lastDreamMessageId && !rerunScopedManual
       ? await safeCall(
           () => opts.loadOverlapPreamble
-            ? opts.loadOverlapPreamble(groupId, state.lastDreamMessageId, limits.DREAM_OVERLAP)
+            ? opts.loadOverlapPreamble(sessionId, state.lastDreamMessageId, limits.DREAM_OVERLAP)
             : [],
           [],
         )
@@ -153,13 +153,13 @@ export async function runDream(opts) {
     const fullDiff = [...taggedOverlap, ...taggedNew];
 
     const segments = segmentDiff(fullDiff, limits.MAX_DIFF_TOKENS_PER_TRIAGE, limits.DREAM_OVERLAP);
-    onProgress({ phase: 'triage', groupId, status: 'running', segments: segments.length });
+    onProgress({ phase: 'triage', sessionId, status: 'running', segments: segments.length });
 
     let actions;
     try {
-      const topicSummaries = await resolveTopicSummaries(groupId);
+      const topicSummaries = await resolveTopicSummaries(sessionId);
       actions = await triageGroupSegments({
-        groupId,
+        sessionId,
         segments,
         topicSummaries,
         llm: opts.llm,
@@ -167,12 +167,12 @@ export async function runDream(opts) {
         language: opts.language,
       });
     } catch (err) {
-      groupsReport.push({ groupId, new: newCount, status: 'error', error: err.message });
-      onProgress({ phase: 'triage', groupId, status: 'error', error: err.message });
+      groupsReport.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/${groupId}`, {
+      await writeDreamError(opts.root, `group/${sessionId}`, {
         phase: 'triage',
         message: err.message,
         stack: err.stack,
@@ -180,12 +180,12 @@ export async function runDream(opts) {
       continue;
     }
 
-    onProgress({ phase: 'triage', groupId, status: 'done', actions: actions.length });
-    groupTriages.push({ groupId, diff: fullDiff, actions });
+    onProgress({ phase: 'triage', sessionId, status: 'done', actions: actions.length });
+    groupTriages.push({ sessionId, diff: fullDiff, actions });
 
     const tailId = lastMessageId(diffNew);
-    processedGroups.push({ groupId, tailId, beforeCount, newCount, segments: segments.length, actions: actions.length });
-    groupsReport.push({ groupId, new: newCount, segments: segments.length, actions: actions.length, status: 'triaged', rerun: rerunScopedManual || undefined });
+    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 });
   }
 
   // 3. merge
@@ -238,12 +238,12 @@ export async function runDream(opts) {
   // 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.groupId === pg.groupId) || { actions: [] })
+    const contributed = (groupTriages.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.groupId, {
+      await writeGroupState(opts.root, pg.sessionId, {
         lastDreamMessageId: pg.tailId,
         lastDreamAt: nowIso,
         messageCount: pg.beforeCount,
@@ -297,7 +297,7 @@ function deriveGroupFilter(filter) {
 
 function sourceGroupId(mergedTarget) {
   const src = Array.isArray(mergedTarget?.sources) ? mergedTarget.sources[0] : null;
-  return src && typeof src.groupId === 'string' ? src.groupId : '';
+  return src && typeof src.sessionId === 'string' ? src.sessionId : '';
 }
 
 async function safeCall(fn, fallback) {
@@ -310,12 +310,12 @@ async function safeCall(fn, fallback) {
   }
 }
 
-async function defaultListTopicSummaries(root, groupId, language) {
+async function defaultListTopicSummaries(root, sessionId, language) {
   const all = await listScopes({ root });
   const out = [];
   for (const sc of all) {
     if (sc.kind !== 'group-topic') continue;
-    if (sc.groupId !== groupId) continue;
+    if (sc.sessionId !== sessionId) continue;
     const summary = await readSummary(sc, { root, language });
     out.push({ path: sc.path.join('/'), summary });
   }

package/yeaft/dream-v2/segment.js

@@ -141,7 +141,7 @@ export function segmentDiff(diff, maxTokens = MAX_DIFF_TOKENS_PER_TRIAGE, overla
 /**
  * Decide whether a merged apply target needs to be split into batches.
  *
- * @param {{ memoryMd?: string, summaryMd?: string, sources: Array<{ groupId: string, diff: any }> }} merged
+ * @param {{ memoryMd?: string, summaryMd?: string, sources: Array<{ sessionId: string, diff: any }> }} merged
  * @param {number} [maxTokens=MAX_APPLY_TOKENS]
  */
 export function needsBatchedApply(merged, maxTokens = MAX_APPLY_TOKENS) {
@@ -165,9 +165,9 @@ function totalApplyTokens(merged) {
  * goes into its own batch — we never split a source diff here (segment
  * happens earlier, in triage).
  *
- * @param {{ memoryMd?: string, summaryMd?: string, sources: Array<{ groupId: string, diff: any }> }} merged
+ * @param {{ memoryMd?: string, summaryMd?: string, sources: Array<{ sessionId: string, diff: any }> }} merged
  * @param {number} [maxTokens=MAX_APPLY_TOKENS]
- * @returns {Array<{ groupId: string, diff: any }[]>}
+ * @returns {Array<{ sessionId: string, diff: any }[]>}
  */
 export function batchSourcesForApply(merged, maxTokens = MAX_APPLY_TOKENS) {
   const sources = Array.isArray(merged.sources) ? merged.sources : [];

package/yeaft/dream-v2/session-wiring.js

@@ -15,7 +15,7 @@
  * load-bearing for the debug panel. Renaming a field on this side
  * silently degrades that UI to a generic JSON dump.
  *
- *   dream_turn_open:   { type:'turn_open',  turnId, userPrompt, vpId, groupId, at }
+ *   dream_turn_open:   { type:'turn_open',  turnId, userPrompt, vpId, sessionId, at }
  *   dream_loop:        { type:'loop',       turnId, loopNumber, pass, model,
  *                        systemPrompt: string,
  *                        messages: [{ role:'user', content:string }],
@@ -35,19 +35,19 @@
  *                      `kind, memoryMdPreview, summaryMdPreview, memoryMdLength,
  *                      summaryMdLength` (see apply.js).
  *
- * `groupId` may be inherited via `stampDreamScope()` when a scope is active.
+ * `sessionId` may be inherited via `stampDreamScope()` when a scope is active.
  */
 
 import { join } from 'path';
 import { runDream } from './runner.js';
 import { createDreamScheduler } from './schedule.js';
-import { listGroups, openGroup } from '../groups/group-store.js';
+import { listSessions, openSession } from '../sessions/session-store.js';
 import { readGroupState } from './state.js';
 import { DREAM_NUDGE_AFTER_MESSAGES, DREAM_INTERVAL_HOURS } from './limits.js';
 
 /**
  * Build the per-call options for runDream. Pure: takes a session and returns
- * the closures runDream needs (listGroups, countMessages, loadGroupDiff, etc.).
+ * the closures runDream needs (listSessions, countMessages, loadGroupDiff, etc.).
  *
  * @param {Object} session  — the live Session object from loadSession()
  * @param {(event: object) => void} [onProgress]
@@ -56,19 +56,19 @@ import { DREAM_NUDGE_AFTER_MESSAGES, DREAM_INTERVAL_HOURS } from './limits.js';
 export function buildRunDreamOpts(session, onProgress) {
   const yeaftDir = session.yeaftDir;
   const memoryRoot = join(yeaftDir, 'memory');
-  const groupsRoot = join(yeaftDir, 'groups');
+  const sessionsRoot = join(yeaftDir, 'sessions');
 
   return {
     root: memoryRoot,
     language: session.config?.language || 'en',
     llm: makeLlm(session),
-    listGroups: async () => {
-      try { return listGroups(groupsRoot).map(g => g.id); }
+    listSessions: async () => {
+      try { return listSessions(sessionsRoot).map(g => g.id); }
       catch { return []; }
     },
     countMessages: async (gid) => {
       try {
-        const h = openGroup(groupsRoot, gid);
+        const h = openSession(sessionsRoot, gid);
         let n = 0;
         for (const _m of h.streamMessages()) n += 1;
         return n;
@@ -76,7 +76,7 @@ export function buildRunDreamOpts(session, onProgress) {
     },
     loadGroupDiff: async (gid, sinceId) => {
       try {
-        const h = openGroup(groupsRoot, gid);
+        const h = openSession(sessionsRoot, gid);
         const out = [];
         let started = !sinceId;
         for (const m of h.streamMessages()) {
@@ -91,7 +91,7 @@ export function buildRunDreamOpts(session, onProgress) {
     },
     loadOverlapPreamble: async (gid, beforeId, n) => {
       try {
-        const h = openGroup(groupsRoot, gid);
+        const h = openSession(sessionsRoot, gid);
         const buf = [];
         for (const m of h.streamMessages()) {
           if (m.id === beforeId) break;
@@ -199,8 +199,8 @@ function makeLlm(session) {
 
 function stampDreamScope(session, evt) {
   if (!evt || typeof evt !== 'object') return evt;
-  if (evt.groupId || !session?._dreamActiveGroupId) return evt;
-  return { ...evt, groupId: session._dreamActiveGroupId };
+  if (evt.sessionId || !session?._dreamActiveGroupId) return evt;
+  return { ...evt, sessionId: session._dreamActiveGroupId };
 }
 
 function finiteNumber(v) {
@@ -326,7 +326,7 @@ export function createV2DreamScheduler(session) {
       turnId,
       userPrompt: '[dream] automatic memory consolidation',
       vpId: null,
-      groupId: null,
+      sessionId: null,
       at: startedAt,
     });
     persistDreamTrace(session, 'dream_turn_open', turnOpen);
@@ -341,7 +341,7 @@ export function createV2DreamScheduler(session) {
     }).then((result) => {
       // Bug 2: emit turn_close when the dream pass completes.
       result.trigger = opts.manual ? 'manual' : 'auto';
-      if (session._dreamActiveGroupId && !result.groupId) result.groupId = session._dreamActiveGroupId;
+      if (session._dreamActiveGroupId && !result.sessionId) result.sessionId = session._dreamActiveGroupId;
       const metrics = finalizeDreamMetrics(session._dreamMetrics, Date.now() - startedAt);
       result.metrics = metrics;
       result.durationMs = metrics.durationMs;
@@ -449,9 +449,9 @@ export function createV2DreamScheduler(session) {
 export async function bootInitEmptyGroups(args) {
   const out = { triggered: [] };
   if (!args || !args.memoryIndex || !args.dreamScheduler) return out;
-  const groupsRoot = join(args.yeaftDir, 'groups');
+  const sessionsRoot = join(args.yeaftDir, 'sessions');
   let ids;
-  try { ids = listGroups(groupsRoot).map(g => g.id); }
+  try { ids = listSessions(sessionsRoot).map(g => g.id); }
   catch { return out; }
   const empty = [];
   for (const gid of ids) {
@@ -461,7 +461,7 @@ export async function bootInitEmptyGroups(args) {
     if (segCount > 0) continue;
     let hasMessages = false;
     try {
-      const h = openGroup(groupsRoot, gid);
+      const h = openSession(sessionsRoot, gid);
       // Any message at all is enough — pull the first record off the
       // iterator and stop.
       const first = h.streamMessages().next();
@@ -516,18 +516,18 @@ export async function bootCatchUpStaleDream(args) {
   if (!args || !args.dreamScheduler) return out;
 
   const memoryRoot = join(args.yeaftDir, 'memory');
-  const groupsRoot = join(args.yeaftDir, 'groups');
+  const sessionsRoot = join(args.yeaftDir, 'sessions');
   const intervalMs = (args.intervalHours ?? DREAM_INTERVAL_HOURS) * 60 * 60 * 1000;
   const now = args.now ?? Date.now();
 
-  let groupIds;
-  try { groupIds = listGroups(groupsRoot).map(g => g.id); }
+  let sessionIds;
+  try { sessionIds = listSessions(sessionsRoot).map(g => g.id); }
   catch { return out; }
 
   // Find the newest lastDreamAt across all groups.
   let newestAt = null;
   let anyTraffic = false;
-  for (const gid of groupIds) {
+  for (const gid of sessionIds) {
     let st;
     try { st = await readGroupState(memoryRoot, gid); }
     catch { continue; }
@@ -537,7 +537,7 @@ export async function bootCatchUpStaleDream(args) {
     }
     if (!anyTraffic) {
       try {
-        const h = openGroup(groupsRoot, gid);
+        const h = openSession(sessionsRoot, gid);
         const first = h.streamMessages().next();
         if (!first.done) anyTraffic = true;
       } catch { /* keep going */ }

package/yeaft/dream-v2/state.js

@@ -59,11 +59,11 @@ const DREAM_BLOCK_CLOSE = '<!-- /dream-state -->';
  * Read a group's .dream-state. Missing file → defaults.
  *
  * @param {string} root — memory root, e.g. ~/.yeaft/memory
- * @param {string} groupId
+ * @param {string} sessionId
  * @returns {Promise<{ lastDreamMessageId: string|null, lastDreamAt: string|null, messageCount: number }>}
  */
-export async function readGroupState(root, groupId) {
-  const abs = join(root, 'group', groupId, STATE_FILE);
+export async function readGroupState(root, sessionId) {
+  const abs = join(root, 'group', sessionId, STATE_FILE);
   const empty = { lastDreamMessageId: null, lastDreamAt: null, messageCount: 0 };
   let raw;
   try { raw = await fsp.readFile(abs, 'utf8'); }
@@ -76,11 +76,11 @@ export async function readGroupState(root, groupId) {
  * absent. Unknown fields are ignored.
  *
  * @param {string} root
- * @param {string} groupId
+ * @param {string} sessionId
  * @param {{ lastDreamMessageId?: string|null, lastDreamAt?: string|null, messageCount?: number }} state
  */
-export async function writeGroupState(root, groupId, state) {
-  const dir = join(root, 'group', groupId);
+export async function writeGroupState(root, sessionId, state) {
+  const dir = join(root, 'group', sessionId);
   await fsp.mkdir(dir, { recursive: true });
   const abs = join(dir, STATE_FILE);
   const body =
@@ -131,7 +131,7 @@ function parseGroupState(raw) {
 /**
  * Resolve a memoryRoot + scope-string to the scope directory.
  * The scope string is the same shape dream-v2 already uses internally:
- * `'user'`, `'vp/<vpId>'`, `'group/<groupId>'`, `'feature/<id>'`, etc.
+ * `'user'`, `'vp/<vpId>'`, `'group/<sessionId>'`, `'feature/<id>'`, etc.
  *
  * Pure path-join; does NOT create the directory. The writer creates it.
  *