mocode-ai 1.4.2 → 1.4.3

package/dist/runtime/runtime.js

@@ -0,0 +1,307 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { runAgentCore } from '../agent/core.js';
+import { createAgentRuntimeContext, defaultAgentRuntimeContext, } from '../agent/runtime-context.js';
+import { contextState as defaultContextState, createContextState, manualCompact, } from '../session/index.js';
+const activeRuntimes = new AsyncLocalStorage();
+/** Runtime facade active in the current agent async tree, used by nested agents to borrow the parent lifecycle. */
+export function getActiveRuntime() {
+    return activeRuntimes.getStore();
+}
+function firstLineOf(input) {
+    const text = typeof input === 'string' ? input : (input.find((part) => part.type === 'text')?.text ?? '');
+    return Array.from(text.split('\n')[0] ?? '')
+        .slice(0, 40)
+        .join('');
+}
+function toChatTools(context) {
+    return context.toolRuntime.tools.map((tool) => ({
+        type: 'function',
+        function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.parameters,
+        },
+    }));
+}
+/** High-level owner for one AgentRuntimeContext and all host-facing lifecycle operations. */
+export class Runtime {
+    context;
+    contextState;
+    session;
+    rollback;
+    listeners = new Map();
+    activeControllers = new Set();
+    activeWork = new Set();
+    mainRunActive = false;
+    controlOperation = null;
+    onStart;
+    onClose;
+    startPromise = null;
+    closePromise = null;
+    closed = false;
+    constructor(init = {}) {
+        const { context, contextState, onStart, onClose, ...contextInit } = init;
+        this.context = context ?? createAgentRuntimeContext(contextInit);
+        this.contextState = contextState ?? createContextState();
+        this.onStart = onStart;
+        this.onClose = onClose;
+        this.session = {
+            create: () => this.createSession(false),
+            resume: (id) => this.resumeSession(id),
+            save: (history, id, queryHistory, lastToolGroups) => this.saveSession(history, id, queryHistory, lastToolGroups),
+            list: (limit) => {
+                this.assertOpen();
+                return this.context.sessionStore.list(limit);
+            },
+            clear: () => this.createSession(true),
+        };
+        this.rollback = {
+            list: () => {
+                this.assertOpen();
+                return this.context.rollbackStore.listTurns();
+            },
+            plan: (n, history) => {
+                this.assertIdle('plan rollback');
+                const plan = this.context.rollbackStore.planRollback(n, history);
+                this.emit('rollback.planned', { cutoffTurnId: plan.cutoffTurnId, retainedTurns: plan.n });
+                return plan;
+            },
+            apply: (plan, history, revertPaths = new Set()) => {
+                this.assertIdle('apply rollback');
+                const result = this.context.rollbackStore.applyRollback(plan, history, revertPaths);
+                this.emit('rollback.applied', {
+                    cutoffTurnId: plan.cutoffTurnId,
+                    retainedTurns: plan.n,
+                    ...result,
+                });
+                return result;
+            },
+        };
+    }
+    start() {
+        if (this.closed)
+            return Promise.reject(new Error('Runtime is closed.'));
+        if (this.startPromise)
+            return this.startPromise;
+        this.startPromise = Promise.resolve(this.onStart?.(this)).then(() => {
+            this.emit('lifecycle.started', { sandboxRoot: this.context.sandboxRoot });
+        });
+        return this.startPromise;
+    }
+    async run(options) {
+        await this.start();
+        this.assertOpen();
+        if (this.controlOperation) {
+            throw new Error(`Runtime cannot start a run while ${this.controlOperation} is active.`);
+        }
+        const { turn = 'new', turnLabel, signal: callerSignal, traceContext, ...coreOptions } = options;
+        let turnId = traceContext?.turnId;
+        if (turn === 'new') {
+            if (this.mainRunActive) {
+                throw new Error("A main Runtime turn is already active. Use turn: 'inherit' for nested agents.");
+            }
+            this.mainRunActive = true;
+            try {
+                turnId = this.context.beginTurn(turnLabel ?? firstLineOf(options.userInput));
+            }
+            catch (cause) {
+                this.mainRunActive = false;
+                throw cause;
+            }
+        }
+        else if (turn === 'inherit') {
+            turnId = this.context.getCurrentTurnId();
+        }
+        const controller = new AbortController();
+        const relayAbort = () => controller.abort(callerSignal?.reason);
+        if (callerSignal?.aborted)
+            relayAbort();
+        else
+            callerSignal?.addEventListener('abort', relayAbort, { once: true });
+        this.activeControllers.add(controller);
+        const finishWork = this.beginTrackedWork();
+        this.emit('run.started', { turn, turnId });
+        try {
+            const result = await activeRuntimes.run(this, () => runAgentCore({
+                ...coreOptions,
+                contextState: coreOptions.contextState ?? this.contextState,
+                signal: controller.signal,
+                traceContext: turnId === undefined ? traceContext : { ...traceContext, turnId },
+                runtimeContext: this.context,
+            }));
+            this.emit('run.completed', {
+                turn,
+                turnId,
+                terminationReason: result.terminationReason,
+                completed: result.completed,
+            });
+            return result;
+        }
+        catch (cause) {
+            this.emit('run.failed', {
+                turn,
+                turnId,
+                aborted: controller.signal.aborted,
+                message: cause instanceof Error ? cause.message : String(cause),
+            });
+            throw cause;
+        }
+        finally {
+            callerSignal?.removeEventListener('abort', relayAbort);
+            this.activeControllers.delete(controller);
+            if (turn === 'new')
+                this.mainRunActive = false;
+            finishWork();
+        }
+    }
+    cancel(reason) {
+        let count = 0;
+        for (const controller of this.activeControllers) {
+            if (controller.signal.aborted)
+                continue;
+            controller.abort(reason);
+            count += 1;
+        }
+        this.emit('run.cancel_requested', { count });
+        return count;
+    }
+    async compact(history, options = {}) {
+        await this.start();
+        this.assertIdle('compact');
+        this.controlOperation = 'compact';
+        const controller = new AbortController();
+        const relayAbort = () => controller.abort(options.signal?.reason);
+        if (options.signal?.aborted)
+            relayAbort();
+        else
+            options.signal?.addEventListener('abort', relayAbort, { once: true });
+        this.activeControllers.add(controller);
+        const finishWork = this.beginTrackedWork();
+        this.emit('compact.started', { focus: options.focus, force: options.force === true });
+        try {
+            const result = await this.context.runInScope(() => manualCompact(history, options.focus, {
+                force: options.force,
+                signal: controller.signal,
+                contextState: options.contextState ?? this.contextState,
+                activeTools: options.activeTools ?? toChatTools(this.context),
+                runtime: this.context,
+            }));
+            this.emit('compact.completed', {
+                compactHistoryCalled: result.compactHistoryCalled,
+                historyMutation: result.historyMutation,
+                reason: result.compactDetail?.reason,
+            });
+            return result;
+        }
+        catch (cause) {
+            this.emit('compact.failed', { message: cause instanceof Error ? cause.message : String(cause) });
+            throw cause;
+        }
+        finally {
+            options.signal?.removeEventListener('abort', relayAbort);
+            this.activeControllers.delete(controller);
+            this.controlOperation = null;
+            finishWork();
+        }
+    }
+    on(type, listener) {
+        const listeners = this.listeners.get(type) ?? new Set();
+        listeners.add(listener);
+        this.listeners.set(type, listeners);
+        return () => listeners.delete(listener);
+    }
+    close() {
+        if (this.closePromise)
+            return this.closePromise;
+        this.closed = true;
+        this.emit('lifecycle.closing', {});
+        this.closePromise = (async () => {
+            if (this.startPromise)
+                await this.startPromise.catch(() => undefined);
+            this.cancel(new DOMException('Runtime closed.', 'AbortError'));
+            await Promise.allSettled([...this.activeWork]);
+            try {
+                await this.onClose?.(this);
+            }
+            finally {
+                this.emit('lifecycle.closed', {});
+                this.listeners.clear();
+            }
+        })();
+        return this.closePromise;
+    }
+    createSession(cleared) {
+        this.assertIdle(cleared ? 'clear session' : 'create session');
+        const id = this.context.sessionStore.createId();
+        this.context.sessionStore.setCurrentSessionId(id);
+        this.context.rollbackStore.resetState();
+        this.emit(cleared ? 'session.cleared' : 'session.created', { sessionId: id });
+        return id;
+    }
+    resumeSession(id) {
+        this.assertIdle('resume session');
+        const loaded = this.context.sessionStore.load(id);
+        if (!loaded?.history.length)
+            return null;
+        this.context.sessionStore.setCurrentSessionId(loaded.id);
+        this.context.rollbackStore.resetState();
+        const snapshotsLoaded = this.context.rollbackStore.loadSnapshots(loaded.id);
+        if (!snapshotsLoaded)
+            this.context.rollbackStore.rebuildFromHistory(loaded.history);
+        this.emit('session.resumed', { sessionId: loaded.id, snapshotsLoaded });
+        return loaded;
+    }
+    saveSession(history, id = this.context.sessionStore.getCurrentSessionId(), queryHistory = [], lastToolGroups = []) {
+        this.assertIdle('save session');
+        if (!id)
+            throw new Error('Cannot save without an active session.');
+        this.context.sessionStore.setCurrentSessionId(id);
+        const meta = this.context.sessionStore.save(history, id, queryHistory, lastToolGroups);
+        this.context.rollbackStore.persistSnapshots(id);
+        this.emit('session.saved', { sessionId: id });
+        return meta;
+    }
+    assertOpen() {
+        if (this.closed)
+            throw new Error('Runtime is closed.');
+    }
+    assertIdle(operation) {
+        this.assertOpen();
+        if (this.activeControllers.size > 0 || this.controlOperation) {
+            const active = this.controlOperation ?? 'an agent run';
+            throw new Error(`Runtime cannot ${operation} while ${active} is active.`);
+        }
+    }
+    beginTrackedWork() {
+        let resolve;
+        const settled = new Promise((done) => {
+            resolve = done;
+        });
+        this.activeWork.add(settled);
+        return () => {
+            this.activeWork.delete(settled);
+            resolve();
+        };
+    }
+    emit(type, data) {
+        const event = { type, timestamp: new Date().toISOString(), data };
+        for (const key of [type, '*']) {
+            for (const listener of this.listeners.get(key) ?? []) {
+                try {
+                    const result = listener(event);
+                    if (result && typeof result.then === 'function') {
+                        void Promise.resolve(result).catch(() => undefined);
+                    }
+                }
+                catch {
+                    // Runtime events are observational and must never affect hooks or lifecycle behavior.
+                }
+            }
+        }
+    }
+}
+export function createRuntime(init = {}) {
+    return new Runtime(init);
+}
+/** Compatibility facade explicitly bound to all historical process-level singletons. */
+export const defaultRuntime = new Runtime({ context: defaultAgentRuntimeContext, contextState: defaultContextState });

