@yeaft/webchat-agent 1.0.77 → 1.0.79

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.77",
+  "version": "1.0.79",
   "description": "Remote worker agent for Yeaft Web Code Agent — connects the native Yeaft engine, CLI providers, and workbench tools",
   "main": "index.js",
   "type": "module",

package/yeaft/conversation/persist.js

@@ -1,23 +1,29 @@
 /**
  * persist.js — Conversation message persistence
  *
- * Hot conversation messages are stored as JSONL segments with a small JSON index
- * under ~/.yeaft/chat/ or ~/.yeaft/sessions/<sessionId>/conversation/.
- * Older per-message Markdown
- * files are read as a legacy fallback only.
+ * Each message is stored as a .md file with YAML frontmatter in
+ * ~/.yeaft/chat/messages/ or ~/.yeaft/sessions/<sessionId>/conversation/messages/. Design: zero JSON, all Markdown.
  *
  * Vocabulary note: the primary on-disk layout uses `sessions/<id>/`. Older
  * installs may still have transcript files under `groups/<id>/`; those are
  * read as a legacy fallback only. Every API surface above the disk layer
  * uses "session" vocabulary.
  *
- * Segment format: one JSON object per line, keyed by global monotonic `seq` /
- * `id` (`m0001`, `m0002`, ...).
+ * Message format:
+ *   ---
+ *   id: m0355
+ *   role: user
+ *   time: 2026-04-09T14:35:00Z
+ *   mode: chat
+ *   model: claude-sonnet-4-20250514
+ *   tokens_est: 230
+ *   ---
+ *   Message content here...
  *
  * Reference: yeaft-yeaft-core-systems.md §4.1, yeaft-yeaft-brainstorm-v5.1.md
  */
 
-import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, renameSync, unlinkSync, statSync, appendFileSync } from 'fs';
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, renameSync, unlinkSync, statSync } from 'fs';
 import { join, basename } from 'path';
 import { isPermissionError } from '../init.js';
 import { pairSanitize } from '../pair-sanitize.js';
@@ -58,58 +64,6 @@ const RECENT_SESSION_SCAN_BASE_CAP = 64;
 const RECENT_SESSION_SCAN_PER_TURN_CAP = 4;
 const RECENT_SESSION_SCAN_MAX_CAP = 256;
 
