@yeaft/webchat-agent 1.0.88 → 1.0.89

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.88",
+  "version": "1.0.89",
   "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/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, migrateRegisteredWorkDirSessions } 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,7 @@ 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} [workDir] — Session workDir; used only for project-tier assets such as skills/MCP, while Session data stays under the user-level dir
  * @property {string} [model] — Model override
  * @property {string} [language] — Language override ('en' | 'zh')
  * @property {boolean} [debug] — Debug mode override
@@ -150,9 +150,10 @@ export async function loadSession(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.
+  //        default config.json that loadConfig can read. Session data
+  //        (metadata/roster/config/messages/memory/tasks) is agent-user data
+  //        and stays under configDir (`~/.yeaft`). workDir is only a project
+  //        tier for assets such as skills and MCP config.
   const overrides = { ...configOverrides };
   if (dir) overrides.dir = dir;
   if (model) overrides.model = model;
@@ -161,15 +162,13 @@ export async function loadSession(options = {}) {
 
   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 yeaftDir = configDir;
   const configInitResult = initYeaftDir(configDir);
-  const storeInitResult = yeaftDir === configDir ? configInitResult : initYeaftDir(yeaftDir);
+  const storeInitResult = configInitResult;
   overrides.dir = configDir;
 
   // Log any warnings from directory initialization.
-  const initWarnings = yeaftDir === configDir
-    ? configInitResult.warnings
-    : [...configInitResult.warnings, ...storeInitResult.warnings];
+  const initWarnings = configInitResult.warnings;
   for (const w of initWarnings) {
     console.warn(`[Yeaft] ${w}`);
   }
@@ -219,6 +218,22 @@ export async function loadSession(options = {}) {
   //         dream directly. Existing users have already migrated
   //         (state file in ~/.yeaft/.memory-v2-migration.json).
 
+  // ─── 2.3 Project-session migration ─────────────────────
+  //         Session data used to be allowed under `<workDir>/.yeaft/sessions`.
+  //         It is now user-level only (`~/.yeaft/sessions`). Copy any registered
+  //         project-backed sessions into the user root before stores open.
+  try {
+    const migration = migrateRegisteredWorkDirSessions(configDir);
+    if (migration.migrated.length > 0 || migration.errors.length > 0) {
+      console.log(
+        `[Yeaft] session project-store migration: migrated=${migration.migrated.length} ` +
+        `errors=${migration.errors.length}`,
+      );
+    }
+  } catch (err) {
+    console.warn(`[Yeaft] session project-store migration failed: ${err?.message || err}`);
+  }
+
   // ─── 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.

package/yeaft/sessions/session-config.js

@@ -1,10 +1,11 @@
 /**
  * session-config.js — Per-session selected model override state.
  *
- * Each session may carry its header-selected model override in `config.json` at
+ * Each session carries its header-selected model override in `config.json` at
  *   ~/.yeaft/sessions/<sessionId>/config.json
- * or, for workDir-backed sessions:
- *   <workDir>/.yeaft/sessions/<sessionId>/config.json
+ *
+ * Session config is user-level state. Project `.yeaft` directories may provide
+ * project assets such as skills/MCP config, but must not own Session config.
  *
  * v1 schema (intentionally tiny — extend via additive keys only):
  *   {
@@ -24,7 +25,7 @@
 import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 import { writeAtomic } from '../storage/index.js';
-import { sessionsRoot, resolveSessionYeaftDir } from './session-crud.js';
+import { sessionsRoot } from './session-crud.js';
 
 const CONFIG_FILE = 'config.json';
 
@@ -41,14 +42,12 @@ export class SessionConfigError extends Error {
 }
 
 /**
- * Resolve the on-disk path for a session's config.json. Honours the
- * per-session workDir registry so sessions bound to a project directory
- * keep their config alongside the session metadata.
+ * Resolve the on-disk path for a session's config.json. Always uses the
+ * agent-local Yeaft root (`~/.yeaft` in production), not a project `.yeaft`.
  */
 export function sessionConfigPath(yeaftDir, sessionId) {
   if (!yeaftDir) return null;
-  const sessionYeaftDir = resolveSessionYeaftDir(yeaftDir, sessionId);
-  return join(sessionsRoot(sessionYeaftDir), sessionId, CONFIG_FILE);
+  return join(sessionsRoot(yeaftDir), sessionId, CONFIG_FILE);
 }
 
 /**

package/yeaft/sessions/session-crud.js

@@ -38,6 +38,7 @@ import {
   existsSync,
   renameSync,
   rmSync,
+  cpSync,
   readdirSync,
   statSync,
   mkdirSync,
@@ -156,101 +157,94 @@ export function unregisterSessionWorkDir(defaultYeaftDir, sessionId) {
 }
 
 /**
- * Scan the `.yeaft/sessions/` directory under `workDir` and return every
- * session meta we can read. Read-only: never touches the registry.
+ * One-way compatibility migration for sessions previously stored under a
+ * project `.yeaft/sessions` tree. New reads/writes never use that location, but
+ * older installs may still have their only `session.json` + conversation jsonl
+ * there and a `group-workdirs.json` registry entry pointing to it.
  *
- * Each returned record carries `workDir` (the normalized path we scanned).
- * This utility deliberately does NOT decorate `alreadyRegistered` — that
- * cross-references the central workdir registry, which is a separate
- * concern owned by the handler / caller (see
- * `handleYeaftScanWorkdirSessions`). Keeping the utility layer-pure makes
- * it usable from contexts that don't have / don't care about the registry
- * (e.g. CLI tools, future per-workdir snapshots).
+ * We copy missing session directories into the user-level root and never
+ * overwrite an existing user-level session. The old project directory is left in
+ * place as a safety backup; subsequent runtime paths ignore it.
  *
- * Returns `[]` for missing dir / empty dir / unreadable dir — never throws.
- * Sort is `createdAt` descending (most-recent first) because the restore
- * UI typically cares about "the session I made yesterday".
+ * @param {string} yeaftDir user-level Yeaft root
+ * @returns {{migrated:string[], skipped:string[], errors:Array<{sessionId:string,error:string}>}}
+ */
+export function migrateRegisteredWorkDirSessions(yeaftDir) {
+  const result = { migrated: [], skipped: [], errors: [] };
+  if (!yeaftDir) return result;
+  const registry = readWorkDirRegistry(yeaftDir);
+  const userRoot = sessionsRoot(yeaftDir);
+  for (const [sessionId, workDir] of Object.entries(registry)) {
+    const normalized = normalizeWorkDir(workDir);
+    if (!sessionId || !normalized) continue;
+    const sourceDir = join(sessionsRoot(yeaftDirForWorkDir(normalized)), sessionId);
+    const targetDir = join(userRoot, sessionId);
+    let tmpDir = null;
+    try {
+      if (existsSync(targetDir)) {
+        const targetMeta = loadSessionMeta(targetDir);
+        if (targetMeta) {
+          result.skipped.push(sessionId);
+        } else {
+          result.errors.push({ sessionId, error: 'target session directory exists but session metadata is invalid' });
+        }
+        continue;
+      }
+      const sourceMeta = existsSync(sourceDir) ? loadSessionMeta(sourceDir) : null;
+      if (!sourceMeta) {
+        result.skipped.push(sessionId);
+        continue;
+      }
+      mkdirSync(userRoot, { recursive: true });
+      tmpDir = join(userRoot, `.migrating-${sessionId}-${randomBytes(6).toString('hex')}`);
+      cpSync(sourceDir, tmpDir, { recursive: true, errorOnExist: true });
+      const copiedMeta = loadSessionMeta(tmpDir);
+      if (!copiedMeta || copiedMeta.id !== sessionId) {
+        throw new Error('copied session metadata failed validation');
+      }
+      renameSync(tmpDir, targetDir);
+      tmpDir = null;
+      result.migrated.push(sessionId);
+    } catch (err) {
+      if (tmpDir) rmSync(tmpDir, { recursive: true, force: true });
+      result.errors.push({ sessionId, error: err?.message || String(err) });
+    }
+  }
+  return result;
+}
+
+/**
+ * Workdir Session storage was retired: Session metadata/roster/config/history
+ * live under the agent-local Yeaft root (`~/.yeaft/sessions`), not under a
+ * project `.yeaft/sessions` tree. Keep this helper as a compatibility no-op for
+ * older UI flows that may still ask to scan a workdir.
  *
  * @param {string} workDir — the working directory to scan.
  * @returns {Array<object>}
  */
 export function scanWorkdirSessions(workDir) {
-  const normalized = normalizeWorkDir(workDir);
-  if (!normalized) return [];
-  const groupYeaftDir = yeaftDirForWorkDir(normalized);
-  const root = sessionsRoot(groupYeaftDir);
-  if (!existsSync(root)) return [];
-  const out = [];
-  let entries;
-  try {
-    entries = readdirSync(root);
-  } catch {
-    return [];
-  }
-  for (const name of entries) {
-    if (name.startsWith('.')) continue; // skip .archived-* and dotfiles
-    const dir = join(root, name);
-    try { if (!statSync(dir).isDirectory()) continue; } catch { continue; }
-    const meta = loadSessionMeta(dir);
-    if (!meta) continue;
-    out.push({
-      ...meta,
-      workDir: normalized,
-    });
-  }
-  return out.sort((a, b) => String(b.createdAt || '').localeCompare(String(a.createdAt || '')));
+  return [];
 }
 
 /**
- * Register `(sessionId, workDir)` in the central registry so the next
- * `snapshotSessions()` includes this session.
- *
- * Validates that `<workDir>/.yeaft/sessions/<sessionId>/session.json`
- * exists and is parseable, with legacy `group.json` as a read fallback.
- * Throws:
- *  - `not_found`   — the session dir is not on disk at this workdir
- *  - `corrupt_meta` — the dir exists but session metadata is missing /
- *                    unreadable / can't be parsed. Surfaced as a distinct
- *                    code so the UI can tell the user "the file is broken"
- *                    instead of "you picked the wrong workdir" (review
- *                    finding I1).
- *
- * Idempotent: if the same `(sessionId, workDir)` is already registered,
- * we still rewrite the entry (with the normalized path) and return the
- * fresh meta — no error.
+ * Compatibility shim for the retired workdir-restore flow. Session metadata is
+ * no longer accepted from project `.yeaft/sessions`; users should create or load
+ * Sessions from the user-level `~/.yeaft/sessions` store.
  *
  * @param {string} defaultYeaftDir
  * @param {string} sessionId
  * @param {string} workDir
- * @returns {object} the session meta, with `workDir` set to the normalized path.
+ * @returns {object}
  */
 export function restoreSessionToRegistry(defaultYeaftDir, sessionId, workDir) {
   if (!sessionId) throw new SessionCrudError('invalid_session_id', null);
-  const normalized = normalizeWorkDir(workDir);
-  if (!normalized) throw new SessionCrudError('invalid_workdir', sessionId);
-  const groupYeaftDir = yeaftDirForWorkDir(normalized);
-  const dir = join(sessionsRoot(groupYeaftDir), sessionId);
-  if (!existsSync(dir)) throw new SessionCrudError('not_found', sessionId);
-  const meta = loadSessionMeta(dir);
-  if (!meta) throw new SessionCrudError('corrupt_meta', sessionId, `session metadata missing or unreadable at ${dir} (expected session.json or legacy group.json)`);
-  registerSessionWorkDir(defaultYeaftDir, sessionId, normalized);
-  return { ...meta, workDir: normalized };
+  throw new SessionCrudError('not_found', sessionId, 'workdir Session restore is retired; Sessions are stored under the user-level Yeaft folder');
 }
 
 export function resolveSessionYeaftDir(defaultYeaftDir, sessionId) {
-  if (!defaultYeaftDir || !sessionId) return defaultYeaftDir;
-
-  const registry = readWorkDirRegistry(defaultYeaftDir);
-  const workDir = normalizeWorkDir(registry[sessionId]);
-  if (workDir) {
-    const candidate = yeaftDirForWorkDir(workDir);
-    const candidateDir = join(sessionsRoot(candidate), sessionId);
-    if (existsSync(candidateDir) && loadSessionMeta(candidateDir)) return candidate;
-  }
-
-  const defaultSessionDir = join(sessionsRoot(defaultYeaftDir), sessionId);
-  if (existsSync(defaultSessionDir) && loadSessionMeta(defaultSessionDir)) return defaultYeaftDir;
-
+  // Legacy helper retained for old call sites. Session storage now always
+  // resolves to the agent-local root; project `.yeaft` is only for project
+  // assets such as skills/MCP, never Session data.
   return defaultYeaftDir;
 }
 
@@ -328,8 +322,7 @@ export function ensureDefaultSessionIfEmpty(yeaftDir, options = {}) {
 export function createSessionFromSpec(yeaftDir, spec, options = {}) {
   const input = spec || {};
   const normalizedWorkDir = normalizeWorkDir(input.workDir);
-  const groupYeaftDir = normalizedWorkDir ? yeaftDirForWorkDir(normalizedWorkDir) : yeaftDir;
-  const memoryRoot = options.memoryRoot || (groupYeaftDir ? join(groupYeaftDir, 'memory') : DEFAULT_MEMORY_ROOT);
+  const memoryRoot = options.memoryRoot || (yeaftDir ? join(yeaftDir, 'memory') : DEFAULT_MEMORY_ROOT);
   const libDir = options.libDir || DEFAULT_VP_LIB_DIR;
   const name = String(input.name || '').trim();
   if (!name) throw new SessionCrudError('invalid_name', null, 'group name required');
@@ -355,7 +348,7 @@ export function createSessionFromSpec(yeaftDir, spec, options = {}) {
   if (!defaultVpId) defaultVpId = roster[0] || null;
 
   const id = makeSessionId(name);
-  const root = sessionsRoot(groupYeaftDir);
+  const root = sessionsRoot(yeaftDir);
   if (existsSync(join(root, id))) {
     // Extremely unlikely (ulid suffix), but surface deterministically.
     throw new SessionCrudError('duplicate', id);
@@ -456,8 +449,7 @@ export function updateSessionConfig(yeaftDir, sessionId, partial) {
  * own second-confirm modal (acceptance #4 in task-334-slice-specs.md 334m).
  */
 export function archiveSession(yeaftDir, sessionId) {
-  const groupYeaftDir = resolveSessionYeaftDir(yeaftDir, sessionId);
-  const root = sessionsRoot(groupYeaftDir);
+  const root = sessionsRoot(yeaftDir);
   const srcDir = join(root, sessionId);
   // Idempotent — nothing on disk, nothing to archive. Workdir-registry is
   // still cleared in case it points at a stale row.
@@ -487,9 +479,8 @@ export function archiveSession(yeaftDir, sessionId) {
  * delete cleans up legacy state too.
  */
 export function deleteSession(yeaftDir, sessionId, options = {}) {
-  const groupYeaftDir = resolveSessionYeaftDir(yeaftDir, sessionId);
-  const memoryRoot = options.memoryRoot || (groupYeaftDir ? join(groupYeaftDir, 'memory') : DEFAULT_MEMORY_ROOT);
-  const root = sessionsRoot(groupYeaftDir);
+  const memoryRoot = options.memoryRoot || (yeaftDir ? join(yeaftDir, 'memory') : DEFAULT_MEMORY_ROOT);
+  const root = sessionsRoot(yeaftDir);
   const srcDir = join(root, sessionId);
   const liveExists = existsSync(srcDir) && !!loadSessionMeta(srcDir);
 
@@ -610,8 +601,7 @@ export function setSessionDefaultVp(yeaftDir, sessionId, vpId) {
 }
 
 export function requireSession(yeaftDir, sessionId) {
-  const groupYeaftDir = resolveSessionYeaftDir(yeaftDir, sessionId);
-  const root = sessionsRoot(groupYeaftDir);
+  const root = sessionsRoot(yeaftDir);
   const dir = join(root, sessionId);
   if (!existsSync(dir) || !loadSessionMeta(dir)) {
     throw new SessionCrudError('not_found', sessionId);
@@ -627,10 +617,8 @@ export function snapshotSessions(yeaftDir) {
   }
   const registry = readWorkDirRegistry(yeaftDir);
   for (const [sessionId, workDir] of Object.entries(registry)) {
-    const groupYeaftDir = yeaftDirForWorkDir(workDir);
-    const dir = join(sessionsRoot(groupYeaftDir), sessionId);
-    const meta = existsSync(dir) ? loadSessionMeta(dir) : null;
-    if (meta) byId.set(meta.id, meta);
+    const meta = byId.get(sessionId);
+    if (meta && !meta.workDir) meta.workDir = normalizeWorkDir(workDir);
   }
   // Attach per-group config overrides (v1: just `model`). Frontend can
   // render the effective model without re-querying.

package/yeaft/web-bridge.js

@@ -45,12 +45,11 @@ import {
   removeMember,
   setSessionDefaultVp,
   snapshotSessions,
-  resolveSessionYeaftDir,
   sessionsRoot,
   scanWorkdirSessions,
   restoreSessionToRegistry,
   readWorkDirRegistry,
-  yeaftDirForWorkDir,
+  migrateRegisteredWorkDirSessions,
 } from './sessions/session-crud.js';
 import { openSession, loadSessionMeta } from './sessions/session-store.js';
 import { loadSessionConfig, resolveSessionConfig, SessionConfigError } from './sessions/session-config.js';
@@ -189,8 +188,8 @@ function scheduleYeaftLoadHistoryMetadataReplay(sessionId) {
       let projectRuntime = null;
       if (sessionId) {
         try {
-          const groupYeaftDir = resolveSessionYeaftDir(ctx.CONFIG?.yeaftDir || DEFAULT_YEAFT_DIR, sessionId);
-          const meta = loadSessionMeta(join(sessionsRoot(groupYeaftDir), sessionId));
+          const metaRoot = ctx.CONFIG?.yeaftDir || DEFAULT_YEAFT_DIR;
+          const meta = loadSessionMeta(join(sessionsRoot(metaRoot), sessionId));
           projectRuntime = await ensureProjectRuntimeForSessionMeta(meta);
         } catch { /* best-effort project metadata */ }
       }
@@ -429,13 +428,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)}`;
 }
@@ -1315,10 +1307,8 @@ function getOrCreateVpEngine(sessionId, vpId, threadId = 'main') {
   const key = threadKey(sessionId, vpId, threadId);
   if (!session) throw new Error('getOrCreateVpEngine: session not loaded');
   // Per-session config overlay (v1: model only). Falls back to the
-  // session's user-level config when no override is set. Prefer the agent-local
-  // config root: sessionConfigPath() resolves registered workDir-backed
-  // sessions from there, while still allowing a later agent-local session in
-  // the same bridge runtime to read its own override after a workDir-first boot.
+  // session's user-level config when no override is set. Session config is
+  // always resolved from the agent-local root; project `.yeaft` is ignored.
   const sessionConfigRoot = liveConfigRoot();
   const groupCfg = loadSessionConfig(sessionConfigRoot, sessionId);
   const effectiveConfig = resolveSessionConfig(session.config, groupCfg);
@@ -2465,14 +2455,10 @@ export function handleYeaftCreateSession(msg) {
 }
 
 /**
- * `yeaft_scan_workdir_sessions` — read-only probe: list every yeaft
- * session physically present under `<workDir>/.yeaft/sessions/` along with
- * an `alreadyRegistered` flag (so the restore UI can disable sessions
- * already visible in the sidebar). Never mutates the registry; never
- * throws on missing/empty directories.
- *
- * Pairs with `handleYeaftRestoreSession` for the "Restore session from a
- * workdir" flow — see plan rosy-snuggling-waterfall.md.
+ * `yeaft_scan_workdir_sessions` — compatibility endpoint for the retired
+ * workdir Session scan flow. Session data now lives under the user-level
+ * `~/.yeaft/sessions`; project `.yeaft` is reserved for project assets such as
+ * skills and MCP config.
  */
 export function handleYeaftScanWorkdirSessions(msg) {
   const requestId = msg && msg.requestId;
@@ -2480,11 +2466,8 @@ export function handleYeaftScanWorkdirSessions(msg) {
     const workDir = String(msg && msg.workDir || '').trim();
     if (!workDir) throw new SessionCrudError('invalid_workdir', null, 'workDir required');
     const yeaftDir = ctx.CONFIG?.yeaftDir;
-    // scanWorkdirSessions is a layer-pure utility — it doesn't read the
-    // central workdir registry. The handler is the right layer to fold in
-    // `alreadyRegistered` because that flag couples the per-workdir scan
-    // to a specific agent's registry (the same scan from a CLI tool or
-    // a different agent would compare against a different registry).
+    // scanWorkdirSessions is now a compatibility no-op because Session data is
+    // user-level only. Keep the decoration shape stable for older clients.
     const sessions = scanWorkdirSessions(workDir);
     const registry = readWorkDirRegistry(yeaftDir);
     const decorated = sessions.map(s => ({
@@ -3533,8 +3516,8 @@ async function runYeaftSessionSend(msg) {
     return;
   }
 
-  // Open the session metadata first so a workDir-backed Session can schedule
-  // project runtime loading without blocking the user-message hot path. If
+  // Open the user-level session metadata first so project runtime loading can
+  // use the stored workDir without blocking the user-message hot path. If
   // metadata is missing we still boot the agent runtime for a useful error
   // response, then fail on the session open check.
   let sessionHandle = null;
@@ -3542,8 +3525,7 @@ async function runYeaftSessionSend(msg) {
   let sessionMetaForRuntime = null;
   const openSessionStart = perfNowMs();
   try {
-    const groupYeaftDir = resolveSessionYeaftDir(yeaftDir, sessionId);
-    sessionRoot = sessionsRoot(groupYeaftDir);
+    sessionRoot = sessionsRoot(yeaftDir);
     const dir = join(sessionRoot, sessionId);
     if (existsSync(dir) && loadSessionMeta(dir)) {
       sessionHandle = openSession(sessionRoot, sessionId);
@@ -3564,6 +3546,17 @@ async function runYeaftSessionSend(msg) {
 
   const ensureSessionStart = perfNowMs();
   await ensureSessionLoaded({ sessionMeta: sessionMetaForRuntime, perfTraceId });
+  if (!sessionHandle) {
+    try {
+      const dir = join(sessionRoot, sessionId);
+      if (existsSync(dir) && loadSessionMeta(dir)) {
+        sessionHandle = openSession(sessionRoot, sessionId);
+        sessionMetaForRuntime = sessionHandle.getMeta();
+      }
+    } catch (err) {
+      console.warn('[Yeaft] yeaft_session_chat: migrated session reopen failed', err?.message || err);
+    }
+  }
   scheduleProjectRuntimeLoad(sessionMetaForRuntime?.workDir);
   traceDuration('session_send.ensure_session_loaded', ensureSessionStart);
 
@@ -3927,11 +3920,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 }),
@@ -5694,13 +5682,15 @@ export async function handleYeaftLoadHistory(msg) {
     ensureYeaftConversationId();
 
     let sessionMetaForRuntime = null;
-    let sessionYeaftDir = yeaftDir;
+    const historyYeaftDir = yeaftDir;
     if (sessionId) {
       try {
-        sessionYeaftDir = resolveSessionYeaftDir(yeaftDir, sessionId);
-        const metaDir = join(sessionsRoot(sessionYeaftDir), sessionId);
+        migrateRegisteredWorkDirSessions(yeaftDir);
+        const metaDir = join(sessionsRoot(yeaftDir), sessionId);
         sessionMetaForRuntime = loadSessionMeta(metaDir);
-      } catch { /* best-effort metadata hint */ }
+      } catch (err) {
+        console.warn('[Yeaft] load_history project-store migration failed:', err?.message || err);
+      }
     }
 
     // First paint must not wait for full Yeaft runtime boot (MCP connects,
@@ -5708,7 +5698,7 @@ export async function handleYeaftLoadHistory(msg) {
     // 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(historyYeaftDir);
     traceDuration('history.cold_store_open', coldStoreStart);
     if (sessionId && (afterSeqRaw !== null || afterMessageId)) {
       let afterSeq = afterSeqRaw;