@yeaft/webchat-agent 0.1.859 → 0.1.863

package/yeaft/chats/chat-store.js

@@ -0,0 +1,224 @@
+/**
+ * chat-store.js — Per-chat persistent store for Yeaft Chat Mode.
+ *
+ * Layout (architecture parity with group-store.js):
+ *   ~/.yeaft/chats/<chat-id>/
+ *     chat.json           # { id, displayName, vpId, workDir, createdAt, lastTurnAt }
+ *     messages/           # JSONL size-rotation log
+ *       000001.jsonl
+ *       index.json
+ *
+ * A chat is 1:1 with a single VP and persists messages the same way groups
+ * do — same storage primitives, same jsonl shape — but without a roster.
+ *
+ * Hard constraint: no @-mention parsing, no dispatch, no engine awareness.
+ * This module only owns chat.json + the messages log.
+ */
+
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  renameSync,
+  rmSync,
+  statSync,
+} from 'fs';
+import { join } from 'path';
+import { writeAtomic, openLog } from '../storage/index.js';
+import { nextMsgId, isReservedVpId, ReservedVpIdError, validateVpId, InvalidVpIdError } from '../groups/ids.js';
+
+const CHAT_FILE = 'chat.json';
+const MESSAGES_DIR = 'messages';
+
+const CHAT_ID_RE = /^[A-Za-z0-9_-]{1,64}$/;
+
+/**
+ * Open (or partially create) the directory for a chat. Returns a handle even
+ * when chat.json is absent — call createChat() to materialise it.
+ *
+ * @param {string} chatsRoot
+ * @param {string} chatId
+ * @returns {ChatHandle}
+ */
+export function openChat(chatsRoot, chatId) {
+  if (!chatId || typeof chatId !== 'string') {
+    throw new Error('openChat: chatId required (string)');
+  }
+  if (!CHAT_ID_RE.test(chatId)) {
+    throw new Error(`openChat: invalid chatId "${chatId}"`);
+  }
+  const dir = join(chatsRoot, chatId);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+
+  let meta = loadChatMeta(dir);
+
+  const messagesDir = join(dir, MESSAGES_DIR);
+  if (!existsSync(messagesDir)) mkdirSync(messagesDir, { recursive: true });
+  const log = openLog(messagesDir);
+
+  return {
+    dir,
+    id: chatId,
+    getMeta() { return meta ? structuredClone(meta) : null; },
+    saveMeta(next) {
+      validateMeta(next);
+      meta = next;
+      writeAtomic(join(dir, CHAT_FILE), JSON.stringify(meta, null, 2));
+    },
+    appendMessage(record) {
+      if (!record || typeof record !== 'object') {
+        throw new Error('appendMessage: record required');
+      }
+      const leaked = Object.keys(record).filter((k) => typeof k === 'string' && k.startsWith('_'));
+      if (leaked.length > 0) {
+        throw new Error(`appendMessage: ephemeral fields leaked into log: ${leaked.join(', ')}`);
+      }
+      const stored = {
+        id: record.id || nextMsgId(),
+        ts: record.ts || new Date().toISOString(),
+        from: record.from,
+        role: record.role || (record.from === 'user' ? 'user' : 'assistant'),
+        text: record.text ?? '',
+        taskId: record.taskId || null,
+        mentions: Array.isArray(record.mentions) ? record.mentions.slice() : [],
+        meta: record.meta || {},
+      };
+      log.append(stored);
+      return stored;
+    },
+    *streamMessages() { yield* log.streamAll(); },
+    *readMessageRange(firstId, lastId) { yield* log.readRange(firstId, lastId); },
+    close() { log.close(); },
+  };
+}
+
+/**
+ * Create a new chat on disk. Fails if chat.json already exists.
+ * @param {string} chatsRoot
+ * @param {{id:string, vpId:string, displayName?:string, workDir?:string, createdAt?:string}} spec
+ * @returns {ChatHandle}
+ */
+export function createChat(chatsRoot, spec) {
+  if (!spec || !spec.id) throw new Error('createChat: spec.id required');
+  if (!spec.vpId) throw new Error('createChat: spec.vpId required');
+  if (isReservedVpId(spec.vpId)) throw new ReservedVpIdError(spec.vpId);
+  const verdict = validateVpId(spec.vpId);
+  if (!verdict.ok) throw new InvalidVpIdError(spec.vpId, verdict.reason);
+
+  const h = openChat(chatsRoot, spec.id);
+  if (h.getMeta()) {
+    throw new Error(`chat ${spec.id} already exists`);
+  }
+  const meta = {
+    id: spec.id,
+    displayName: typeof spec.displayName === 'string' && spec.displayName.trim()
+      ? spec.displayName.trim() : spec.id,
+    vpId: spec.vpId,
+    workDir: typeof spec.workDir === 'string' ? spec.workDir.trim() : '',
+    createdAt: spec.createdAt || new Date().toISOString(),
+    lastTurnAt: null,
+  };
+  h.saveMeta(meta);
+  return h;
+}
+
+/** Non-destructive load — returns null if chat.json is missing/corrupt. */
+export function loadChatMeta(dir) {
+  const path = join(dir, CHAT_FILE);
+  if (!existsSync(path)) return null;
+  try {
+    const raw = readFileSync(path, 'utf8');
+    const parsed = JSON.parse(raw);
+    validateMeta(parsed);
+    if (typeof parsed.displayName !== 'string') parsed.displayName = parsed.id;
+    if (typeof parsed.workDir !== 'string') parsed.workDir = '';
+    if (parsed.lastTurnAt === undefined) parsed.lastTurnAt = null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+/** List every chat directory under `chatsRoot`. */
+export function listChats(chatsRoot) {
+  if (!existsSync(chatsRoot)) return [];
+  const out = [];
+  for (const name of readdirSync(chatsRoot)) {
+    if (name.startsWith('.')) continue;
+    const p = join(chatsRoot, name);
+    try {
+      if (!statSync(p).isDirectory()) continue;
+    } catch { continue; }
+    const meta = loadChatMeta(p);
+    if (meta) out.push(meta);
+  }
+  return out;
+}
+
+/** Update a chat's displayName. */
+export function renameChat(chatsRoot, chatId, displayName) {
+  const h = openChat(chatsRoot, chatId);
+  const meta = h.getMeta();
+  if (!meta) throw new Error(`renameChat: chat ${chatId} not found`);
+  const next = { ...meta, displayName: String(displayName || '').trim() || meta.id };
+  h.saveMeta(next);
+  h.close();
+  return next;
+}
+
+/** Stamp lastTurnAt — invoked by web-bridge after a successful turn. */
+export function touchChat(chatsRoot, chatId, when = new Date().toISOString()) {
+  const h = openChat(chatsRoot, chatId);
+  const meta = h.getMeta();
+  if (!meta) { h.close(); return null; }
+  const next = { ...meta, lastTurnAt: when };
+  h.saveMeta(next);
+  h.close();
+  return next;
+}
+
+/** Soft-archive: rename dir to `.archived-<chatId>-<ts>`. */
+export function archiveChat(chatsRoot, chatId) {
+  const src = join(chatsRoot, chatId);
+  if (!existsSync(src)) return false;
+  const ts = new Date().toISOString().replace(/[:.]/g, '-');
+  const dst = join(chatsRoot, `.archived-${chatId}-${ts}`);
+  renameSync(src, dst);
+  return true;
+}
+
+/** Permanently delete a chat directory. Use after archive when sure. */
+export function deleteChat(chatsRoot, chatId) {
+  const src = join(chatsRoot, chatId);
+  if (!existsSync(src)) return false;
+  rmSync(src, { recursive: true, force: true });
+  return true;
+}
+
+function validateMeta(meta) {
+  if (!meta || typeof meta !== 'object') throw new Error('chat.json must be object');
+  if (!meta.id || typeof meta.id !== 'string') throw new Error('chat.id required');
+  if (!meta.vpId || typeof meta.vpId !== 'string') throw new Error('chat.vpId required');
+  if (meta.displayName != null && typeof meta.displayName !== 'string') {
+    throw new Error('chat.displayName must be string');
+  }
+  if (meta.workDir != null && typeof meta.workDir !== 'string') {
+    throw new Error('chat.workDir must be string');
+  }
+  if (meta.lastTurnAt != null && typeof meta.lastTurnAt !== 'string') {
+    throw new Error('chat.lastTurnAt must be string|null');
+  }
+}
+
+/**
+ * @typedef {Object} ChatHandle
+ * @property {string} dir
+ * @property {string} id
+ * @property {() => any} getMeta
+ * @property {(next:any) => void} saveMeta
+ * @property {(record:any) => any} appendMessage
+ * @property {() => Generator<any>} streamMessages
+ * @property {(first:string,last:string) => Generator<any>} readMessageRange
+ * @property {() => void} close
+ */

package/yeaft/conversation/persist.js

@@ -109,6 +109,7 @@ function serializeMessage(msg) {
   // in the default group and switching back to the originating group
   // shows an empty pane.
   if (msg.groupId) fm.push(`groupId: ${msg.groupId}`);
+  if (msg.chatId) fm.push(`chatId: ${msg.chatId}`);
   // Group-chat attribution: when a VP authors an assistant turn (either
   // its own reply or a route_forward injection from another VP), stamp
   // the speaker so the UI can render the message on the correct VP track.
@@ -225,6 +226,7 @@ export function parseMessage(raw) {
       case 'threadId': msg.threadId = value; break;
       case 'sourceThreadId': msg.sourceThreadId = value; break;
       case 'groupId': msg.groupId = value; break;
+      case 'chatId': msg.chatId = value; break;
       case 'speakerVpId': msg.speakerVpId = value; break;
       case 'attachmentsB64':
         try {
@@ -1354,10 +1356,106 @@ export class ConversationStore {
   }
 
   #messageDirFor(msg) {
+    if (msg?.chatId) return join(this.#chatConversationDir(msg.chatId, { create: true }), 'messages');
     if (!msg?.groupId) return this.#chatMsgDir;
     return join(this.#groupConversationDir(msg.groupId, { create: true }), 'messages');
   }
 
+  #chatConversationDir(chatId, { create = false } = {}) {
+    const dir = join(this.#dir, 'chats', this.#safeDirComponent(chatId), 'conversation');
+    if (create) this.#ensureConversationDirs(dir);
+    return dir;
+  }
+
+  #chatConversationDirs() {
+    const root = join(this.#dir, 'chats');
+    if (!existsSync(root)) return [];
+    const dirs = [];
+    for (const name of readdirSync(root)) {
+      if (name.startsWith('.')) continue;
+      const chatDir = join(root, name);
+      try { if (!statSync(chatDir).isDirectory()) continue; }
+      catch (err) { if (isPermissionError(err)) continue; throw err; }
+      const conv = join(chatDir, 'conversation');
+      if (existsSync(conv)) dirs.push(conv);
+    }
+    return dirs;
+  }
+
+  #chatMessageDirs(kind, chatId = null) {
+    if (chatId) {
+      const dir = join(this.#chatConversationDir(chatId), kind);
+      return existsSync(dir) ? [dir] : [];
+    }
+    return this.#chatConversationDirs()
+      .map(dir => join(dir, kind))
+      .filter(dir => existsSync(dir));
+  }
+
+  /** Per-chat scoped compact summary path. */
+  #scopedChatCompactPath(chatId, vpId) {
+    if (!chatId || !vpId) return null;
+    const dir = join(this.#chatConversationDir(chatId, { create: true }), 'compact');
+    return join(dir, `${this.#safeIdComponent(vpId)}.md`);
+  }
+
+  /** Read per-(chatId, vpId) compact summary. */
+  readCompactSummaryForChat(chatId, vpId) {
+    const p = this.#scopedChatCompactPath(chatId, vpId);
+    if (!p || !existsSync(p)) return '';
+    try { return readFileSync(p, 'utf8'); } catch { return ''; }
+  }
+
+  /** Rewrite per-(chatId, vpId) compact summary. */
+  replaceCompactSummaryForChat(chatId, vpId, summary) {
+    if (typeof summary !== 'string' || !summary) return;
+    const p = this.#scopedChatCompactPath(chatId, vpId);
+    if (!p) return;
+    try { writeFileSync(p, summary, { encoding: 'utf8', mode: 0o644 }); }
+    catch (err) {
+      if (isPermissionError(err)) {
+        if (!_permissionWarned) {
+          console.warn(`[Yeaft] Cannot write scoped chat compact summary: ${err.code}`);
+          _permissionWarned = true;
+        }
+      } else throw err;
+    }
+  }
+
+  /** Recent messages for a chat — chat mode mirror of loadRecentByGroup. */
+  loadRecentByChat(chatId, turnsLimit = DEFAULT_RECENT_TURNS) {
+    if (!chatId) return [];
+    const all = [
+      ...this.#chatMessageDirs('messages', chatId).flatMap(dir => this.#loadFromDir(dir, Infinity)),
+      ...this.#chatMessageDirs('cold', chatId).flatMap(dir => this.#loadFromDir(dir, Infinity)),
+    ].sort(compareMessagesBySeq);
+    const filtered = all.filter(m => m && m.chatId === chatId);
+    if (turnsLimit === Infinity || turnsLimit < 0) return pairSanitize(filtered);
+    return pairSanitize(sliceLastNTurns(filtered, turnsLimit));
+  }
+
+  /** VP-scoped chat history — chat-mode mirror of loadGroupHistoryForVp. */
+  loadChatHistoryForVp(chatId, vpId) {
+    if (!chatId || !vpId) return [];
+    const all = [
+      ...this.#chatMessageDirs('messages', chatId).flatMap(dir => this.#loadFromDir(dir, Infinity)),
+      ...this.#chatMessageDirs('cold', chatId).flatMap(dir => this.#loadFromDir(dir, Infinity)),
+    ].sort(compareMessagesBySeq);
+    const out = [];
+    for (const m of all) {
+      if (!m || m.chatId !== chatId) continue;
+      if (m._reflection || m.internal || m.systemOnly || m.systemOnlyMessage) continue;
+      if (m.role === 'user') { out.push(m); continue; }
+      if (m.role === 'assistant') {
+        // Chat is 1:1 — every assistant row is "ours".
+        out.push(m);
+        continue;
+      }
+      if (m.role === 'tool') { out.push(m); continue; }
+    }
+    return pairSanitize(out);
+  }
+
   #groupConversationDir(groupId, { create = false } = {}) {
     const dir = join(this.#groupsDir, this.#safeDirComponent(groupId), 'conversation');
     if (create) this.#ensureConversationDirs(dir);

package/yeaft/dream-v2/apply.js

@@ -143,6 +143,12 @@ export function targetToScope(target) {
       return { kind: 'group-topic', groupId: segs[1], path: segs.slice(3) };
     }
   }
+  if (segs[0] === 'chat') {
+    if (segs.length === 2) return { kind: 'chat', id: segs[1] };
+    if (segs.length === 4 && segs[2] === 'vp') {
+      return { kind: 'chat-vp', chatId: segs[1], id: segs[3] };
+    }
+  }
   throw new Error(`apply.targetToScope: malformed target ${JSON.stringify(target)}`);
 }
 
@@ -274,6 +280,8 @@ function scopeRelDir(scope) {
     case 'group-vp':      return `group/${scope.groupId}/vp/${scope.id}`;
     case 'group-feature': return `group/${scope.groupId}/feature/${scope.id}`;
     case 'group-topic':   return `group/${scope.groupId}/topic/${scope.path.join('/')}`;
+    case 'chat':          return `chat/${scope.id}`;
+    case 'chat-vp':       return `chat/${scope.chatId}/vp/${scope.id}`;
     default: throw new Error(`apply.scopeRelDir: unknown kind ${scope.kind}`);
   }
 }

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

@@ -47,6 +47,9 @@ export function extractTemplateForScope(scope) {
   if (/^group\/[^/]+\/topic\//.test(scope)) return 'extractTopic';
   if (/^group\/[^/]+\/user(?:\/|$)/.test(scope)) return 'extractUser';
   if (scope.startsWith('group/')) return 'extractGroup';
+  // Chat-isolated scopes: same template family as groups.
+  if (/^chat\/[^/]+\/vp\//.test(scope)) return 'extractVp';
+  if (scope.startsWith('chat/')) return 'extractGroup';
   // 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/triage.js

@@ -58,13 +58,28 @@ function triageSystem(language) {
  * @param {{ groupId: string, messages: Array<object> }} args
  * @returns {Array<{ kind: 'update', scope: string }>}
  */
-export function applyHardRules({ groupId, messages }) {
+export function applyHardRules({ groupId, chatId, messages }) {
   const out = new Map();
   const add = (scope) => { if (!out.has(scope)) out.set(scope, { kind: 'update', scope }); };
 
   // global user is always in.
   add('user');
 
+  // chat path takes precedence: chat sessions have no group context.
+  if (chatId) {
+    add(`chat/${chatId}`);
+    for (const m of (messages || [])) {
+      if (!m || typeof m !== 'object') continue;
+      if (m.role === 'assistant') {
+        const vp = m.vpId || (m.author && /^vp:(.+)$/.exec(m.author)?.[1]);
+        if (vp && /^[A-Za-z0-9_\-.一-鿿]+$/.test(vp)) {
+          add(`chat/${chatId}/vp/${vp}`);
+        }
+      }
+    }
+    return Array.from(out.values());
+  }
+
   // active group + its per-group user layer, except the virtual _no-group bucket.
   if (groupId && groupId !== '_no-group') {
     add(`group/${groupId}`);

package/yeaft/engine.js

@@ -306,6 +306,8 @@ export class Engine {
   #groupId = null;
   /** @type {string|null} — set when this engine is bound to a specific VP (per-VP fan-out path). */
   #vpId = null;
+  /** @type {string|null} — set when this engine is bound to a chat session (Chat Mode). */
+  #chatId = null;
 
   /** @type {import('./stats/tool-usage.js').ToolUsageStats|null} — per-tool call/latency counters */
   #toolStats = null;
@@ -406,7 +408,7 @@ export class Engine {
    *   toolStats?: import('./stats/tool-usage.js').ToolUsageStats,
    * }} params
    */
-  constructor({ adapter, trace, config, conversationStore, memoryIndex, amsRegistry, toolRegistry, skillManager, mcpManager, yeaftDir, toolStats = null, groupId = null, vpId = null }) {
+  constructor({ adapter, trace, config, conversationStore, memoryIndex, amsRegistry, toolRegistry, skillManager, mcpManager, yeaftDir, toolStats = null, groupId = null, vpId = null, chatId = null }) {
     this.#adapter = adapter;
     this.#trace = trace;
     this.#config = config;
@@ -428,6 +430,7 @@ export class Engine {
     // callers leave both null → fall back to the global file.
     this.#groupId = (typeof groupId === 'string' && groupId) ? groupId : null;
     this.#vpId = (typeof vpId === 'string' && vpId) ? vpId : null;
+    this.#chatId = (typeof chatId === 'string' && chatId) ? chatId : null;
 
     // PR-L: tool history reflection log. Keyed by traceId so distinct
     // engine instances don't stomp on each other's jsonl files. When
@@ -972,6 +975,7 @@ export class Engine {
       const result = runMemoryPreflow(this.#memoryIndex, {
         userMsg: prompt,
         groupId: ctx.groupId,
+        chatId: ctx.chatId || this.#chatId,
         vpId: ctx.vpId,
       });
       memory.profile = result.profile || '';
@@ -994,6 +998,10 @@ export class Engine {
     // read ONLY its own summary file. Falling back to legacy compact.md here
     // leaks another group/VP's summary into every new group turn after one
     // post-turn compact writes the session-global file.
+    if (this.#chatId && this.#vpId
+        && typeof this.#conversationStore.readCompactSummaryForChat === 'function') {
+      return this.#conversationStore.readCompactSummaryForChat(this.#chatId, this.#vpId);
+    }
     if (this.#groupId && this.#vpId
         && typeof this.#conversationStore.readCompactSummaryFor === 'function') {
       return this.#conversationStore.readCompactSummaryFor(this.#groupId, this.#vpId);
@@ -1032,8 +1040,9 @@ export class Engine {
         role: 'user',
         content: userContent,
         threadId,
-        // Bug 6: stamp groupId so history replay can route by group.
+        // Bug 6: stamp groupId/chatId so history replay can route by container.
         ...(groupId ? { groupId } : {}),
+        ...(this.#chatId ? { chatId: this.#chatId } : {}),
       });
     }
 
@@ -1044,6 +1053,7 @@ export class Engine {
       model: this.#config.model,
       threadId,
       ...(groupId ? { groupId } : {}),
+      ...(this.#chatId ? { chatId: this.#chatId } : {}),
     };
     if (toolCalls && toolCalls.length > 0) {
       assistantMsg.toolCalls = toolCalls;
@@ -1091,12 +1101,16 @@ export class Engine {
     // Legacy / sub-agent callers (no groupId/vpId pair) keep the global
     // loadAll() behaviour so we don't break those flows.
     let messages;
-    const scoped = !!(this.#groupId && this.#vpId
+    const scopedChat = !!(this.#chatId && this.#vpId
+      && typeof conversationStore.loadChatHistoryForVp === 'function');
+    const scoped = !scopedChat && !!(this.#groupId && this.#vpId
       && typeof conversationStore.loadGroupHistoryForVp === 'function');
     try {
-      messages = scoped
-        ? conversationStore.loadGroupHistoryForVp(this.#groupId, this.#vpId)
-        : conversationStore.loadAll();
+      messages = scopedChat
+        ? conversationStore.loadChatHistoryForVp(this.#chatId, this.#vpId)
+        : scoped
+          ? conversationStore.loadGroupHistoryForVp(this.#groupId, this.#vpId)
+          : conversationStore.loadAll();
     } catch { return null; }
     if (!Array.isArray(messages) || messages.length === 0) return null;
 
@@ -1212,11 +1226,13 @@ export class Engine {
       // per-VP summary written below is the durable win; physical
       // cold-archival across shared rows is the dream-level orchestrator's
       // job, not post-turn compact's.
-      if (!scoped && archiveIds.length > 0) {
+      if (!scoped && !scopedChat && archiveIds.length > 0) {
         conversationStore.moveToColdBatch(archiveIds);
       }
       if (out.compactSummary) {
-        if (scoped && typeof conversationStore.replaceCompactSummaryFor === 'function') {
+        if (scopedChat && typeof conversationStore.replaceCompactSummaryForChat === 'function') {
+          conversationStore.replaceCompactSummaryForChat(this.#chatId, this.#vpId, out.compactSummary);
+        } else if (scoped && typeof conversationStore.replaceCompactSummaryFor === 'function') {
           conversationStore.replaceCompactSummaryFor(this.#groupId, this.#vpId, out.compactSummary);
         } else {
           conversationStore.replaceCompactSummary(out.compactSummary);

package/yeaft/groups/pre-flow.js

@@ -167,8 +167,13 @@ export function selectRespondingVps(input) {
  */
 function scopeHeading(scope) {
   if (scope === 'user') return '## Memory: User';
-  // Nested group scopes first.
-  let m = /^group\/([^/]+)\/vp\/(.+)$/.exec(scope);
+  // Nested chat scopes first.
+  let m = /^chat\/([^/]+)\/vp\/(.+)$/.exec(scope);
+  if (m) return `## Memory: VP ${m[2]}`;
+  m = /^chat\/([^/]+)$/.exec(scope);
+  if (m) return `## Memory: Chat ${m[1]}`;
+  // Nested group scopes.
+  m = /^group\/([^/]+)\/vp\/(.+)$/.exec(scope);
   if (m) return `## Memory: VP ${m[2]}`;
   m = /^group\/([^/]+)\/user$/.exec(scope);
   if (m) return `## Memory: Group ${m[1]} (user)`;
@@ -245,9 +250,12 @@ export function formatPickedForInjection(picked) {
  * @param {{groupId?: string, vpId?: string, extra?: string[]}} ctx
  * @returns {string[]}
  */
-export function buildRelevantScopes({ groupId, vpId, extra } = {}) {
+export function buildRelevantScopes({ groupId, chatId, vpId, extra } = {}) {
   const scopes = ['user'];
-  if (groupId) {
+  if (chatId) {
+    scopes.push(`chat/${chatId}`);
+    if (vpId) scopes.push(`chat/${chatId}/vp/${vpId}`);
+  } else if (groupId) {
     scopes.push(`group/${groupId}`);
     scopes.push(`group/${groupId}/user`);
     if (vpId) scopes.push(`group/${groupId}/vp/${vpId}`);
@@ -286,6 +294,7 @@ export function runMemoryPreflow(index, opts) {
 
   const relevantScopes = buildRelevantScopes({
     groupId: opts.groupId,
+    chatId: opts.chatId,
     vpId: opts.vpId,
     extra: opts.extraScopes,
   });

package/yeaft/llm/models-dev.js

@@ -36,8 +36,14 @@ function getCachePath(yeaftDir) {
 async function diskCacheAgeMs(yeaftDir) {
   try {
     const s = await stat(getCachePath(yeaftDir));
+    // Clamp negative ages (clock-skew between filesystem mtime and
+    // JS Date.now() can momentarily be a few ms ahead on some CI
+    // runners). Returning null here would skip stage-2 and force a
+    // network fetch — which broke the deterministic listProviders test
+    // by serving the live ~140-provider models.dev payload. A freshly
+    // written cache is, by definition, fresh.
     const age = Date.now() - s.mtimeMs;
-    return age < 0 ? null : age;
+    return age < 0 ? 0 : age;
   } catch {
     return null;
   }

package/yeaft/memory/segment.js

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

package/yeaft/memory/store-v2.js

@@ -62,9 +62,11 @@ export const SCOPE_KINDS = Object.freeze([
   'group-vp',
   'group-feature',
   'group-topic',
+  'chat',
+  'chat-vp',
 ]);
 
-/** @typedef {'user'|'group'|'group-user'|'group-vp'|'group-feature'|'group-topic'} ScopeKind */
+/** @typedef {'user'|'group'|'group-user'|'group-vp'|'group-feature'|'group-topic'|'chat'|'chat-vp'} ScopeKind */
 
 /**
  * @typedef {Object} Scope
@@ -122,6 +124,18 @@ export function scopeDir(scope) {
       for (const s of segs) assertSafeSegment(s, 'group-topic.path');
       return `group/${scope.groupId}/topic/${segs.join('/')}`;
     }
+    case 'chat': {
+      if (!scope.id) throw new Error('scopeDir: chat scope requires id');
+      assertSafeSegment(scope.id, 'chat.id');
+      return `chat/${scope.id}`;
+    }
+    case 'chat-vp': {
+      if (!scope.chatId) throw new Error('scopeDir: chat-vp scope requires chatId');
+      if (!scope.id) throw new Error('scopeDir: chat-vp scope requires id');
+      assertSafeSegment(scope.chatId, 'chat-vp.chatId');
+      assertSafeSegment(scope.id, 'chat-vp.id');
+      return `chat/${scope.chatId}/vp/${scope.id}`;
+    }
     default:
       throw new Error(`scopeDir: unknown kind ${JSON.stringify(scope.kind)}`);
   }
@@ -187,7 +201,7 @@ export function isValidTopic(scope) {
  */
 export function isVpForeign(relPath, currentVpId) {
   if (!relPath || !currentVpId) return false;
-  const m = /^group\/[^/]+\/vp\/([^/]+)(?:\/|$)/.exec(relPath);
+  const m = /^(?:group|chat)\/[^/]+\/vp\/([^/]+)(?:\/|$)/.exec(relPath);
   if (!m) return false;
   return m[1] !== currentVpId;
 }
@@ -525,6 +539,31 @@ export async function listScopes(opts = {}) {
     }
   }
 
+  // chat/<c>/  and  chat/<c>/vp/<v>/
+  const chatRoot = join(root, 'chat');
+  let chats;
+  try { chats = await fsp.readdir(chatRoot, { withFileTypes: true }); }
+  catch (err) {
+    if (err && err.code === 'ENOENT') chats = [];
+    else throw err;
+  }
+  for (const cent of chats) {
+    if (!cent.isDirectory()) continue;
+    if (cent.name.startsWith('.')) continue;
+    if (!isSafeId(cent.name)) continue;
+    const c = cent.name;
+    out.push({ kind: 'chat', id: c });
+    const vpDir = join(chatRoot, c, 'vp');
+    let vps;
+    try { vps = await fsp.readdir(vpDir, { withFileTypes: true }); }
+    catch { vps = []; }
+    for (const vent of vps) {
+      if (!vent.isDirectory()) continue;
+      if (!isSafeId(vent.name)) continue;
+      out.push({ kind: 'chat-vp', chatId: c, id: vent.name });
+    }
+  }
+
   return out;
 }