@yeaft/webchat-agent 0.1.924 → 0.1.926

package/index.js

@@ -324,10 +324,22 @@ process.on('SIGTERM', () => {
   process.exit(0);
 });
 
-// 启动 - 先确保依赖，再检测能力，再连接
+// 启动 - 先确保依赖，再检测能力，预热 models.dev 缓存，再连接
 (async () => {
   await ensureDependencies();
   await ensureYeaftSkills();
   ctx.agentCapabilities = await detectCapabilities();
+  // Prime the models.dev community catalog so the Yeaft engine's *synchronous*
+  // hot path (engine.js / config.js / cli.js all read context-window inline)
+  // can resolve real per-model limits without bubbling async up through every
+  // call site. Failure here is non-fatal: stale disk cache → DEFAULT 200K
+  // fall-through keeps the agent boot-able offline.
+  try {
+    const { fetchModelsDev } = await import('./yeaft/llm/models-dev.js');
+    await fetchModelsDev({ yeaftDir: YEAFT_DIR });
+    console.log('[Agent] models.dev cache primed');
+  } catch (err) {
+    console.warn(`[Agent] models.dev prime failed (will use config/defaults): ${err?.message || err}`);
+  }
   connect();
 })();

package/package.json

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

package/yeaft/cli.js

@@ -28,7 +28,7 @@ import { join } from 'path';
 import { loadConfig } from './config.js';
 import { DebugTrace } from './debug-trace.js';
 import { loadSession } from './session.js';
-import { listModels, resolveModel, parseModelRef } from './models.js';
+import { listModels, resolveModel, parseModelRef, resolveContextWindow, resolveMaxOutputTokens } from './models.js';
 import { buildSystemPrompt } from './prompts.js';
 import { searchMessages } from './conversation/search.js';
 import { ConversationStore } from './conversation/persist.js';
@@ -488,13 +488,15 @@ async function runREPL(config, args) {
                 session.config.model = modelRef;
               }
 
-              // Re-resolve model info from registry
+              // Re-resolve model info from registry (adapter / baseUrl /
+              // thinking metadata). Token limits come from the resolver
+              // ladder — models.dev snapshot first, config fallback.
               const newModelInfo = resolveModel(session.config.model);
               if (newModelInfo) {
-                session.config.maxContextTokens = newModelInfo.contextWindow;
-                session.config.maxOutputTokens = newModelInfo.maxOutputTokens;
                 session.config.modelInfo = newModelInfo;
               }
+              session.config.maxContextTokens = resolveContextWindow(session.config.model, session.config);
+              session.config.maxOutputTokens = resolveMaxOutputTokens(session.config.model, session.config);
               const providerStr = providerName ? ` (provider: ${providerName})` : '';
               console.log(`Model switched to: ${session.config.model}${providerStr}`);
               console.log('Note: Model change takes effect on next query.');
