@yeaft/webchat-agent 0.1.925 → 0.1.927

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.925",
+  "version": "0.1.927",
   "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}`;
+          const isThisGroup = evtGroupId === sessionId || target === `group/${sessionId}` || target === `session/${sessionId}`;
           if (!isBroadcast && !isThisGroup) continue;
         }
         dreamEvents.push({

package/yeaft/dream/state.js

@@ -6,7 +6,7 @@
  *   1. Per-group control state (used to decide whether a group enters
  *      triage and how far to advance the cursor):
  *
- *        ~/.yeaft/memory/group/<id>/.dream-state
+ *        ~/.yeaft/memory/session/<id>/.dream-state
  *
  *      A 3-line text file:
  *
@@ -18,7 +18,7 @@
  *      empty / null / 0. The file is rewritten atomically every dream.
  *
  *      The virtual `_no-group/` group lives at the same path layout
- *      (`group/_no-group/.dream-state`) and uses the same accessor.
+ *      (`session/_no-group/.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:
@@ -63,11 +63,19 @@ const DREAM_BLOCK_CLOSE = '<!-- /dream-state -->';
  * @returns {Promise<{ lastDreamMessageId: string|null, lastDreamAt: string|null, messageCount: number }>}
  */
 export async function readGroupState(root, sessionId) {
-  const abs = join(root, 'group', sessionId, STATE_FILE);
+  const abs = join(root, 'session', sessionId, STATE_FILE);
+  const legacyAbs = join(root, 'group', 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') return empty; throw err; }
+  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;
+    }
+  }
   return parseGroupState(raw);
 }
 
@@ -80,7 +88,7 @@ export async function readGroupState(root, sessionId) {
  * @param {{ lastDreamMessageId?: string|null, lastDreamAt?: string|null, messageCount?: number }} state
  */
 export async function writeGroupState(root, sessionId, state) {
-  const dir = join(root, 'group', sessionId);
+  const dir = join(root, 'session', sessionId);
   await fsp.mkdir(dir, { recursive: true });
   const abs = join(dir, STATE_FILE);
   const body =

package/yeaft/init.js

@@ -82,7 +82,6 @@ const SUBDIRS = [
   'chat/messages',
   'chat/cold',
   'chat/blobs',
-  'groups',
   'sessions',
   'memory/entries',
   'tasks',

package/yeaft/llm/router.js

@@ -193,7 +193,21 @@ export class AdapterRouter extends LLMAdapter {
    */
   constructor({ providers }) {
     super();
-    this.#providers = providers;
+    this.#providers = [];
+    this.#modelToProvider = new Map();
+    this.#adapterCache = new Map();
+    this.refreshProviders(providers);
+  }
+
+  /**
+   * Replace the provider/model index after config.json changes. Existing
+   * provider adapters are dropped because credentials, baseUrl, protocol,
+   * or model ownership may have changed along with the list.
+   *
+   * @param {object[]} providers
+   */
+  refreshProviders(providers) {
+    this.#providers = Array.isArray(providers) ? providers : [];
     this.#modelToProvider = new Map();
     this.#adapterCache = new Map();
 
@@ -201,7 +215,7 @@ export class AdapterRouter extends LLMAdapter {
     // model id appears in multiple providers. Each model entry may declare
     // its own `protocol`; we keep the normalized entry so #effectiveProtocol
     // can consult it later without re-parsing.
-    for (const provider of providers) {
+    for (const provider of this.#providers) {
       if (!Array.isArray(provider.models)) continue;
       for (const raw of provider.models) {
         const entry = normalizeModelEntry(raw);

package/yeaft/migrate/sessions.js

@@ -43,6 +43,7 @@ import {
   readFileSync,
   renameSync,
   statSync,
+  rmSync,
   unlinkSync,
   writeFileSync,
 } from 'fs';
@@ -50,7 +51,7 @@ import { join } from 'path';
 import { openSegmentIndex } from '../memory/index-db.js';
 
 const SENTINEL = '.yeaft-migration.done';
-const SENTINEL_VERSION = 2;
+const SENTINEL_VERSION = 3;
 
 /**
  * Run the sessions migration. No-op when sentinel exists.
@@ -216,9 +217,13 @@ export function migrateSessions(yeaftDir) {
   //    so that any pre-rename row still on disk gets the new key shape.
   const frontmatterRewrites = rewriteAllMessageFrontmatter(yeaftDir, warnings);
 
-  // 8. Sentinel — version 2 = this consolidated migration (covers what the
-  //    old `.session-migration-v1.done` sentinel covered plus the frontmatter
-  //    rewrite).
+  // 8. Cleanup: if this is rerunning after a v2 sentinel, legacy groups/ or
+  //    chats/ directories may have been recreated. Merge non-duplicate files
+  //    into sessions/<id>, then remove empty legacy directories.
+  const cleanup = cleanupLegacySessionDirs(yeaftDir, warnings);
+  moved += cleanup.moved;
+
+  // 9. Sentinel — version 3 = consolidated migration plus legacy cleanup.
   writeFileSync(sentinel, JSON.stringify({
     version: SENTINEL_VERSION,
     migratedAt: new Date().toISOString(),
@@ -410,6 +415,58 @@ function listDirs(root) {
   return out;
 }
 
+function cleanupLegacySessionDirs(yeaftDir, warnings) {
+  const sessionsRoot = join(yeaftDir, 'sessions');
+  let moved = 0;
+  for (const legacyName of ['groups', 'chats']) {
+    const legacyRoot = join(yeaftDir, legacyName);
+    if (!existsSync(legacyRoot)) continue;
+    for (const id of listDirs(legacyRoot)) {
+      const src = join(legacyRoot, id);
+      const dst = join(sessionsRoot, id);
+      if (!existsSync(dst)) continue;
+      mergeLegacyDirIntoSession(src, dst, warnings, `${legacyName}/${id}`);
+      removeDirIfEmpty(src, warnings, `${legacyName}/${id}`);
+      if (!existsSync(src)) moved++;
+    }
+    removeDirIfEmpty(legacyRoot, warnings, legacyName);
+  }
+  return { moved };
+}
+
+function mergeLegacyDirIntoSession(src, dst, warnings, label) {
+  if (!existsSync(src) || !existsSync(dst)) return;
+  let entries = [];
+  try { entries = readdirSync(src, { withFileTypes: true }); }
+  catch (err) { warnings.push(`${label}: failed to scan legacy dir: ${err.message}`); return; }
+
+  for (const ent of entries) {
+    const from = join(src, ent.name);
+    const to = join(dst, ent.name);
+    if (!existsSync(to)) {
+      try { renameSync(from, to); }
+      catch (err) { warnings.push(`${label}: failed to move ${ent.name}: ${err.message}`); }
+      continue;
+    }
+    if (ent.isDirectory()) {
+      mergeLegacyDirIntoSession(from, to, warnings, `${label}/${ent.name}`);
+      removeDirIfEmpty(from, warnings, `${label}/${ent.name}`);
+    } else {
+      warnings.push(`${label}: kept duplicate legacy file ${ent.name}`);
+    }
+  }
+}
+
+function removeDirIfEmpty(dir, warnings, label) {
+  if (!existsSync(dir)) return;
+  try {
+    const entries = readdirSync(dir);
+    if (entries.length === 0) rmSync(dir, { recursive: true, force: true });
+  } catch (err) {
+    warnings.push(`${label}: failed to remove empty legacy dir: ${err.message}`);
+  }
+}
+
 function rewriteGroupMetaToSessionMeta(sessionDir, warnings) {
   const oldPath = join(sessionDir, 'group.json');
   const newPath = join(sessionDir, 'meta.json');

package/yeaft/sessions/ids.js

@@ -40,13 +40,13 @@ export function nextMsgId() {
 export function nextSessionId(slug = 'default') {
   // Slug-tolerant: lowercase a-z0-9_- only, capped at 24 chars so the
   // total id stays compact after the suffix is appended.
-  const safe = String(slug).toLowerCase().replace(/[^a-z0-9_-]+/g, '-').slice(0, 24) || 'group';
+  const safe = String(slug).toLowerCase().replace(/[^a-z0-9_-]+/g, '-').slice(0, 24) || 'session';
   // Append 8 crockford-base32 chars (~40 bits) so re-creating a session
   // with the same display name yields a fresh id instead of throwing
   // `duplicate` on the existsSync check in session-crud.js. The
   // `duplicate` branch is now a true defensive guard rather than the
   // first-collision footgun it used to be.
-  return `grp_${safe}_${randEncoded(8)}`;
+  return `session_${safe}_${randEncoded(8)}`;
 }
 
 /**

package/yeaft/sessions/seed-default.js

@@ -1,14 +1,14 @@
 /**
- * seed-default.js — First-boot default group (architecture §10 D1).
+ * seed-default.js — First-boot default session (architecture §10 D1).
  *
- * When multi-VP mode is first enabled for a user, seed a default group with
- * the provided roster (typically `[defaultVpId]`). Idempotent: if the group
+ * When multi-VP mode is first enabled for a user, seed a default session with
+ * the provided roster (typically `[defaultVpId]`). Idempotent: if the session
  * already exists on disk, returns the existing handle without overwriting.
  *
  * Separation from group-store.createSession:
  *   - createSession throws on duplicate; seed returns the existing handle.
- *   - seed picks a stable id `grp_default` so UI can deep-link to it.
- *   - seed is the only place that writes the "default group exists" side
+ *   - seed picks a stable id `session_default` so UI can deep-link to it.
+ *   - seed is the only place that writes the "default session exists" side
  *     effect during the bootstrap flow.
  */
 
@@ -18,20 +18,20 @@ import { homedir } from 'os';
 import { openSession, createSession, loadSessionMeta } from './session-store.js';
 import { seedSummaryIfMissingSync } from '../memory/store.js';
 
-export const DEFAULT_SESSION_ID = 'grp_default';
+export const DEFAULT_SESSION_ID = 'session_default';
 
 /**
  * Default memory root used when callers don't pass `options.memoryRoot`.
- * See `groups/group-crud.js` and `vp/vp-crud.js` for the same default;
+ * See `sessions/session-crud.js` and `vp/vp-crud.js` for the same default;
  * production code threads `<yeaftDir>/memory` through to keep test/prod
  * isolation honest.
  */
 const DEFAULT_MEMORY_ROOT = join(homedir(), '.yeaft', 'memory');
 
 /**
- * Build the default-group seed summary body. Pulled into a helper so
+ * Build the default-session seed summary body. Pulled into a helper so
  * tests can pin the exact format. Mirrors `buildSessionSeedSummary` in
- * `group-crud.js` shape, with the "Default group" wording reserved for
+ * `session-crud.js` shape, with the "Default session" wording reserved for
  * the bootstrap path.
  *
  * @param {{ name?: string, roster?: string[], defaultVpId?: string|null }} spec
@@ -42,7 +42,7 @@ export function buildDefaultSessionSeedSummary(spec) {
   const roster = Array.isArray(spec?.roster) ? spec.roster : [];
   const defaultVpId = spec?.defaultVpId || null;
   const lines = [`# ${name}`, ''];
-  lines.push(`Default group with ${roster.length} member${roster.length === 1 ? '' : 's'}.`);
+  lines.push(`Default session with ${roster.length} member${roster.length === 1 ? '' : 's'}.`);
   if (roster.length > 0) lines.push('', `**Members:** ${roster.join(', ')}`);
   if (defaultVpId) lines.push('', `**Default VP:** ${defaultVpId}`);
   return lines.join('\n').trim();
@@ -77,7 +77,7 @@ export function seedDefaultSession(yeaftDir, spec = {}) {
   });
 
   // Seed Layer-A resident summary so the very first session — even on a
-  // brand-new install where only `grp_default` exists — renders a non-
+  // brand-new install where only `session_default` exists — renders a non-
   // empty memory section in the system prompt. No-op once Dream-v2 (or
   // createSessionFromSpec) has already written one. Best-effort: a memory-
   // root permission failure must NOT break the bootstrap flow.

package/yeaft/sessions/session-crud.js

@@ -1,17 +1,17 @@
 /**
- * group-crud.js — High-level Group CRUD API (task-334m).
+ * session-crud.js — High-level Session CRUD API (task-334m).
  *
- * Wraps the primitives from group-store.js + roster.js into the 5 operations
+ * Wraps the primitives from session-store.js + roster.js into the 5 operations
  * wired to WS events (§Δ10 334m + R6 §Δ31.2):
- *   createSessionFromSpec  — wizard "create new group" (empty or user-picked roster)
+ *   createSessionFromSpec  — wizard "create new session" (empty or user-picked roster)
  *   renameSession          — update meta.name; preserves roster / defaultVpId
  *   archiveSession         — rename dir to `.archived-<ts>-<id>` (soft delete)
  *   addMember            — roster.addVp + save; sets defaultVpId if first
  *   removeMember         — roster.removeVp + save; clears/rotates defaultVpId
  *
  * Plus the D1 bootstrap helper:
- *   ensureDefaultSessionIfEmpty(yeaftDir, {libDir}) — if NO group exists on
- *   disk, seed `grp_default` with roster = every VP in the library, and
+ *   ensureDefaultSessionIfEmpty(yeaftDir, {libDir}) — if NO session exists on
+ *   disk, seed `session_default` with roster = every VP in the library, and
  *   defaultVpId = alphabetically first vpId. No-op when ≥1 group present.
  *
  * Hard constraints (PM):
@@ -250,21 +250,21 @@ export function resolveSessionYeaftDir(defaultYeaftDir, sessionId) {
 
 /** Build a safe group id from a display name (slug + ulid-lite suffix). */
 export function makeSessionId(name) {
-  const slug = String(name || 'group')
+  const slug = String(name || 'session')
     .toLowerCase()
     .replace(/[^a-z0-9]+/g, '-')
     .replace(/^-+|-+$/g, '')
-    .slice(0, 24) || 'group';
+    .slice(0, 24) || 'session';
   return nextSessionId(slug);
 }
 
 /**
  * (B) D1 seed — called at boot (or when multi-VP is first enabled). Idempotent:
- * returns `{seeded:false}` if any group already exists on disk (including
- * `grp_default`). When empty, seeds with roster = full VP library, sorted
+ * returns `{seeded:false}` if any session already exists on disk (including
+ * `session_default`). When empty, seeds with roster = full VP library, sorted
  * alphabetically; defaultVpId = roster[0].
  *
- * When the VP library is also empty, we still seed an empty-roster group so
+ * When the VP library is also empty, we still seed an empty-roster session so
  * the UI has somewhere to land — but defaultVpId is null and downstream
  * message send will return `no_default_vp` until the user adds a VP.
  */
@@ -355,7 +355,7 @@ export function createSessionFromSpec(yeaftDir, spec, options = {}) {
       saveSessionConfig(yeaftDir, id, spec.config);
     }
   } catch (err) {
-    console.warn(`[group-crud] failed to seed config.json for ${id}:`, err?.message || err);
+    console.warn(`[session-crud] failed to seed config.json for ${id}:`, err?.message || err);
   }
 
   // Seed Layer-A resident summary so the first session has memory content
@@ -363,12 +363,12 @@ export function createSessionFromSpec(yeaftDir, spec, options = {}) {
   // Best-effort: a memory-root permission failure must NOT break group create.
   try {
     seedSummaryIfMissingSync(
-      { kind: 'group', id },
+      { kind: 'session', id },
       buildSessionSeedSummary({ name, roster, defaultVpId }),
       { root: memoryRoot },
     );
   } catch (err) {
-    console.warn(`[group-crud] failed to seed summary.md for ${id}:`, err?.message || err);
+    console.warn(`[session-crud] failed to seed summary.md for ${id}:`, err?.message || err);
   }
 
   return meta;
@@ -501,9 +501,12 @@ export function deleteSession(yeaftDir, sessionId, options = {}) {
   // 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(`[group-crud] failed to remove memory dir for ${sessionId}:`, err?.message || err);
+    console.warn(`[session-crud] failed to remove memory dir for ${sessionId}:`, err?.message || err);
   }
 
   unregisterSessionWorkDir(yeaftDir, sessionId);
@@ -516,9 +519,9 @@ export function deleteSession(yeaftDir, sessionId, options = {}) {
 }
 
 /**
- * Sweep any leftover `.archived-*` directories under groups/ that are
+ * Sweep any leftover `.archived-*` directories under sessions/ that are
  * orphans of the old soft-archive flow. Used at boot so users don't see
- * ghost groups in subsequent loads. Returns the list of removed paths.
+ * ghost sessions in subsequent loads. Returns the list of removed paths.
  */
 export function purgeArchivedSessions(yeaftDir) {
   const root = sessionsRoot(yeaftDir);

package/yeaft/web-bridge.js

@@ -23,6 +23,7 @@ import { existsSync } from 'node:fs';
 import { randomUUID } from 'node:crypto';
 import { Engine } from './engine.js';
 import { loadSession } from './session.js';
+import { loadConfig } from './config.js';
 import { sendToServer } from '../connection/buffer.js';
 import ctx from '../context.js';
 import { hydrateYeaftStatusFromSession } from './status-cache.js';
@@ -69,6 +70,26 @@ let session = null;
 
 let threadClassifier = defaultClassifyThread;
 
+function refreshLiveSessionConfig() {
+  if (!session) return;
+  try {
+    const freshConfig = loadConfig({ dir: session.yeaftDir || ctx.CONFIG?.yeaftDir });
+    const freshModels = Array.isArray(freshConfig.availableModels) ? freshConfig.availableModels : [];
+    session.config.availableModels = freshModels;
+    if (freshConfig.model && !freshModels.some(m => m?.id === session.config.model)) {
+      session.config.model = freshConfig.model;
+    }
+    if (freshConfig.providers) {
+      session.config.providers = freshConfig.providers;
+      if (typeof session.adapter?.refreshProviders === 'function') {
+        session.adapter.refreshProviders(freshConfig.providers);
+      }
+    }
+  } catch (err) {
+    console.warn('[Yeaft] refresh live session config failed:', err?.message || err);
+  }
+}
+
 /** Test-only: replace the lightweight VP thread classifier. */
 export function __testSetThreadClassifier(fn) {
   threadClassifier = typeof fn === 'function' ? fn : defaultClassifyThread;
@@ -3728,6 +3749,7 @@ export function handleYeaftModeSwitch(_msg) {
 /** Handle model switch from the web UI. */
 export function handleYeaftModelSwitch(msg) {
   if (!session || !msg.model) return;
+  refreshLiveSessionConfig();
 
   const available = session.config.availableModels || [];
   const found = available.some(m => m.id === msg.model);
@@ -3774,6 +3796,7 @@ export async function handleYeaftLoadHistory(msg) {
     installYeaftRuntimeBridge(session);
 
     yeaftConversationId = `yeaft-${Date.now()}`;
+    refreshLiveSessionConfig();
     hydrateYeaftStatusFromSession(session, { reason: 'history_load', emitEvent: true });
 
     // Per-group history hydrates lazily via getOrCreateSessionHistory.
@@ -3782,7 +3805,12 @@ export async function handleYeaftLoadHistory(msg) {
     // it doesn't (legacy callers), do nothing — the per-group lazy
     // hydration handles it.
     if (sessionId) setGroupHistory(sessionId, hydrateGroupHistory(sessionId));
-  } else if (sessionId) {
+  } else {
+    refreshLiveSessionConfig();
+    hydrateYeaftStatusFromSession(session, { reason: 'history_load', emitEvent: true });
+  }
+
+  if (sessionId) {
     // Re-entering an existing session with a (possibly new) group filter:
     // re-seed THIS group's history from disk so it doesn't carry stale
     // in-memory state into the next turn's context.