-
-const SEGMENT_INDEX_FILE = 'index.json';
-const SEGMENT_DIR = 'segments';
-const SEGMENT_TARGET_BYTES = 1024 * 1024;
-const SEGMENT_FIRST_NAME = '000001.jsonl';
-
-function emptySegmentIndex() {
-  return {
-    version: 1,
-    nextSeq: 1,
-    totalMessages: 0,
-    lastMessageId: null,
-    activeSegment: SEGMENT_FIRST_NAME,
-    segments: [],
-  };
-}
-
-function seqId(seq) {
-  return `m${String(seq).padStart(4, '0')}`;
-}
-
-function normalizeSegmentRecord(msg) {
-  if (!msg || typeof msg !== 'object') return null;
-  const seq = Number.isFinite(msg.seq) ? msg.seq : parseSeqFromId(msg.id);
-  if (!Number.isFinite(seq)) return null;
-  const out = { ...msg, seq, id: msg.id || seqId(seq) };
-  return out;
-}
-
-function segmentNameForNumber(n) {
-  return `${String(n).padStart(6, '0')}.jsonl`;
-}
-
-function nextSegmentName(name) {
-  const m = String(name || '').match(/^(\d+)\.jsonl$/);
-  const n = m ? parseInt(m[1], 10) + 1 : 1;
-  return segmentNameForNumber(n);
-}
-
-function parseJsonLine(line) {
-  if (!line || !line.trim()) return null;
-  try { return normalizeSegmentRecord(JSON.parse(line)); }
-  catch { return null; }
-}
-
-function parseSegmentOrMarkdown(raw) {
-  if (!raw) return null;
-  const msg = parseJsonLine(raw);
-  if (msg) return msg;
-  return parseMessage(raw);
-}
-
 /** Read the current default cold-start replay window (turn count). */
 export function getDefaultRecentTurnsLimit() {
   return DEFAULT_RECENT_TURNS;
@@ -487,209 +441,6 @@ export function parseMessage(raw) {
   return msg;
 }
 
-
-class SegmentStore {
-  constructor(rootDir) {
-    this.rootDir = rootDir;
-    this.segmentDir = join(rootDir, SEGMENT_DIR);
-    this.indexPath = join(rootDir, SEGMENT_INDEX_FILE);
-    this.index = null;
-  }
-
-  ensure() {
-    if (!existsSync(this.rootDir)) mkdirSync(this.rootDir, { recursive: true, mode: 0o755 });
-    if (!existsSync(this.segmentDir)) mkdirSync(this.segmentDir, { recursive: true, mode: 0o755 });
-  }
-
-  hasData() {
-    if (existsSync(this.indexPath)) return true;
-    if (!existsSync(this.segmentDir)) return false;
-    try { return readdirSync(this.segmentDir).some(f => f.endsWith('.jsonl')); }
-    catch (err) { if (isPermissionError(err)) return false; throw err; }
-  }
-
-  loadIndex() {
-    if (this.index) return this.index;
-    let idx = null;
-    if (existsSync(this.indexPath)) {
-      try {
-        const parsed = JSON.parse(readFileSync(this.indexPath, 'utf8') || '{}');
-        if (parsed && typeof parsed === 'object') idx = parsed;
-      } catch {
-        idx = null;
-      }
-    }
-    this.index = this.#normalizeIndex(idx || this.#rebuildIndex());
-    if (!existsSync(this.indexPath) && this.hasData()) this.saveIndex();
-    return this.index;
-  }
-
-  saveIndex() {
-    this.ensure();
-    writeFileSync(this.indexPath, `${JSON.stringify(this.index || emptySegmentIndex(), null, 2)}\n`, { encoding: 'utf8', mode: 0o644 });
-  }
-
-  append(msg) {
-    this.ensure();
-    const idx = this.loadIndex();
-    let segment = idx.segments[idx.segments.length - 1] || null;
-    let active = segment?.file || idx.activeSegment || SEGMENT_FIRST_NAME;
-    let activePath = join(this.segmentDir, active);
-    const currentSize = existsSync(activePath) ? statSync(activePath).size : 0;
-    if (currentSize >= SEGMENT_TARGET_BYTES && segment && segment.count > 0) {
-      active = nextSegmentName(active);
-      activePath = join(this.segmentDir, active);
-      segment = null;
-    }
-    const line = `${JSON.stringify(msg)}\n`;
-    appendFileSync(activePath, line, { encoding: 'utf8', mode: 0o644 });
-
-    const seq = parseSeqFromId(msg.id);
-    if (!segment || segment.file !== active) {
-      segment = { file: active, firstSeq: seq, lastSeq: seq, count: 0, bytes: 0 };
-      idx.segments.push(segment);
-    }
-    segment.firstSeq = Number.isFinite(segment.firstSeq) ? Math.min(segment.firstSeq, seq) : seq;
-    segment.lastSeq = Number.isFinite(segment.lastSeq) ? Math.max(segment.lastSeq, seq) : seq;
-    segment.count = (segment.count || 0) + 1;
-    segment.bytes = (segment.bytes || currentSize) + Buffer.byteLength(line);
-    idx.activeSegment = active;
-    idx.totalMessages = (idx.totalMessages || 0) + 1;
-    idx.lastMessageId = msg.id || null;
-    idx.nextSeq = Math.max(Number(idx.nextSeq) || 1, seq + 1);
-    this.saveIndex();
-  }
-
-  readAll({ beforeSeq = Infinity, afterSeq = -Infinity, desc = false, includeCold = false } = {}) {
-    if (!this.hasData()) return [];
-    const idx = this.loadIndex();
-    const segments = (idx.segments || [])
-      .filter(seg => this.#segmentMayContain(seg, beforeSeq, afterSeq))
-      .slice()
-      .sort((a, b) => desc ? (b.lastSeq || 0) - (a.lastSeq || 0) : (a.firstSeq || 0) - (b.firstSeq || 0));
-    const out = [];
-    for (const seg of segments) {
-      const rows = this.#readSegment(seg.file, { beforeSeq, afterSeq, desc, includeCold });
-      out.push(...rows);
-    }
-    return desc ? out.sort((a, b) => parseSeqFromId(b.id) - parseSeqFromId(a.id)) : out.sort(compareMessagesBySeq);
-  }
-
-  *scan({ beforeSeq = Infinity, afterSeq = -Infinity, desc = false, includeCold = false } = {}) {
-    if (!this.hasData()) return;
-    const idx = this.loadIndex();
-    const segments = (idx.segments || [])
-      .filter(seg => this.#segmentMayContain(seg, beforeSeq, afterSeq))
-      .slice()
-      .sort((a, b) => desc ? (b.lastSeq || 0) - (a.lastSeq || 0) : (a.firstSeq || 0) - (b.firstSeq || 0));
-    for (const seg of segments) {
-      for (const row of this.#readSegment(seg.file, { beforeSeq, afterSeq, desc, includeCold })) yield row;
-    }
-  }
-
-  count(kind = 'hot') {
-    if (!this.hasData()) return 0;
-    if (kind === 'all') {
-      const idx = this.loadIndex();
-      return Number(idx.totalMessages) || (idx.segments || []).reduce((sum, seg) => sum + (Number(seg.count) || 0), 0);
-    }
-    const rows = this.readAll({ includeCold: true });
-    if (kind === 'cold') return rows.filter(m => m && m.cold === true).length;
-    return rows.filter(m => m && m.cold !== true).length;
-  }
-
-  replaceAll(rows) {
-    this.clear();
-    for (const msg of (rows || []).filter(Boolean).sort(compareMessagesBySeq)) this.append(msg);
-  }
-
-  markCold(id) {
-    if (!id || !this.hasData()) return 0;
-    const rows = this.readAll({ includeCold: true });
-    let changed = 0;
-    for (const msg of rows) {
-      if (msg?.id === id && msg.cold !== true) {
-        msg.cold = true;
-        changed += 1;
-      }
-    }
-    if (changed > 0) this.replaceAll(rows);
-    return changed;
-  }
-
-  clear() {
-    if (existsSync(this.segmentDir)) {
-      for (const f of readdirSync(this.segmentDir)) {
-        if (f.endsWith('.jsonl')) unlinkSync(join(this.segmentDir, f));
-      }
-    }
-    if (existsSync(this.indexPath)) unlinkSync(this.indexPath);
-    this.index = emptySegmentIndex();
-  }
-
-  #normalizeIndex(idx) {
-    const out = { ...emptySegmentIndex(), ...(idx || {}) };
-    out.segments = Array.isArray(out.segments) ? out.segments.filter(s => s && s.file) : [];
-    out.segments.sort((a, b) => (Number(a.firstSeq) || 0) - (Number(b.firstSeq) || 0));
-    const maxSeq = out.segments.reduce((max, seg) => Math.max(max, Number(seg.lastSeq) || 0), 0);
-    out.nextSeq = Math.max(Number(out.nextSeq) || 1, maxSeq + 1);
-    out.activeSegment = out.activeSegment || out.segments[out.segments.length - 1]?.file || SEGMENT_FIRST_NAME;
-    out.totalMessages = Number(out.totalMessages) || out.segments.reduce((sum, seg) => sum + (Number(seg.count) || 0), 0);
-    return out;
-  }
-
-  #rebuildIndex() {
-    const idx = emptySegmentIndex();
-    if (!existsSync(this.segmentDir)) return idx;
-    const files = readdirSync(this.segmentDir).filter(f => f.endsWith('.jsonl')).sort();
-    for (const file of files) {
-      const rows = this.#readSegment(file, { includeCold: true });
-      if (rows.length === 0) continue;
-      const seqs = rows.map(r => parseSeqFromId(r.id)).filter(Number.isFinite);
-      const path = join(this.segmentDir, file);
-      const seg = {
-        file,
-        firstSeq: Math.min(...seqs),
-        lastSeq: Math.max(...seqs),
-        count: rows.length,
-        bytes: existsSync(path) ? statSync(path).size : 0,
-      };
-      idx.segments.push(seg);
-      idx.totalMessages += rows.length;
-      idx.lastMessageId = rows[rows.length - 1]?.id || idx.lastMessageId;
-      idx.nextSeq = Math.max(idx.nextSeq, seg.lastSeq + 1);
-      idx.activeSegment = file;
-    }
-    return idx;
-  }
-
-  #segmentMayContain(seg, beforeSeq, afterSeq) {
-    const first = Number(seg.firstSeq);
-    const last = Number(seg.lastSeq);
-    if (Number.isFinite(beforeSeq) && Number.isFinite(first) && first >= beforeSeq) return false;
-    if (Number.isFinite(afterSeq) && Number.isFinite(last) && last <= afterSeq) return false;
-    return true;
-  }
-
-  #readSegment(file, { beforeSeq = Infinity, afterSeq = -Infinity, desc = false, includeCold = false } = {}) {
-    const path = join(this.segmentDir, file);
-    if (!existsSync(path)) return [];
-    const raw = readFileSync(path, 'utf8');
-    const rows = [];
-    for (const line of raw.split('\n')) {
-      const msg = parseJsonLine(line);
-      if (!msg) continue;
-      const seq = parseSeqFromId(msg.id);
-      if (Number.isFinite(beforeSeq) && seq >= beforeSeq) continue;
-      if (Number.isFinite(afterSeq) && seq <= afterSeq) continue;
-      if (!includeCold && msg.cold === true) continue;
-      rows.push(msg);
-    }
-    rows.sort(compareMessagesBySeq);
-    return desc ? rows.reverse() : rows;
-  }
-}
-
 // ─── ConversationStore ───────────────────────────────────────
 
 /**
@@ -697,14 +448,15 @@ class SegmentStore {
  *
  * Directory layout:
  *   chat/            — one-to-one chat mode history
- *     index.json
- *     segments/
+ *     index.md
  *     compact.md
+ *     messages/
+ *     cold/
  *     blobs/
  *   sessions/<sessionId>/conversation/
- *     index.json
- *     segments/
  *     compact/
+ *     messages/
+ *     cold/
  *     blobs/
  *
  * Legacy compatibility: ~/.yeaft/conversation is read as an old mixed store,
@@ -765,7 +517,7 @@ export class ConversationStore {
     // errors). Per-session conversation directories are created lazily once a
     // sessionId is known. Legacy directories are never created by new versions.
     for (const d of [
-      this.#chatDir, join(this.#chatDir, 'blobs'), join(this.#chatDir, SEGMENT_DIR), this.#chatMsgDir, this.#chatColdDir,
+      this.#chatDir, join(this.#chatDir, 'blobs'), this.#chatMsgDir, this.#chatColdDir,
       this.#sessionsDir,
     ]) {
       try {
@@ -801,8 +553,9 @@ export class ConversationStore {
       tokens_est: msg.tokens_est || estimateTokens(msg.content || ''),
     };
 
+    const filePath = join(this.#messageDirFor(fullMsg), `${id}.md`);
     try {
-      this.#segmentStoreFor(fullMsg, { create: true }).append(fullMsg);
+      writeFileSync(filePath, serializeMessage(fullMsg), { encoding: 'utf8', mode: 0o644 });
     } catch (err) {
       if (isPermissionError(err)) {
         if (!_permissionWarned) {
@@ -835,10 +588,6 @@ export class ConversationStore {
    * @param {string} id — message id (e.g. "m0355")
    */
   moveToCold(id) {
-    for (const dir of [this.#chatDir, ...this.#sessionConversationDirs({ primaryOnly: true })]) {
-      const moved = this.#segmentStoreForConversationDir(dir).markCold(id);
-      if (moved > 0) return;
-    }
     for (const [hotDir, coldDir] of this.#hotColdDirPairs({ includeLegacy: false })) {
       const src = join(hotDir, `${id}.md`);
       const dst = join(coldDir, `${id}.md`);
@@ -1078,10 +827,7 @@ export class ConversationStore {
         }
       }
     }
-    for (const dir of [this.#chatDir, ...this.#sessionConversationDirs({ primaryOnly: true })]) {
-      this.#segmentStoreForConversationDir(dir).clear();
-    }
-    // Reset compact files in the new chat/session stores. Legacy
+    // Reset compact files in the new chat/group stores. Legacy
     // ~/.yeaft/conversation is intentionally left untouched.
     for (const path of [this.#compactPath]) {
       if (!existsSync(path)) continue;
@@ -1293,9 +1039,11 @@ export class ConversationStore {
    */
   loadOlderBySession(sessionId, beforeSeq, turnsLimit = DEFAULT_RECENT_TURNS) {
     if (!sessionId) return { messages: [], oldestSeq: null, hasMore: false };
+    const all = this.#loadSessionMessages(sessionId);
     const cutoff = Number.isFinite(beforeSeq) ? beforeSeq : Infinity;
-    const prefix = this.#readSessionRows(sessionId, { beforeSeq: cutoff })
-      .filter(m => m && m.sessionId === sessionId && !isHiddenConversationRow(m));
+    const prefix = all.filter(m => m && m.sessionId === sessionId
+      && !isHiddenConversationRow(m)
+      && parseSeqFromId(m.id) < cutoff);
     if (prefix.length === 0) return { messages: [], oldestSeq: null, hasMore: false };
     const sliced = pairSanitize(sliceLastNTurns(prefix, turnsLimit));
     // Turn-based hasMore: there's an EARLIER turn boundary we didn't keep.
@@ -1369,7 +1117,14 @@ export class ConversationStore {
     if (cutoff === null) return { messages: [], latestSeq: null };
     const after = [];
     let newestScannedSeq = cutoff;
-    for (const m of this.#iterateSessionRows(sessionId, { afterSeq: cutoff, desc: false })) {
+    for (const entry of this.#sessionFileEntries('messages', sessionId, { afterSeq: cutoff, desc: false })) {
+      let m;
+      try {
+        m = this.readMessageFile(entry.path);
+      } catch (err) {
+        if (isPermissionError(err)) continue;
+        throw err;
+      }
       if (!m || m.sessionId !== sessionId) continue;
       const seq = parseSeqFromId(m.id);
       if (Number.isFinite(seq) && seq > newestScannedSeq) newestScannedSeq = seq;
@@ -1401,13 +1156,7 @@ export class ConversationStore {
    * @returns {number}
    */
   countHot() {
-    let total = this.#countSegmentMessages([this.#chatDir, ...this.#sessionConversationDirs({ primaryOnly: true })]);
-    const markdownDirs = [this.#legacyMsgDir];
-    if (!this.#segmentStoreForConversationDir(this.#chatDir).hasData()) markdownDirs.push(this.#chatMsgDir);
-    for (const dir of this.#sessionConversationDirs()) {
-      if (!this.#segmentStoreForConversationDir(dir).hasData()) markdownDirs.push(join(dir, 'messages'));
-    }
-    return total + this.#countFilesInDirs(markdownDirs);
+    return this.#countFilesInDirs([this.#chatMsgDir, ...this.#sessionMessageDirs('messages'), this.#legacyMsgDir]);
   }
 
   /**
@@ -1416,8 +1165,7 @@ export class ConversationStore {
    * @returns {number}
    */
   countCold() {
-    return this.#countSegmentMessages([this.#chatDir, ...this.#sessionConversationDirs({ primaryOnly: true })], 'cold')
-      + this.#countFilesInDirs([this.#chatColdDir, ...this.#sessionMessageDirs('cold'), this.#legacyColdDir]);
+    return this.#countFilesInDirs([this.#chatColdDir, ...this.#sessionMessageDirs('cold'), this.#legacyColdDir]);
   }
 
   /**
@@ -1426,7 +1174,7 @@ export class ConversationStore {
    * @returns {number}
    */
   hotTokens() {
-    const messages = this.#loadHotMessages();
+    const messages = this.loadAll();
     return messages.reduce((sum, m) => sum + (m.tokens_est || estimateTokens(m.content || '')), 0);
   }
 
@@ -1473,13 +1221,7 @@ export class ConversationStore {
   deleteByGroup(sessionId) {
     if (!sessionId) return 0;
     let removed = 0;
-    const primaryDir = this.#sessionConversationDir(sessionId);
-    const segmentStore = this.#segmentStoreForConversationDir(primaryDir);
-    if (segmentStore.hasData()) {
-      removed += segmentStore.count('all');
-      segmentStore.clear();
-    }
-    for (const dir of [this.#chatMsgDir, this.#chatColdDir, ...this.#sessionMessageDirs('messages', sessionId), ...this.#sessionMessageDirs('cold', sessionId)]) {
+    for (const dir of [this.#chatMsgDir, this.#chatColdDir, ...this.#sessionMessageDirs('messages'), ...this.#sessionMessageDirs('cold'), this.#legacyMsgDir, this.#legacyColdDir]) {
       if (!existsSync(dir)) continue;
       let files;
       try {
@@ -1508,6 +1250,7 @@ export class ConversationStore {
         }
       }
     }
+    // Invalidate cached next-seq — countHot/loadAll will re-scan.
     this.#nextSeq = null;
     return removed;
   }
@@ -1536,33 +1279,6 @@ export class ConversationStore {
     let scanned = 0;
     let removed = 0;
     const orphans = [];
-
-    const scanMsg = (msg, locator) => {
-      if (!msg) return false;
-      scanned += 1;
-      const isOrphan = !msg.sessionId || !keep.has(msg.sessionId);
-      if (!isOrphan) return false;
-      orphans.push(locator);
-      return true;
-    };
-
-    for (const dir of [this.#chatDir, ...this.#sessionConversationDirs({ primaryOnly: true })]) {
-      const store = this.#segmentStoreForConversationDir(dir);
-      if (!store.hasData()) continue;
-      const rows = store.readAll({ includeCold: true });
-      let keepRows = [];
-      let dirty = false;
-      for (const msg of rows) {
-        const orphan = scanMsg(msg, `${dir}/${SEGMENT_DIR}/${msg.id || 'unknown'}`);
-        if (orphan) dirty = true;
-        else keepRows.push(msg);
-      }
-      if (dirty && !dryRun) {
-        store.replaceAll(keepRows);
-        removed += rows.length - keepRows.length;
-      }
-    }
-
     for (const dir of [this.#chatMsgDir, this.#chatColdDir, ...this.#sessionMessageDirs('messages'), ...this.#sessionMessageDirs('cold'), this.#legacyMsgDir, this.#legacyColdDir]) {
       if (!existsSync(dir)) continue;
       let files;
@@ -1582,7 +1298,11 @@ export class ConversationStore {
           throw err;
         }
         const msg = parseMessage(raw);
-        if (!scanMsg(msg, path)) continue;
+        if (!msg) continue;
+        scanned += 1;
+        const isOrphan = !msg.sessionId || !keep.has(msg.sessionId);
+        if (!isOrphan) continue;
+        orphans.push(path);
         if (dryRun) continue;
         try {
           unlinkSync(path);
@@ -1613,25 +1333,6 @@ export class ConversationStore {
   reassignThread(sourceId, targetId) {
     if (!sourceId || !targetId || sourceId === targetId) return 0;
     let rewritten = 0;
-
-    for (const dir of [this.#chatDir, ...this.#sessionConversationDirs({ primaryOnly: true })]) {
-      const store = this.#segmentStoreForConversationDir(dir);
-      if (!store.hasData()) continue;
-      const rows = store.readAll();
-      let dirty = false;
-      for (const msg of rows) {
-        if (!msg || msg.threadId !== sourceId) continue;
-        if (!msg.sourceThreadId) msg.sourceThreadId = sourceId;
-        msg.threadId = targetId;
-        rewritten += 1;
-        dirty = true;
-      }
-      if (dirty) {
-        store.clear();
-        for (const msg of rows) store.append(msg);
-      }
-    }
-
     for (const dir of [this.#chatMsgDir, this.#chatColdDir, ...this.#sessionMessageDirs('messages'), ...this.#sessionMessageDirs('cold'), this.#legacyMsgDir, this.#legacyColdDir]) {
       if (!existsSync(dir)) continue;
       let files;
@@ -1652,6 +1353,7 @@ export class ConversationStore {
         }
         const msg = parseMessage(raw);
         if (!msg || msg.threadId !== sourceId) continue;
+        // Preserve original thread id for UI pill; only stamp once.
         if (!msg.sourceThreadId) msg.sourceThreadId = sourceId;
         msg.threadId = targetId;
         try {
@@ -1708,9 +1410,19 @@ export class ConversationStore {
       throw err;
     }
 
-    // Collect source-thread candidate rows from segmented storage and legacy Markdown dirs.
-    const sourceRows = this.#loadAllMessages().filter(m => m && m.threadId === sourceId);
+    // Collect source-thread candidate files from both hot + cold dirs.
     const candidates = [];
+    for (const dir of [this.#chatColdDir, this.#chatMsgDir, ...this.#sessionMessageDirs('cold'), ...this.#sessionMessageDirs('messages'), this.#legacyColdDir, this.#legacyMsgDir]) {
+      if (!existsSync(dir)) continue;
+      let files;
+      try {
+        files = readdirSync(dir).filter(f => f.endsWith('.md'));
+      } catch (err) {
+        if (isPermissionError(err)) continue;
+        throw err;
+      }
+      for (const f of files) candidates.push(join(dir, f));
+    }
     // Also pick up any already-forked sub-thread dir (chain fork).
     const sourceSubDir = this.#threadMsgDir(sourceId);
     if (existsSync(sourceSubDir)) {
@@ -1722,7 +1434,11 @@ export class ConversationStore {
         if (!isPermissionError(err)) throw err;
       }
     }
-    sourceRows.sort(compareMessagesBySeq);
+    // Sort by the "m{NNNN}" basename. For chain-fork, sub-thread ids also
+    // restart at m0001 so sorting by basename alone is ambiguous across
+    // dirs; but a given source thread stores messages in exactly ONE place
+    // (either legacy flat dir OR its sub-dir — see below), so ties never
+    // arise. Sorting by (path, seq) is still well-defined.
     candidates.sort((a, b) => {
       const ma = a.match(/m(\d+)\.md$/);
       const mb = b.match(/m(\d+)\.md$/);
@@ -1734,13 +1450,25 @@ export class ConversationStore {
     const cutoffSeq = parseInt(cutoffMatch[1], 10);
 
     let copied = 0;
-    const copyMsg = (msg) => {
-      if (!msg || msg.threadId !== sourceId) return;
-      const seq = parseSeqFromId(msg.id);
-      if (!Number.isFinite(seq) || seq > cutoffSeq) return;
+    for (const path of candidates) {
+      const fileMatch = path.match(/m(\d+)\.md$/);
+      if (!fileMatch) continue;
+      const seq = parseInt(fileMatch[1], 10);
+      if (seq > cutoffSeq) continue; // do not break — sub-thread dir mixed in may interleave
+      let raw;
+      try {
+        raw = readFileSync(path, 'utf8');
+      } catch (err) {
+        if (isPermissionError(err)) continue;
+        throw err;
+      }
+      const msg = parseMessage(raw);
+      if (!msg || msg.threadId !== sourceId) continue;
+      // Mint a fresh per-thread id restarting at m0001 under the target
+      // thread's own namespace.
       const nextSeq = this.#getNextThreadSeq(targetId);
       const newId = `m${String(nextSeq).padStart(4, '0')}`;
-      const { id: _id, seq: _seq, ...rest } = msg;
+      const { id: _id, ...rest } = msg;
       const copy = {
         ...rest,
         id: newId,
@@ -1750,18 +1478,10 @@ export class ConversationStore {
         tokens_est: rest.tokens_est || estimateTokens(rest.content || ''),
       };
       const filePath = join(targetDir, `${newId}.md`);
-      writeFileSync(filePath, serializeMessage(copy), { encoding: 'utf8', mode: 0o644 });
-      this.#nextSeqByThread.set(targetId, nextSeq + 1);
-      copied += 1;
-    };
-    for (const msg of sourceRows) {
-      try { copyMsg(msg); }
-      catch (err) { if (isPermissionError(err)) continue; throw err; }
-    }
-    for (const path of candidates) {
       try {
-        const msg = parseMessage(readFileSync(path, 'utf8'));
-        copyMsg(msg);
+        writeFileSync(filePath, serializeMessage(copy), { encoding: 'utf8', mode: 0o644 });
+        this.#nextSeqByThread.set(targetId, nextSeq + 1);
+        copied += 1;
       } catch (err) {
         if (isPermissionError(err)) continue;
         throw err;
@@ -1797,10 +1517,8 @@ export class ConversationStore {
       }
       return out;
     }
-    // Legacy plus segmented root: messages live in the flat/session stores stamped with threadId.
-    const collected = this.#loadAllMessages()
-      .filter(msg => msg && msg.threadId === threadId)
-      .map(msg => ({ msg, f: `${msg.id || ''}.md` }));
+    // Legacy: messages live in the flat dir stamped with threadId.
+    const collected = [];
     for (const dir of [this.#chatColdDir, this.#chatMsgDir, ...this.#sessionMessageDirs('cold'), ...this.#sessionMessageDirs('messages'), this.#legacyColdDir, this.#legacyMsgDir]) {
       if (!existsSync(dir)) continue;
       for (const f of readdirSync(dir).filter(x => x.endsWith('.md'))) {
@@ -1821,6 +1539,12 @@ export class ConversationStore {
     return collected.map(x => x.msg);
   }
 
+  #messageDirFor(msg) {
+    if (msg?.chatId) return join(this.#chatConversationDir(msg.chatId, { create: true }), 'messages');
+    if (!msg?.sessionId) return this.#chatMsgDir;
+    return join(this.#sessionConversationDir(msg.sessionId, { create: true }), 'messages');
+  }
+
   #chatConversationDir(chatId, { create = false } = {}) {
     const dir = join(this.#dir, 'chats', this.#safeDirComponent(chatId), 'conversation');
     if (create) this.#ensureConversationDirs(dir);
@@ -1886,7 +1610,6 @@ export class ConversationStore {
   loadRecentByChat(chatId, turnsLimit = DEFAULT_RECENT_TURNS) {
     if (!chatId) return [];
     const all = [
-      ...this.#readSegmentRows(this.#chatConversationDir(chatId)),
       ...this.#chatMessageDirs('messages', chatId).flatMap(dir => this.#loadFromDir(dir, Infinity)),
       ...this.#chatMessageDirs('cold', chatId).flatMap(dir => this.#loadFromDir(dir, Infinity)),
     ].sort(compareMessagesBySeq);
@@ -1899,7 +1622,6 @@ export class ConversationStore {
   loadChatHistoryForVp(chatId, vpId) {
     if (!chatId || !vpId) return [];
     const all = [
-      ...this.#readSegmentRows(this.#chatConversationDir(chatId)),
       ...this.#chatMessageDirs('messages', chatId).flatMap(dir => this.#loadFromDir(dir, Infinity)),
       ...this.#chatMessageDirs('cold', chatId).flatMap(dir => this.#loadFromDir(dir, Infinity)),
     ].sort(compareMessagesBySeq);
@@ -1929,28 +1651,15 @@ export class ConversationStore {
   }
 
   #ensureConversationDirs(dir) {
-    for (const d of [dir, join(dir, 'blobs'), join(dir, SEGMENT_DIR), join(dir, 'messages'), join(dir, 'cold'), join(dir, 'compact')]) {
+    for (const d of [dir, join(dir, 'blobs'), join(dir, 'messages'), join(dir, 'cold'), join(dir, 'compact')]) {
       if (!existsSync(d)) mkdirSync(d, { recursive: true, mode: 0o755 });
     }
   }
 
-  #segmentStoreFor(msg, { create = false } = {}) {
-    let dir;
-    if (msg?.chatId) dir = this.#chatConversationDir(msg.chatId, { create });
-    else if (msg?.sessionId) dir = this.#sessionConversationDir(msg.sessionId, { create });
-    else dir = this.#chatDir;
-    return new SegmentStore(dir);
-  }
-
-  #segmentStoreForConversationDir(dir) {
-    return new SegmentStore(dir);
-  }
-
-
-  #sessionConversationDirs({ primaryOnly = false } = {}) {
+  #sessionConversationDirs() {
     const dirs = [];
     const seen = new Set();
-    for (const root of (primaryOnly ? [this.#sessionsDir] : [this.#sessionsDir, this.#legacySessionsDir])) {
+    for (const root of [this.#sessionsDir, this.#legacySessionsDir]) {
       if (!existsSync(root)) continue;
       for (const name of readdirSync(root)) {
         const sessionDir = join(root, name);
@@ -1970,19 +1679,15 @@ export class ConversationStore {
   }
 
   #sessionMessageDirs(kind, sessionId = null) {
-    const kinds = kind === 'all' ? ['cold', 'messages'] : [kind];
     if (sessionId) {
-      const dirs = [];
-      for (const k of kinds) {
-        dirs.push(
-          join(this.#sessionConversationDir(sessionId), k),
-          join(this.#legacySessionConversationDir(sessionId), k),
-        );
-      }
+      const dirs = [
+        join(this.#sessionConversationDir(sessionId), kind),
+        join(this.#legacySessionConversationDir(sessionId), kind),
+      ];
       return dirs.filter(dir => existsSync(dir));
     }
     return this.#sessionConversationDirs()
-      .flatMap(dir => kinds.map(k => join(dir, k)))
+      .map(dir => join(dir, kind))
       .filter(dir => existsSync(dir));
   }
 
@@ -2000,18 +1705,15 @@ export class ConversationStore {
     // mode compatibility, only import legacy records that are not stamped with
     // a sessionId, so group mode cannot bleed into chat.
     return [
-      ...this.#readSegmentRows(this.#chatDir).filter(m => !m?.sessionId),
       ...this.#loadFromDir(this.#legacyMsgDir, Infinity).filter(m => !m?.sessionId),
       ...this.#loadFromDir(this.#chatMsgDir, Infinity),
     ].sort(compareMessagesBySeq);
   }
 
   #loadSessionHotMessages(sessionId = null) {
-    if (sessionId) return this.#readSessionRows(sessionId);
-    return [
-      ...this.#sessionConversationDirs({ primaryOnly: true }).flatMap(dir => this.#readSegmentRows(dir)),
-      ...this.#sessionMessageDirs('messages', null).flatMap(dir => this.#loadFromDir(dir, Infinity)),
-    ].sort(compareMessagesBySeq);
+    return this.#sessionMessageDirs('messages', sessionId)
+      .flatMap(dir => this.#loadFromDir(dir, Infinity))
+      .sort(compareMessagesBySeq);
   }
 
   #loadSessionMessages(sessionId = null) {
@@ -2058,13 +1760,20 @@ export class ConversationStore {
     // and stop after the requested turn window is complete. Hidden/internal and
     // non-turn rows are not allowed to force an unbounded scan; a hard parse cap
     // conservatively marks the page truncated.
-    for (const m of this.#iterateSessionRows(sessionId, { beforeSeq, desc: true })) {
+    for (const entry of this.#sessionFileEntries('messages', sessionId, { beforeSeq, desc: true })) {
       if (parsed >= scanCap) {
         truncated = true;
         break;
       }
       parsed += 1;
 
+      let m;
+      try {
+        m = this.readMessageFile(entry.path);
+      } catch (err) {
+        if (isPermissionError(err)) continue;
+        throw err;
+      }
       if (!m || m.sessionId !== sessionId) continue;
 
       const boundaryComplete = turnsFromEnd >= turnsLimit;
@@ -2115,38 +1824,8 @@ export class ConversationStore {
     };
   }
 
-  #readSegmentRows(conversationDir, opts = {}) {
-    return this.#segmentStoreForConversationDir(conversationDir).readAll(opts);
-  }
-
-  *#iterateSessionRows(sessionId, opts = {}) {
-    const primaryDir = this.#sessionConversationDir(sessionId);
-    const segmentStore = this.#segmentStoreForConversationDir(primaryDir);
-    yield* segmentStore.scan({ includeCold: true, ...opts });
-    for (const entry of this.#sessionFileEntries('all', sessionId, opts)) {
-      try {
-        const msg = this.readMessageFile(entry.path);
-        if (msg) yield msg;
-      } catch (err) {
-        if (isPermissionError(err)) continue;
-        throw err;
-      }
-    }
-  }
-
-  #readSessionRows(sessionId, opts = {}) {
-    return Array.from(this.#iterateSessionRows(sessionId, opts)).sort(compareMessagesBySeq);
-  }
-
-  #countSegmentMessages(conversationDirs, kind = 'hot') {
-    let total = 0;
-    for (const dir of conversationDirs) total += this.#segmentStoreForConversationDir(dir).count(kind);
-    return total;
-  }
-
   #sessionFileEntries(kind, sessionId, { beforeSeq = Infinity, afterSeq = -Infinity, desc = false } = {}) {
     const entries = [];
-    const kindOrder = kind === 'all' ? { cold: 0, messages: 1 } : null;
     for (const dir of this.#sessionMessageDirs(kind, sessionId)) {
       let files;
       try {
@@ -2161,14 +1840,10 @@ export class ConversationStore {
         if (!Number.isFinite(seq)) continue;
         if (Number.isFinite(beforeSeq) && seq >= beforeSeq) continue;
         if (Number.isFinite(afterSeq) && seq <= afterSeq) continue;
-        const kindRank = kindOrder ? kindOrder[basename(dir)] ?? 0 : 0;
-        entries.push({ path: join(dir, file), seq, kindRank });
+        entries.push({ path: join(dir, file), seq });
       }
     }
-    entries.sort((a, b) => {
-      if (a.seq !== b.seq) return desc ? b.seq - a.seq : a.seq - b.seq;
-      return desc ? b.kindRank - a.kindRank : a.kindRank - b.kindRank;
-    });
+    entries.sort((a, b) => desc ? b.seq - a.seq : a.seq - b.seq);
     return entries;
   }
 
@@ -2178,25 +1853,11 @@ export class ConversationStore {
       ...this.#loadFromDir(this.#legacyMsgDir, Infinity),
       ...this.#loadFromDir(this.#chatColdDir, Infinity),
       ...this.#loadFromDir(this.#chatMsgDir, Infinity),
-      ...this.#readSegmentRows(this.#chatDir, { includeCold: true }),
-      ...this.#sessionConversationDirs({ primaryOnly: true }).flatMap(dir => this.#readSegmentRows(dir, { includeCold: true })),
       ...this.#sessionMessageDirs('cold').flatMap(dir => this.#loadFromDir(dir, Infinity)),
       ...this.#sessionMessageDirs('messages').flatMap(dir => this.#loadFromDir(dir, Infinity)),
     ].sort(compareMessagesBySeq);
   }
 
-  #loadHotMessages() {
-    return [
-      ...this.#loadFromDir(this.#legacyMsgDir, Infinity),
-      ...this.#loadFromDir(this.#chatMsgDir, Infinity),
-      ...this.#readSegmentRows(this.#chatDir),
-      ...this.#sessionConversationDirs({ primaryOnly: true }).flatMap(dir => this.#readSegmentRows(dir)),
-      ...this.#sessionMessageDirs('messages').flatMap(dir => this.#loadFromDir(dir, Infinity)),
-    ]
-      .filter(m => m && m.cold !== true)
-      .sort(compareMessagesBySeq);
-  }
-
   #countFilesInDirs(dirs) {
     let total = 0;
     for (const dir of dirs) {
@@ -2261,7 +1922,7 @@ export class ConversationStore {
     const messages = [];
     for (const file of selected) {
       const raw = readFileSync(join(dir, file), 'utf8');
-      const parsed = parseSegmentOrMarkdown(raw);
+      const parsed = parseMessage(raw);
       if (parsed) messages.push(parsed);
     }
 
@@ -2276,13 +1937,6 @@ export class ConversationStore {
     if (this.#nextSeq != null) return this.#nextSeq;
 
     let maxSeq = 0;
-    for (const dir of [this.#chatDir, ...this.#sessionConversationDirs({ primaryOnly: true })]) {
-      const store = this.#segmentStoreForConversationDir(dir);
-      if (store.hasData()) {
-        const idx = store.loadIndex();
-        maxSeq = Math.max(maxSeq, (Number(idx.nextSeq) || 1) - 1);
-      }
-    }
     for (const dir of [this.#chatMsgDir, this.#chatColdDir, ...this.#sessionMessageDirs('messages'), ...this.#sessionMessageDirs('cold'), this.#legacyMsgDir, this.#legacyColdDir]) {
       if (!existsSync(dir)) continue;
       for (const file of readdirSync(dir)) {

package/yeaft/conversation/search.js

@@ -8,24 +8,14 @@ import { existsSync, readdirSync, readFileSync, statSync } from 'fs';
 import { join } from 'path';
 import { parseMessage, parseSeqFromId } from './persist.js';
 
-function parseJsonLine(line) {
-  if (!line || !line.trim()) return null;
-  try {
-    const msg = JSON.parse(line);
-    return msg && typeof msg === 'object' ? msg : null;
-  } catch {
-    return null;
-  }
-}
-
 /**
- * Search Markdown messages in a directory for a keyword.
+ * Search messages in a directory for a keyword.
  *
  * @param {string} dir — messages directory
  * @param {string} keyword — search term (case-insensitive)
  * @returns {object[]} — matching messages
  */
-function searchMarkdownDir(dir, keyword) {
+function searchDir(dir, keyword) {
   if (!existsSync(dir)) return [];
 
   const lowerKeyword = keyword.toLowerCase();
@@ -45,29 +35,6 @@ function searchMarkdownDir(dir, keyword) {
   return results;
 }
 
-function searchSegmentDir(dir, keyword) {
-  if (!existsSync(dir)) return [];
-  const lowerKeyword = keyword.toLowerCase();
-  const files = readdirSync(dir)
-    .filter(f => f.endsWith('.jsonl'))
-    .sort()
-    .reverse();
-
-  const results = [];
-  for (const file of files) {
-    const raw = readFileSync(join(dir, file), 'utf8');
-    if (!raw.toLowerCase().includes(lowerKeyword)) continue;
-    const lines = raw.split('\n');
-    for (let i = lines.length - 1; i >= 0; i -= 1) {
-      const line = lines[i];
-      if (!line || !line.toLowerCase().includes(lowerKeyword)) continue;
-      const msg = parseJsonLine(line);
-      if (msg) results.push(msg);
-    }
-  }
-  return results;
-}
-
 function compareNewest(a, b) {
   const sa = parseSeqFromId(a?.id);
   const sb = parseSeqFromId(b?.id);
@@ -75,7 +42,7 @@ function compareNewest(a, b) {
   return String(b?.time || '').localeCompare(String(a?.time || ''));
 }
 
-function sessionConversationDirs(dir) {
+function sessionConversationMessageDirs(dir) {
   const dirs = [];
   const seen = new Set();
   for (const rootName of ['sessions', 'groups']) {
@@ -90,9 +57,12 @@ function sessionConversationDirs(dir) {
       }
 
       const conversationDir = join(sessionDir, 'conversation');
-      if (seen.has(conversationDir)) continue;
-      seen.add(conversationDir);
-      dirs.push(conversationDir);
+      for (const kind of ['messages', 'cold']) {
+        const messagesDir = join(conversationDir, kind);
+        if (seen.has(messagesDir)) continue;
+        seen.add(messagesDir);
+        dirs.push(messagesDir);
+      }
     }
   }
   return dirs;
@@ -109,23 +79,17 @@ function sessionConversationDirs(dir) {
 export function searchMessages(dir, keyword, limit = 20) {
   if (!keyword || !keyword.trim()) return [];
 
-  const conversationDirs = [
-    join(dir, 'chat'),
-    ...sessionConversationDirs(dir),
-  ];
-
-  const markdownDirs = [
-    ...conversationDirs.flatMap(d => [join(d, 'messages'), join(d, 'cold')]),
+  const dirs = [
+    join(dir, 'chat', 'messages'),
+    join(dir, 'chat', 'cold'),
+    ...sessionConversationMessageDirs(dir),
     // Compatibility for profiles created before chat/session split.
     join(dir, 'conversation', 'messages'),
     join(dir, 'conversation', 'cold'),
   ];
-  const segmentDirs = conversationDirs.map(d => join(d, 'segments'));
 
-  return [
-    ...segmentDirs.flatMap(d => searchSegmentDir(d, keyword)),
-    ...markdownDirs.flatMap(d => searchMarkdownDir(d, keyword)),
-  ]
+  return dirs
+    .flatMap(d => searchDir(d, keyword))
     .sort(compareNewest)
     .slice(0, limit);
 }

package/yeaft/session.js

@@ -45,7 +45,7 @@ import { TaskManager } from './tasks/manager.js';
 // resumes with the same onDemand/recent membership it had on
 // disconnect. Engine.#runQuery uses the registry to populate the
 // AMS each turn and to run `memory/adjust.js` post-turn.
-import { ensureDefaultSessionIfEmpty, yeaftDirForWorkDir } from './sessions/session-crud.js';
+import { ensureDefaultSessionIfEmpty } from './sessions/session-crud.js';
 import { seedDefaultVps } from './vp/seed-defaults.js';
 import { topUpDefaultVps } from './vp/seed-topup.js';
 import { archiveLegacyScopes } from './memory/seed-backfill.js';
@@ -71,7 +71,6 @@ const DEFAULT_COMPACT_TRIGGER_RATIO = 0.7;
 /**
  * @typedef {Object} SessionOptions
  * @property {string} [dir] — Yeaft data directory override (default: ~/.yeaft)
- * @property {string} [workDir] — Session workDir; when provided, storage lives under <workDir>/.yeaft while config still comes from dir/defaults
  * @property {string} [model] — Model override
  * @property {string} [language] — Language override ('en' | 'zh')
  * @property {boolean} [debug] — Debug mode override
@@ -137,7 +136,6 @@ function prepareToolStatsDir(yeaftDir) {
 export async function loadSession(options = {}) {
   const {
     dir,
-    workDir,
     model,
     language,
     debug,
@@ -148,29 +146,21 @@ export async function loadSession(options = {}) {
     serverMode = false,
   } = options;
 
-  // ─── 1. Determine config + store directories ─────────────
-  //        Must happen BEFORE loadConfig so that first-run generates a
-  //        default config.json that loadConfig can read. workDir-backed
-  //        Sessions store conversation/session data under <workDir>/.yeaft,
-  //        but runtime config still comes from the agent-local configDir.
+  // ─── 1. Determine yeaftDir + ensure directory structure ──
+  //        Must happen BEFORE loadConfig so that first-run
+  //        generates a default config.json that loadConfig can read.
   const overrides = { ...configOverrides };
   if (dir) overrides.dir = dir;
   if (model) overrides.model = model;
   if (language) overrides.language = language;
   if (debug !== undefined) overrides.debug = debug;
 
-  const sessionWorkDir = typeof workDir === 'string' && workDir.trim() ? workDir.trim() : '';
-  const configDir = overrides.dir || process.env.YEAFT_DIR || DEFAULT_YEAFT_DIR;
-  const yeaftDir = sessionWorkDir ? yeaftDirForWorkDir(sessionWorkDir) : configDir;
-  const configInitResult = initYeaftDir(configDir);
-  const storeInitResult = yeaftDir === configDir ? configInitResult : initYeaftDir(yeaftDir);
-  overrides.dir = configDir;
-
-  // Log any warnings from directory initialization.
-  const initWarnings = yeaftDir === configDir
-    ? configInitResult.warnings
-    : [...configInitResult.warnings, ...storeInitResult.warnings];
-  for (const w of initWarnings) {
+  const yeaftDir = overrides.dir || process.env.YEAFT_DIR || DEFAULT_YEAFT_DIR;
+  const initResult = initYeaftDir(yeaftDir);
+  overrides.dir = yeaftDir;
+
+  // Log any warnings from directory initialization
+  for (const w of initResult.warnings) {
     console.warn(`[Yeaft] ${w}`);
   }
 
@@ -222,7 +212,7 @@ export async function loadSession(options = {}) {
   // ─── 2a. Permission pre-check ─────────────────────────
   //         If the data dir is not writable, mark session as read-only.
   //         Persistence (conversation, memory, dream) is skipped in this mode.
-  if (!storeInitResult.writable) {
+  if (!initResult.writable) {
     config._readOnly = true;
     console.warn(`[Yeaft] ${yeaftDir} is not writable — running in read-only mode`);
   }
@@ -375,23 +365,24 @@ export async function loadSession(options = {}) {
   }
 
   // ─── 6. Load skills ────────────────────────────────────
-  // User/global runtime assets still come from configDir. workDir, when
-  // present, is only a project tier overlay plus the storage root.
-  const projectTierRoot = sessionWorkDir || process.cwd();
+  // Project tier root for skills + MCP project assets. Per-session workDir
+  // overlays are loaded by web-bridge once it knows the selected Session meta;
+  // the base runtime still uses the agent process cwd for global/default status.
+  const projectTierRoot = process.cwd();
 
   let skillManager;
   if (skipSkills) {
     // Pass the literal user-tier dir (matches the normal branch's tier 2)
     // so any save/remove calls land in the same place users expect. New
     // `SkillManager` API takes literal scan dirs — no auto-suffix of /skills.
-    skillManager = new SkillManager(join(configDir, 'skills'));
+    skillManager = new SkillManager(join(yeaftDir, 'skills'));
     // Don't call .load() — empty skill manager
   } else {
-    skillManager = createSkillManager(configDir, projectTierRoot);
+    skillManager = createSkillManager(yeaftDir, projectTierRoot);
   }
 
   // ─── 7. Connect MCP servers ────────────────────────────
-  const mcpConfig = loadMCPConfig(configDir, undefined, projectTierRoot);
+  const mcpConfig = loadMCPConfig(yeaftDir, undefined, projectTierRoot);
   const mcpManager = new MCPManager();
   let mcpStatus = { connected: [], failed: [] };
 

package/yeaft/web-bridge.js

@@ -53,7 +53,6 @@ import {
   scanWorkdirSessions,
   restoreSessionToRegistry,
   readWorkDirRegistry,
-  yeaftDirForWorkDir,
 } from './sessions/session-crud.js';
 import { openSession, loadSessionMeta } from './sessions/session-store.js';
 import { loadSessionConfig, resolveSessionConfig, SessionConfigError } from './sessions/session-config.js';
@@ -415,13 +414,6 @@ function projectRuntimeKey(workDir) {
   return normalizeSessionWorkDir(workDir) || '__agent_cwd__';
 }
 
-function resolveStoreYeaftDirForSession(defaultYeaftDir, { sessionId = null, sessionMeta = null, workDir = '' } = {}) {
-  const normalizedWorkDir = normalizeSessionWorkDir(workDir || sessionMeta?.workDir);
-  if (normalizedWorkDir) return yeaftDirForWorkDir(normalizedWorkDir);
-  if (sessionId) return resolveSessionYeaftDir(defaultYeaftDir, sessionId);
-  return defaultYeaftDir;
-}
-
 function createThreadId() {
   return `thr_${Date.now().toString(36)}_${randomUUID().slice(0, 8)}`;
 }
@@ -3888,11 +3880,6 @@ async function ensureSessionLoaded(opts = {}) {
   sessionLoadPromise = (async () => {
     const yeaftDir = ctx.CONFIG?.yeaftDir;
     const normalizedWorkDir = normalizeSessionWorkDir(opts?.workDir || opts?.sessionMeta?.workDir);
-    const sessionYeaftDir = resolveStoreYeaftDirForSession(yeaftDir, {
-      sessionId: opts?.sessionId || opts?.sessionMeta?.id || null,
-      sessionMeta: opts?.sessionMeta || null,
-      workDir: normalizedWorkDir,
-    });
     session = await loadSession({
       ...(yeaftDir && { dir: yeaftDir }),
       ...(normalizedWorkDir && { workDir: normalizedWorkDir }),
@@ -5653,22 +5640,12 @@ export async function handleYeaftLoadHistory(msg) {
     const limit = (typeof msg.limit === 'number') ? msg.limit : 10;
     ensureYeaftConversationId();
 
-    let sessionMetaForRuntime = null;
-    let sessionYeaftDir = yeaftDir;
-    if (sessionId) {
-      try {
-        sessionYeaftDir = resolveSessionYeaftDir(yeaftDir, sessionId);
-        const metaDir = join(sessionsRoot(sessionYeaftDir), sessionId);
-        sessionMetaForRuntime = loadSessionMeta(metaDir);
-      } catch { /* best-effort metadata hint */ }
-    }
-
     // First paint must not wait for full Yeaft runtime boot (MCP connects,
-    // skill scans, memory index sync). The conversation segment store is the
+    // skill scans, memory index sync). The conversation markdown store is the
     // source of truth and can be opened cheaply, so replay the visible message
     // window immediately, then finish loadSession below for actual turns.
     const coldStoreStart = perfNowMs();
-    const coldStore = new ConversationStore(sessionYeaftDir);
+    const coldStore = new ConversationStore(yeaftDir);
     traceDuration('history.cold_store_open', coldStoreStart);
     if (sessionId && (afterSeqRaw !== null || afterMessageId)) {
       let afterSeq = afterSeqRaw;
@@ -5698,6 +5675,14 @@ export async function handleYeaftLoadHistory(msg) {
     }
     historyAlreadyReplayed = true;
 
+    let sessionMetaForRuntime = null;
+    if (sessionId) {
+      try {
+        const groupYeaftDir = resolveSessionYeaftDir(yeaftDir, sessionId);
+        const metaDir = join(sessionsRoot(groupYeaftDir), sessionId);
+        sessionMetaForRuntime = loadSessionMeta(metaDir);
+      } catch { /* best-effort metadata hint */ }
+    }
     // Full runtime boot can be expensive (memory FTS sync, skills, MCP, dream
     // boot checks). It is not needed to render persisted history, so keep this
     // request short and let message-send await the same single-flight boot when