@@ -766,6 +768,19 @@ async function runOnce(config, args) {
 async function main() {
   const args = parseArgs(process.argv);
 
+  // Prime the models.dev community catalog so resolveContextWindow /
+  // resolveMaxOutputTokens — called synchronously from loadConfig and the
+  // engine hot path — can return real per-model limits instead of falling
+  // through to DEFAULT. Failure is non-fatal: stale disk cache or DEFAULT
+  // keeps the CLI usable offline. Mirrors the prime in agent/index.js.
+  try {
+    const { fetchModelsDev } = await import('./llm/models-dev.js');
+    const dir = args.dir || process.env.YEAFT_DIR || null;
+    await fetchModelsDev({ yeaftDir: dir });
+  } catch {
+    // best-effort; resolver falls back to config / DEFAULT.
+  }
+
   // Load config with CLI overrides (for --trace queries and dry-run, no session needed)
   const config = loadConfig({
     model: args.model,

package/yeaft/config.js

@@ -22,7 +22,7 @@
 import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 import { DEFAULT_YEAFT_DIR } from './init.js';
-import { resolveModel, parseModelRef, normalizeProviderModels } from './models.js';
+import { resolveModel, parseModelRef, normalizeProviderModels, resolveContextWindow, resolveMaxOutputTokens } from './models.js';
 
 /** Default configuration values. */
 const DEFAULTS = {
@@ -250,8 +250,15 @@ function loadLegacyConfig(dir, overrides) {
     if (modelInfo) {
       config.adapter = modelInfo.adapter === 'anthropic' ? 'anthropic' : 'openai';
       if (!config.baseUrl) config.baseUrl = modelInfo.baseUrl;
-      if (config.maxContextTokens === DEFAULTS.maxContextTokens) config.maxContextTokens = modelInfo.contextWindow;
-      if (config.maxOutputTokens === DEFAULTS.maxOutputTokens) config.maxOutputTokens = modelInfo.maxOutputTokens;
+      // Resolve token limits via the resolver ladder (models.dev → config →
+      // DEFAULT). Only fill in when the caller left the slot at the default
+      // — explicit env / CLI overrides win.
+      if (config.maxContextTokens === DEFAULTS.maxContextTokens) {
+        config.maxContextTokens = resolveContextWindow(config.model, config);
+      }
+      if (config.maxOutputTokens === DEFAULTS.maxOutputTokens) {
+        config.maxOutputTokens = resolveMaxOutputTokens(config.model, config);
+      }
     } else {
       if (config.apiKey) config.adapter = 'anthropic';
       else if (config.openaiApiKey) config.adapter = 'openai';
@@ -305,9 +312,19 @@ export function loadConfig(overrides = {}) {
     fastModelId = parsed.modelId;
   }
 
-  // Resolve model info for context window / output limits
+  // Resolve model info for adapter/baseUrl/thinking metadata. Token limits
+  // (contextWindow / maxOutputTokens) are NOT read from here — they live in
+  // models.dev and are resolved via resolveContextWindow / resolveMaxOutputTokens
+  // a few lines below so the live models.dev snapshot is the source of truth.
   const modelInfo = resolveModel(model);
 
+  // Pre-resolve token limits once so we can both write them onto config and
+  // pass `config` to the resolver chain consistently below.
+  const resolvedMaxContext = overrides.maxContextTokens ?? jsonConfig.maxContextTokens
+    ?? resolveContextWindow(model, { modelInfo });
+  const resolvedMaxOutput = overrides.maxOutputTokens ?? jsonConfig.maxOutputTokens
+    ?? resolveMaxOutputTokens(model, { modelInfo });
+
   const config = {
     // Model
     model: overrides.model || model,
@@ -325,9 +342,16 @@ export function loadConfig(overrides = {}) {
     debug: overrides.debug !== undefined ? overrides.debug : (jsonConfig.debug ?? DEFAULTS.debug),
     dir,
 
-    // Token limits
-    maxContextTokens: overrides.maxContextTokens ?? jsonConfig.maxContextTokens ?? modelInfo?.contextWindow ?? DEFAULTS.maxContextTokens,
-    maxOutputTokens: overrides.maxOutputTokens ?? jsonConfig.maxOutputTokens ?? modelInfo?.maxOutputTokens ?? DEFAULTS.maxOutputTokens,
+    // Token limits. Resolution order:
+    //   1. CLI override (overrides.*)
+    //   2. ~/.yeaft/config.json explicit value
+    //   3. resolveContextWindow / resolveMaxOutputTokens — which themselves
+    //      walk: per-provider override → models.dev snapshot → DEFAULT.
+    // Anything that needs the *live* number for a model the user picks at
+    // runtime (mid-session model switch, e.g.) should call the resolvers
+    // directly rather than read these fields.
+    maxContextTokens: resolvedMaxContext,
+    maxOutputTokens: resolvedMaxOutput,
     messageTokenBudget: overrides.messageTokenBudget ?? jsonConfig.messageTokenBudget ?? DEFAULTS.messageTokenBudget,
     maxContinueTurns: overrides.maxContinueTurns ?? jsonConfig.maxContinueTurns ?? DEFAULTS.maxContinueTurns,
 

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/engine.js

@@ -37,6 +37,7 @@ import { runStopHooks } from './stop-hooks.js';
 const MAIN_THREAD_ID = 'main';
 import { pickEffort, parseEffortPrefix } from './effort.js';
 import { DEFAULT_CONTEXT_WINDOW, normalizeEffort, resolveContextWindow, resolveModel } from './models.js';
+import { lookupModelLimitSync } from './llm/models-dev.js';
 import { countTurns } from './turn-utils.js';
 import { attachRouterPlan, extractPriorPlan, stripMetaForWire } from './router/continuity.js';
 import { resolveThinking } from './router/thinking.js';
@@ -186,7 +187,11 @@ export function shouldAllowGroupReflection({
     };
   }
   const contextWindow = resolveContextWindow(model, config);
-  const hasRegistryContext = !!resolveModel(model)?.contextWindow;
+  // Telemetry: did the resolver hit either of its top non-default rungs?
+  // Used by `usedFallbackContextWindow` below — if neither models.dev nor
+  // the global config provided a number, we fell through to DEFAULT and
+  // callers may want to surface that to the user.
+  const hasModelsDevContext = !!lookupModelLimitSync(model, resolveModel(model)?.provider || null)?.context;
   const hasConfigContext = Number.isFinite(config?.maxContextTokens) && config.maxContextTokens > 0;
   const threshold = Math.floor(contextWindow * GROUP_CONTEXT_PRESSURE_RATIO);
   const tokenEstimate = estimateMessagesTokens(system, messages);
@@ -204,7 +209,7 @@ export function shouldAllowGroupReflection({
     contextWindow,
     ratio: GROUP_CONTEXT_PRESSURE_RATIO,
     turnCount,
-    usedFallbackContextWindow: !hasRegistryContext && !hasConfigContext && contextWindow === DEFAULT_CONTEXT_WINDOW,
+    usedFallbackContextWindow: !hasModelsDevContext && !hasConfigContext && contextWindow === DEFAULT_CONTEXT_WINDOW,
   };
 }
 

package/yeaft/init.js

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

package/yeaft/llm/models-dev.js

@@ -163,6 +163,76 @@ export async function listProviderModels(providerId, { yeaftDir = null } = {}) {
   return Object.keys(models);
 }
 
+/**
+ * Synchronously look up a model's `{context, output}` limits from whatever
+ * models.dev snapshot is currently warmed in memory.
+ *
+ * The yeaft engine query loop is synchronous (engine.js, config.js, cli.js
+ * all read the context window inline). To avoid bubbling async up through
+ * every gate, the agent boot script primes `fetchModelsDev()` once so this
+ * function can read straight from `_memCache` afterwards.
+ *
+ * If the cache is empty (boot prime failed or test never warmed it), or the
+ * model isn't present in any provider entry, returns `null` — callers fall
+ * back to the next rung of their resolver ladder.
+ *
+ * Collision policy: a given model id can appear under multiple providers
+ * (e.g. `qwen3-32b` lives under 7 providers in the live models.dev snapshot
+ * with context limits ranging 32K–131K). Behavior:
+ *
+ *   • If `providerHint` is given AND that provider lists the model, we use
+ *     that provider's numbers verbatim — the caller knew which gateway it
+ *     was talking to.
+ *   • Otherwise we take the MIN of every provider's `context` and `output`.
+ *     Context is a ceiling: under-shooting risks an early compact (bad);
+ *     over-shooting risks an LLMContextError mid-query (worse). Min picks
+ *     the safer side. Users who know better can pin numbers explicitly via
+ *     `providers[].models[].contextWindow` in `~/.yeaft/config.json`.
+ *
+ * @param {string} modelId
+ * @param {string|null} [providerHint] Provider id matching the models.dev
+ *   top-level key (e.g. 'anthropic', 'openai', 'google', 'deepseek'). The
+ *   MODEL_REGISTRY's `provider` field is aligned to these ids deliberately.
+ * @returns {{ context?: number, output?: number } | null}
+ */
+export function lookupModelLimitSync(modelId, providerHint = null) {
+  if (!modelId || !_memCache || typeof _memCache !== 'object') return null;
+
+  // Hit the hint first if it actually lists this model.
+  if (providerHint && typeof providerHint === 'string') {
+    const provEntry = _memCache[providerHint];
+    const m = provEntry?.models?.[modelId];
+    if (m && m.limit && typeof m.limit === 'object') {
+      const out = {};
+      if (Number.isFinite(m.limit.context) && m.limit.context > 0) out.context = m.limit.context;
+      if (Number.isFinite(m.limit.output) && m.limit.output > 0) out.output = m.limit.output;
+      if (out.context !== undefined || out.output !== undefined) return out;
+    }
+    // Hint missed — fall through to the scan rather than returning null,
+    // because the model genuinely might live under another provider id
+    // (e.g. a deepseek model surfaced via a relay).
+  }
+
+  // Scan every provider; collect context/output values, return MIN.
+  let minCtx = null;
+  let minOut = null;
+  for (const provId of Object.keys(_memCache)) {
+    const m = _memCache[provId]?.models?.[modelId];
+    if (!m || !m.limit || typeof m.limit !== 'object') continue;
+    if (Number.isFinite(m.limit.context) && m.limit.context > 0) {
+      minCtx = minCtx === null ? m.limit.context : Math.min(minCtx, m.limit.context);
+    }
+    if (Number.isFinite(m.limit.output) && m.limit.output > 0) {
+      minOut = minOut === null ? m.limit.output : Math.min(minOut, m.limit.output);
+    }
+  }
+  if (minCtx === null && minOut === null) return null;
+  const result = {};
+  if (minCtx !== null) result.context = minCtx;
+  if (minOut !== null) result.output = minOut;
+  return result;
+}
+
 /**
  * Reset the in-memory cache. Test seam.
  */
@@ -171,3 +241,26 @@ export function _resetMemCache() {
   _memCachePath = null;
   _memCacheTime = 0;
 }
+
+/**
+ * Inject a snapshot into the in-memory cache without going through the
+ * fetch/disk path. Test seam: callers that want to exercise
+ * `lookupModelLimitSync` deterministically can seed any shape they need.
+ *
+ * Pass a falsy snapshot to fully reset (equivalent to {@link _resetMemCache}).
+ * This avoids the foot-gun where `_setMemCacheForTest(null)` would leave
+ * `_memCachePath` and `_memCacheTime` stamped to a fake `__test__` value,
+ * confusing any subsequent `fetchModelsDev` call about whether the cache
+ * was ever populated.
+ *
+ * @param {object|null} snapshot models.dev-shaped data, or null/undefined to reset.
+ */
+export function _setMemCacheForTest(snapshot) {
+  if (!snapshot || typeof snapshot !== 'object') {
+    _resetMemCache();
+    return;
+  }
+  _memCache = snapshot;
+  _memCachePath = '__test__';
+  _memCacheTime = Date.now();
+}

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/models.js

@@ -1,24 +1,34 @@
 /**
- * models.js — Model ID registry for Yeaft Yeaft
+ * models.js — Model ID registry for Yeaft
  *
- * Maps model IDs (e.g. "gpt-5", "claude-sonnet-4-20250514") to their
- * adapter type, API base URL, and capabilities.
+ * Maps model IDs (e.g. "gpt-5", "claude-sonnet-4-20250514") to the *adapter*
+ * metadata Yeaft needs to dispatch requests: which protocol (anthropic vs
+ * openai-responses), which base URL, which thinking/reasoning capabilities.
  *
  * Yeaft does not provide its own models. The "model" field is always a
  * model ID from an external provider. This registry lets Yeaft auto-detect
  * the correct adapter and endpoint from just the model ID, so users only
  * need to set YEAFT_MODEL=gpt-5 without configuring adapter/baseUrl separately.
  *
+ * **Token limits (contextWindow / maxOutput) are NOT stored here.** They are
+ * resolved at runtime from the models.dev community catalog
+ * (`agent/yeaft/llm/models-dev.js`), with a per-provider config override
+ * (`~/.yeaft/config.json: providers[].models[].contextWindow`) and a
+ * conservative DEFAULT as the final rung. See {@link resolveContextWindow}
+ * and {@link resolveMaxOutputTokens} for the full ladder.
+ *
  * Unknown model IDs return null — caller falls back to env-based detection.
  */
 
+import { lookupModelLimitSync } from './llm/models-dev.js';
+
 /**
  * @typedef {Object} ModelInfo
- * @property {'anthropic' | 'openai' | 'deepseek' | 'google'} provider — Which provider this model belongs to
+ * @property {'anthropic' | 'openai' | 'deepseek' | 'google'} provider — Which provider this model belongs to.
+ *   These ids are intentionally aligned with the top-level keys in the models.dev
+ *   catalog so they can be used as a `providerHint` to {@link lookupModelLimitSync}.
  * @property {'anthropic' | 'chat-completions'} adapter — Which wire protocol to use
  * @property {string} baseUrl — Official API endpoint base URL
- * @property {number} contextWindow — Max context tokens
- * @property {number} maxOutputTokens — Max output tokens
  * @property {string} displayName — Human-readable model name
  * @property {boolean} [supportsThinking] — task-327a: model supports thinking/reasoning effort.
  * @property {'anthropic' | 'openai-reasoning' | 'none'} [thinkingProtocol] — task-327a:
@@ -39,8 +49,6 @@ export const MODEL_REGISTRY = new Map([
     provider: 'anthropic',
     adapter: 'anthropic',
     baseUrl: 'https://api.anthropic.com',
-    contextWindow: 200000,
-    maxOutputTokens: 16384,
     displayName: 'Claude Sonnet 4',
     // task-327a: extended thinking supported; budget caps at 32K on Sonnet.
     supportsThinking: true,
@@ -52,8 +60,6 @@ export const MODEL_REGISTRY = new Map([
     provider: 'anthropic',
     adapter: 'anthropic',
     baseUrl: 'https://api.anthropic.com',
-    contextWindow: 200000,
-    maxOutputTokens: 16384,
     displayName: 'Claude Opus 4',
     // task-327a: PM decision — Opus max budget = 64K.
     supportsThinking: true,
@@ -65,8 +71,6 @@ export const MODEL_REGISTRY = new Map([
     provider: 'anthropic',
     adapter: 'anthropic',
     baseUrl: 'https://api.anthropic.com',
-    contextWindow: 200000,
-    maxOutputTokens: 8192,
     displayName: 'Claude Haiku 3',
     // task-327a: Haiku 3 does not support extended thinking — effort is dropped.
     supportsThinking: false,
@@ -78,17 +82,12 @@ export const MODEL_REGISTRY = new Map([
     provider: 'openai',
     adapter: 'openai-responses',
     baseUrl: 'https://api.openai.com/v1',
-    contextWindow: 256000,
-    maxOutputTokens: 16384,
     displayName: 'GPT-5',
     // task-327a: GPT-5 supports reasoning.effort (low/medium/high). No 'max'.
     supportsThinking: true,
     thinkingProtocol: 'openai-reasoning',
     defaultEffort: null,
   }],
-  // gpt-5-mini/-nano/-pro: keep id + family/protocol metadata so they appear
-  // as known models, but do NOT hardcode context/maxOutput — the real limits
-  // should come from provider config (user-supplied) instead of guesses.
   ['gpt-5-mini', {
     provider: 'openai',
     adapter: 'openai-responses',
@@ -111,40 +110,30 @@ export const MODEL_REGISTRY = new Map([
     provider: 'openai',
     adapter: 'openai-responses',
     baseUrl: 'https://api.openai.com/v1',
-    contextWindow: 272000,
-    maxOutputTokens: 16384,
     displayName: 'GPT-5.4',
   }],
   ['gpt-4.1', {
     provider: 'openai',
     adapter: 'openai-responses',
     baseUrl: 'https://api.openai.com/v1',
-    contextWindow: 1047576,
-    maxOutputTokens: 32768,
     displayName: 'GPT-4.1',
   }],
   ['gpt-4.1-mini', {
     provider: 'openai',
     adapter: 'openai-responses',
     baseUrl: 'https://api.openai.com/v1',
-    contextWindow: 1047576,
-    maxOutputTokens: 16384,
     displayName: 'GPT-4.1 Mini',
   }],
   ['gpt-4.1-nano', {
     provider: 'openai',
     adapter: 'openai-responses',
     baseUrl: 'https://api.openai.com/v1',
-    contextWindow: 1047576,
-    maxOutputTokens: 16384,
     displayName: 'GPT-4.1 Nano',
   }],
   ['o3', {
     provider: 'openai',
     adapter: 'openai-responses',
     baseUrl: 'https://api.openai.com/v1',
-    contextWindow: 200000,
-    maxOutputTokens: 100000,
     displayName: 'o3',
     // task-327a: o-series reasoning models use reasoning.effort.
     supportsThinking: true,
@@ -155,8 +144,6 @@ export const MODEL_REGISTRY = new Map([
     provider: 'openai',
     adapter: 'openai-responses',
     baseUrl: 'https://api.openai.com/v1',
-    contextWindow: 200000,
-    maxOutputTokens: 100000,
     displayName: 'o4-mini',
     supportsThinking: true,
     thinkingProtocol: 'openai-reasoning',
@@ -168,16 +155,12 @@ export const MODEL_REGISTRY = new Map([
     provider: 'deepseek',
     adapter: 'openai-responses',
     baseUrl: 'https://api.deepseek.com',
-    contextWindow: 131072,
-    maxOutputTokens: 8192,
     displayName: 'DeepSeek Chat',
   }],
   ['deepseek-reasoner', {
     provider: 'deepseek',
     adapter: 'openai-responses',
     baseUrl: 'https://api.deepseek.com',
-    contextWindow: 131072,
-    maxOutputTokens: 8192,
     displayName: 'DeepSeek Reasoner',
   }],
 
@@ -186,16 +169,12 @@ export const MODEL_REGISTRY = new Map([
     provider: 'google',
     adapter: 'openai-responses',
     baseUrl: 'https://generativelanguage.googleapis.com/v1beta/openai',
-    contextWindow: 1048576,
-    maxOutputTokens: 65536,
     displayName: 'Gemini 2.5 Pro',
   }],
   ['gemini-2.5-flash', {
     provider: 'google',
     adapter: 'openai-responses',
     baseUrl: 'https://generativelanguage.googleapis.com/v1beta/openai',
-    contextWindow: 1048576,
-    maxOutputTokens: 65536,
     displayName: 'Gemini 2.5 Flash',
   }],
 ]);
@@ -214,9 +193,9 @@ export function resolveModel(modelName) {
 }
 
 /**
- * Default context window when neither the model registry nor the engine
- * config has a value. 200K is a conservative middle-ground — most modern
- * production models (Claude, GPT-5, Gemini) have ≥ 128K.
+ * Default context window when no upstream source has a value. 200K is a
+ * conservative middle-ground — most modern production models (Claude,
+ * GPT-5, Gemini) have ≥ 128K.
  *
  * Single source of truth: callers (engine.js pre-flight guard,
  * tools/registry.js per-result cap) MUST use this constant or
@@ -225,40 +204,106 @@ export function resolveModel(modelName) {
 export const DEFAULT_CONTEXT_WINDOW = 200_000;
 
 /**
- * Resolve the live context window for a model, with an explicit fallback
- * ladder:
- *   1. MODEL_REGISTRY entry's `contextWindow` (most accurate)
- *   2. caller-supplied config override (e.g. `config.maxContextTokens`)
- *   3. {@link DEFAULT_CONTEXT_WINDOW}
+ * Default per-call output cap when no upstream source has a value. This is
+ * the floor the adapters use to size `max_tokens`; production models give us
+ * more, but 16K is enough to make progress on any single turn without
+ * tripping a provider-side reject.
+ */
+export const DEFAULT_MAX_OUTPUT_TOKENS = 16_384;
+
+/**
+ * Resolve the live context window for a model.
+ *
+ * Fallback ladder (first match wins):
+ *   1. `config.modelInfo.contextWindow` — per-provider override originating
+ *      from `~/.yeaft/config.json: providers[].models[].contextWindow`. The
+ *      caller is responsible for passing the relevant entry; loadConfig
+ *      threads it through `config.modelInfo` already.
+ *   2. {@link lookupModelLimitSync} against the warmed models.dev snapshot,
+ *      hinted by the MODEL_REGISTRY provider when available so collisions
+ *      across providers resolve to the right entry.
+ *   3. `config.maxContextTokens` — global ceiling from config / CLI.
+ *   4. {@link DEFAULT_CONTEXT_WINDOW}.
  *
  * Used by the per-tool-result cap and the pre-flight token guard so the
  * defense layers always see the same number, regardless of which seam
  * resolves it first.
  *
  * @param {string} modelName
- * @param {{ maxContextTokens?: number }} [config]
+ * @param {{ maxContextTokens?: number, modelInfo?: { contextWindow?: number } } | null} [config]
  * @returns {number}
  */
 export function resolveContextWindow(modelName, config) {
-  const info = resolveModel(modelName);
-  if (info && Number.isFinite(info.contextWindow) && info.contextWindow > 0) {
-    return info.contextWindow;
+  // Rung 1: per-provider config override threaded via config.modelInfo.
+  const overrideCtx = config?.modelInfo?.contextWindow;
+  if (Number.isFinite(overrideCtx) && overrideCtx > 0) return overrideCtx;
+
+  // Rung 2: models.dev snapshot (warmed at agent boot).
+  const reg = MODEL_REGISTRY.get(modelName);
+  const limit = lookupModelLimitSync(modelName, reg?.provider || null);
+  if (limit && Number.isFinite(limit.context) && limit.context > 0) {
+    return limit.context;
   }
+
+  // Rung 3: global config ceiling.
   const cfg = config && Number.isFinite(config.maxContextTokens) && config.maxContextTokens > 0
     ? config.maxContextTokens : null;
   if (cfg !== null) return cfg;
+
+  // Rung 4: default.
   return DEFAULT_CONTEXT_WINDOW;
 }
 
 /**
- * List all known models.
+ * Resolve the live per-call output cap for a model. Same ladder as
+ * {@link resolveContextWindow} but for the `output` axis:
+ *   1. `config.modelInfo.maxOutput` override
+ *   2. models.dev `limit.output`
+ *   3. `config.maxOutputTokens`
+ *   4. {@link DEFAULT_MAX_OUTPUT_TOKENS}
+ *
+ * @param {string} modelName
+ * @param {{ maxOutputTokens?: number, modelInfo?: { maxOutput?: number, maxOutputTokens?: number } } | null} [config]
+ * @returns {number}
+ */
+export function resolveMaxOutputTokens(modelName, config) {
+  const overrideOut = config?.modelInfo?.maxOutput
+    ?? config?.modelInfo?.maxOutputTokens;
+  if (Number.isFinite(overrideOut) && overrideOut > 0) return overrideOut;
+
+  const reg = MODEL_REGISTRY.get(modelName);
+  const limit = lookupModelLimitSync(modelName, reg?.provider || null);
+  if (limit && Number.isFinite(limit.output) && limit.output > 0) {
+    return limit.output;
+  }
+
+  const cfg = config && Number.isFinite(config.maxOutputTokens) && config.maxOutputTokens > 0
+    ? config.maxOutputTokens : null;
+  if (cfg !== null) return cfg;
+
+  return DEFAULT_MAX_OUTPUT_TOKENS;
+}
+
+/**
+ * List all known models with their resolved token limits.
+ *
+ * Token limits are resolved at call time — they reflect whatever models.dev
+ * snapshot is currently warmed, plus the DEFAULT fallback for models the
+ * snapshot doesn't cover. The returned objects therefore mirror what
+ * `resolveContextWindow` / `resolveMaxOutputTokens` would return for the
+ * same model id.
  *
  * @returns {{ name: string, adapter: string, baseUrl: string, contextWindow: number, maxOutputTokens: number, displayName: string }[]}
  */
 export function listModels() {
   const result = [];
   for (const [name, info] of MODEL_REGISTRY) {
-    result.push({ name, ...info });
+    result.push({
+      name,
+      ...info,
+      contextWindow: resolveContextWindow(name, null),
+      maxOutputTokens: resolveMaxOutputTokens(name, null),
+    });
   }
   return result;
 }
@@ -484,11 +529,16 @@ export function serializeModelForPersistence(entry) {
  *
  * Lookup order:
  *   1. provider-config fields (contextWindow / maxOutput) — highest priority
- *   2. MODEL_REGISTRY entry (contextWindow / maxOutputTokens)
+ *   2. models.dev snapshot (`limit.{context,output}`) via the synchronous
+ *      reader, hinted by the MODEL_REGISTRY provider when known so cross-
+ *      provider id collisions resolve to the right entry.
  *   3. undefined if neither has any info
  *
  * Returns a normalized shape: `{ id, contextWindow?, maxOutput?, provider?, adapter?, baseUrl?, displayName? }`.
  *
+ * Note: token limits are intentionally NOT read from MODEL_REGISTRY — those
+ * fields were removed when models.dev became the source of truth.
+ *
  * @param {string} model
  * @param {{ id?: string, contextWindow?: number, maxOutput?: number } | null} [providerConfig]
  * @returns {object | undefined}
@@ -499,8 +549,12 @@ export function getModelInfo(model, providerConfig) {
   const overrideCtx = coercePositiveInt(providerConfig?.contextWindow);
   const overrideMax = coercePositiveInt(providerConfig?.maxOutput);
 
-  const ctx = overrideCtx ?? reg?.contextWindow;
-  const max = overrideMax ?? reg?.maxOutputTokens;
+  // Pull the models.dev numbers as the second rung. Hint with the registry's
+  // provider id when available — same alignment trick the resolveContext-
+  // Window ladder uses.
+  const limit = lookupModelLimitSync(model, reg?.provider || null);
+  const ctx = overrideCtx ?? (limit && Number.isFinite(limit.context) && limit.context > 0 ? limit.context : undefined);
+  const max = overrideMax ?? (limit && Number.isFinite(limit.output) && limit.output > 0 ? limit.output : undefined);
 
   // If we have literally no information, return undefined
   if (!reg && ctx === undefined && max === undefined) return undefined;

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);