package/dist/session/compact.js

@@ -4,11 +4,17 @@ import { MAX_HISTORY_RESULT, MAX_MEMORY_RESULT, MAX_OLD_TOOL_STUB, MAX_SKILL_RES
 import { ui } from '../ui/theme.js';
 import { Spinner } from '../ui/spinner.js';
 import * as layout from '../ui/layout.js';
-import { pruneAfterCompaction } from '../rollback/index.js';
+import { defaultRollbackStore } from '../rollback/index.js';
 import { toText } from '../context/utils.js';
 import { DEFAULT_BUDGET_POLICY } from '../context/budget.js';
 import { collectArtifactRefs } from '../context/artifacts.js';
 import { writeCompactionSnapshot } from './notes.js';
+/** 默认兼容依赖：旧调用方继续读取进程级 config/chat。 */
+export const defaultCompactionRuntime = {
+    config,
+    modelTransport: chat,
+    rollbackStore: defaultRollbackStore,
+};
 export function createContextState() {
     return { lastEstimate: 0, correction: 1, calibrationSamples: 0 };
 }
@@ -424,7 +430,7 @@ function buildTranscript(stripped, scale) {
     })
         .join('\n');
 }
-async function defaultSummarize(older, focus, signal) {
+async function defaultSummarize(older, focus, signal, runtime = defaultCompactionRuntime) {
     // 已中断就别白拼转录了(几千 token 的字符串拼接 + 一去不回的 LLM 请求)。
     if (signal?.aborted) {
         throw new DOMException('This operation was aborted', 'AbortError');
@@ -435,13 +441,13 @@ async function defaultSummarize(older, focus, signal) {
     // 不需要"先压一遍再摘要"。封顶策略:先按满额封顶;总量仍超窗口 55% 预算时等比缩小
     // 配额重拼(优先保条数/每轮都有代表,其次保单条长度);再超才整段中截兜底(罕见)。
     let transcript = buildTranscript(stripped, 1);
-    const tokenBudget = Math.floor(config.contextWindowTokens * SUMMARY_TRANSCRIPT_WINDOW_RATIO);
+    const tokenBudget = Math.floor(runtime.config.contextWindowTokens * SUMMARY_TRANSCRIPT_WINDOW_RATIO);
     let tokens = estimateTokens(transcript);
     if (tokens > tokenBudget) {
         transcript = buildTranscript(stripped, tokenBudget / tokens);
         tokens = estimateTokens(transcript);
-        if (tokens > Math.floor(config.contextWindowTokens * 0.6)) {
-            transcript = truncateMid(transcript, Math.floor(config.contextWindowTokens * 0.5));
+        if (tokens > Math.floor(runtime.config.contextWindowTokens * 0.6)) {
+            transcript = truncateMid(transcript, Math.floor(runtime.config.contextWindowTokens * 0.5));
         }
     }
     const sysMsg = {
@@ -473,7 +479,7 @@ async function defaultSummarize(older, focus, signal) {
         // signal 必须透传:摘要是几十秒的 LLM 调用,不串进来 Ctrl+C 只能干等它跑完。
         // 空 handlers:不打印、不外显流式;tools=[] 不带工具表——摘要纯文本任务,
         // 全量工具 schema 白占几千 token 窗口,还诱导幻觉工具调用。
-        const r = await chat([sysMsg, userMsg], {}, signal, []);
+        const r = await runtime.modelTransport([sysMsg, userMsg], {}, signal, []);
         // 推理模型可能只返 reasoning_content(content 为 null),或幻觉出 tool_calls → 视为失败
         if (r.toolCalls.length > 0 || !r.content)
             return null;
@@ -622,7 +628,8 @@ export async function compactHistory(history, opts) {
             ...older,
         ];
     }
-    const summarizeFn = opts.summarize ?? defaultSummarize;
+    const summarizeFn = opts.summarize ??
+        ((older, focus, signal) => defaultSummarize(older, focus, signal, opts.runtime ?? defaultCompactionRuntime));
     let summary = null;
     try {
         summary = await summarizeFn(older, opts.focus, opts.signal);
@@ -661,7 +668,7 @@ export async function compactHistory(history, opts) {
         const rebuilt = [systemMsg, summaryMsg, ...flattenGroups(kept)];
         history.length = 0;
         history.push(...rebuilt);
-        pruneAfterCompaction(history); // 摘要删了旧轮次 → 按存活轮次裁剪回滚日志
+        (opts.runtime?.rollbackStore ?? defaultRollbackStore).pruneAfterCompaction(history);
         const estimateAfter = estimatePromptTokens(history, activeTools, state.correction);
         state.lastEstimate = estimateAfter;
         state.lastUsage = undefined; // 压缩后旧 usage 失效,/context 改用校正估算
@@ -735,8 +742,8 @@ export async function compactHistory(history, opts) {
  * 默认 manual=false 自动路径完全不变。
  */
 export async function maybeCompact(history, report, manualOpts, state = contextState, activeTools = chatTools, 
-/** 主 agent 的 abort signal;透传给 compactHistory → 摘要器 → chat()。 */
-signal) {
+/** 主 agent 的 abort signal;透传给 compactHistory → 摘要器 → model transport。 */
+signal, runtime = defaultCompactionRuntime) {
     const est = estimatePromptTokens(history, activeTools, state.correction);
     state.lastEstimate = est;
     const isManual = manualOpts?.manual === true;
@@ -747,7 +754,7 @@ signal) {
         report.rawTotal >= DEFAULT_BUDGET_POLICY.pressureTriggerRatio * report.window;
     // 手动路径:旁路 autoCompact / report / 总阈三重门
     if (!isManual) {
-        if (!hardCap && !config.autoCompact)
+        if (!hardCap && !runtime.config.autoCompact)
             return;
         if (report) {
             // Scheduler mode: the shared pressure report is the sole automatic trigger.
@@ -758,14 +765,14 @@ signal) {
         else {
             // Fallback mode uses the same threshold; there is no second compact gate.
             const raw = estimatePromptTokens(history, activeTools, 1);
-            hardCap = raw >= DEFAULT_BUDGET_POLICY.pressureTriggerRatio * config.contextWindowTokens;
-            const pressureLine = DEFAULT_BUDGET_POLICY.pressureTriggerRatio * config.contextWindowTokens;
+            hardCap = raw >= DEFAULT_BUDGET_POLICY.pressureTriggerRatio * runtime.config.contextWindowTokens;
+            const pressureLine = DEFAULT_BUDGET_POLICY.pressureTriggerRatio * runtime.config.contextWindowTokens;
             if (!hardCap && est < pressureLine)
                 return;
         }
     }
     const r = await compactHistory(history, {
-        window: config.contextWindowTokens,
+        window: runtime.config.contextWindowTokens,
         threshold: DEFAULT_BUDGET_POLICY.pressureTriggerRatio,
         focus: manualOpts?.focus,
         manual: isManual,
@@ -773,6 +780,7 @@ signal) {
         force: manualOpts?.force === true || hardCap,
         tools: activeTools,
         contextState: state,
+        runtime,
         signal,
     });
     return r;

package/dist/session/index.js

@@ -11,6 +11,7 @@ export { compactHistory, maybeCompact, capToolResultForHistory, truncateMid, con
 // repl /compact 命令调 manualCompact(history, focus?):与自动路径共享决策，focus 透传摘要 prompt。
 export { runScheduler, manualCompact, createBudgetScheduler } from './scheduler.js';
 export { newSessionId, saveSession, loadSession, listSessions, sessionDir } from './persist.js';
+export { SessionStore, defaultSessionStore, getActiveSessionStore, withSessionStore } from './store.js';
 export { appendCurrentSessionTrace, appendCurrentSessionTraceEvent, appendCurrentSessionRuntimeEvent, createTraceEvent, } from './trace.js';
 export { reduceTraceMetrics, readTraceEvents, readTraceMetrics } from './trace-metrics.js';
 export { summarizeToolArguments, hashTraceValue, safeProviderId } from './trace-sanitize.js';

package/dist/session/persist.js

@@ -1,157 +1,21 @@
-import { existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from 'node:fs';
-import path from 'node:path';
-import { config, getActiveModel } from '../config/index.js';
-import { isToolRouteGroupName } from '../config/profiles.js';
-import { truncateDisplay } from '../ui/render.js';
+import { defaultSessionStore } from './store.js';
 /** 会话目录(确保存在)。 */
 export function sessionDir() {
-    mkdirSync(config.sessionDir, { recursive: true });
-    return config.sessionDir;
+    return defaultSessionStore.sessionDir();
 }
-/** 新会话 id:YYYYMMDD-HHmmss(运行时 Date 可用)。 */
+/** 新会话 id：可排序时间前缀 + 碰撞防护后缀。 */
 export function newSessionId() {
-    const d = new Date();
-    const p = (n) => String(n).padStart(2, '0');
-    return `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}`;
+    return defaultSessionStore.createId();
 }
-/** id(YYYYMMDD-HHmmss)→ ISO 字符串,稳定可排序。解析失败回退原 id。 */
-function idToIso(id) {
-    const m = /^(\d{4})(\d{2})(\d{2})-(\d{2})(\d{2})(\d{2})$/.exec(id);
-    if (!m)
-        return id;
-    return `${m[1]}-${m[2]}-${m[3]}T${m[4]}:${m[5]}:${m[6]}`;
-}
-function toText(content) {
-    if (content == null)
-        return '';
-    if (typeof content === 'string')
-        return content;
-    try {
-        return JSON.stringify(content);
-    }
-    catch {
-        return String(content);
-    }
-}
-function firstUserOf(history) {
-    for (const m of history) {
-        if (m.role === 'user') {
-            const text = toText(m.content)
-                .replace(/\n/g, ' ')
-                .trim();
-            return truncateDisplay(text, 40);
-        }
-    }
-    return '';
-}
-function sessionPath(id) {
-    return path.join(config.sessionDir, id, 'session.json');
-}
-/** 保存会话到磁盘。全新且没有 query 的会话不创建文件；已有会话即使回滚为空也必须覆盖旧记录。 */
+/** 保存会话；保留旧同步 API 与磁盘格式。 */
 export function saveSession(history, id, queryHistory = [], lastToolGroups = []) {
-    const meta = {
-        id,
-        createdAt: idToIso(id),
-        model: getActiveModel(),
-        firstUser: history.length > 1
-            ? firstUserOf(history)
-            : truncateDisplay((queryHistory[0] ?? '').replace(/\n/g, ' ').trim(), 40),
-    };
-    const currentPath = sessionPath(id);
-    const legacyPath = path.join(config.sessionDir, `${id}.json`);
-    if (history.length <= 1 && queryHistory.length === 0 && !existsSync(currentPath) && !existsSync(legacyPath)) {
-        return meta;
-    }
-    const dir = path.join(config.sessionDir, id);
-    mkdirSync(dir, { recursive: true });
-    const record = {
-        ...meta,
-        history,
-        queryHistory: [...queryHistory],
-        lastToolGroups: [...lastToolGroups],
-    };
-    writeFileSync(currentPath, JSON.stringify(record), 'utf8');
-    // 一旦写入新式目录，删除旧式扁平副本，避免已回滚消息仍残留在磁盘。
-    if (existsSync(legacyPath))
-        unlinkSync(legacyPath);
-    return meta;
+    return defaultSessionStore.save(history, id, queryHistory, lastToolGroups);
 }
-/** 加载会话;不存在 / 损坏返 null(不抛)。优先新式目录,回退旧式文件。 */
+/** 加载会话；不存在或损坏时返回 null。 */
 export function loadSession(id) {
-    // 新式: .mocode/sessions/<id>/session.json
-    const newPath = path.join(config.sessionDir, id, 'session.json');
-    // 旧式: .mocode/sessions/<id>.json
-    const oldPath = path.join(config.sessionDir, `${id}.json`);
-    const p = existsSync(newPath) ? newPath : oldPath;
-    if (!existsSync(p))
-        return null;
-    try {
-        const raw = readFileSync(p, 'utf8');
-        const rec = JSON.parse(raw);
-        if (!rec || !Array.isArray(rec.history))
-            return null;
-        return {
-            id: rec.id,
-            createdAt: rec.createdAt ?? idToIso(rec.id ?? id),
-            model: rec.model ?? '',
-            firstUser: rec.firstUser ?? '',
-            history: rec.history,
-            queryHistory: Array.isArray(rec.queryHistory)
-                ? rec.queryHistory.filter((query) => typeof query === 'string')
-                : undefined,
-            lastToolGroups: Array.isArray(rec.lastToolGroups) ? rec.lastToolGroups.filter(isToolRouteGroupName) : undefined,
-        };
-    }
-    catch {
-        return null;
-    }
+    return defaultSessionStore.load(id);
 }
-/** 列出最近会话,按 createdAt 降序。损坏文件跳过。
- *  - limit?: 仅返回前 N 条。会话目录名是 YYYYMMDD-HHmmss,字典序=时间序;
- *    按目录名降序逐个解析，收集到 N 个有效会话就停止，避免 /resume 在
- *    sessions 目录堆了几百个子目录时全量 JSON.parse；同时不让只有笔记或
- *    快照、没有 session.json 的目录占掉最近 N 条的名额。
- *  - 不传 limit 时读全部(向后兼容,供裸 --resume 列全表用)。
- *  - 向后兼容:同时扫描旧式 <id>.json 文件(扁平结构),优先读新式目录。
- */
+/** 列出最近会话，按 createdAt 降序。 */
 export function listSessions(limit) {
-    if (!existsSync(config.sessionDir))
-        return [];
-    const entries = readdirSync(config.sessionDir, { withFileTypes: true });
-    const ids = [];
-    for (const e of entries) {
-        if (e.isDirectory() && /^\d{8}-\d{6}$/.test(e.name)) {
-            ids.push(e.name);
-        }
-        else if (e.isFile() && e.name.endsWith('.json') && !e.name.endsWith('.snapshots.json')) {
-            // 旧式扁平文件:兼容读取
-            ids.push(e.name.replace(/\.json$/, ''));
-        }
-    }
-    const all = ids.sort().reverse(); // 降序:最新在前
-    const maxResults = typeof limit === 'number' ? Math.max(0, limit) : Infinity;
-    const out = [];
-    for (const id of all) {
-        if (out.length >= maxResults)
-            break;
-        try {
-            // 优先新式目录,回退旧式文件
-            const newPath = path.join(config.sessionDir, id, 'session.json');
-            const oldPath = path.join(config.sessionDir, `${id}.json`);
-            const p = existsSync(newPath) ? newPath : oldPath;
-            const rec = JSON.parse(readFileSync(p, 'utf8'));
-            if (rec && typeof rec.id === 'string') {
-                out.push({
-                    id: rec.id,
-                    createdAt: rec.createdAt ?? idToIso(rec.id),
-                    model: rec.model ?? '',
-                    firstUser: rec.firstUser ?? '',
-                });
-            }
-        }
-        catch {
-            // 跳过损坏文件
-        }
-    }
-    return out;
+    return defaultSessionStore.list(limit);
 }