aicodeswitch 5.2.11 → 5.2.13

package/dist/server/log-store/log-store.js

@@ -0,0 +1,1367 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogStore = void 0;
+/**
+ * LogStore —— 追加写 NDJSON 日志存储
+ *
+ * 设计要点：
+ * - 每条日志一行（NDJSON），按 namespace 分目录，文件按日期 + 大小滚动，**只追加不重写**。
+ * - append 在 per-file 锁内「先 stat 取 size 作 offset，再 append」，保证字节偏移严格对应。
+ * - 会话索引 sessionRefs 存 {file, offset, length, timestamp, logId}；追加写下偏移永远稳定，
+ *   按会话取日志 = 按字节范围随机读，零邻居解析。
+ * - 查询 getRecent/search 流式逐行扫，内存只持轻量描述符 + 当前页；切页后按字节范围回填正文。
+ * - 会话级删除用 tombstone（按 id），追加写无需重写文件。
+ *
+ * 仅依赖 node:fs / node:path / node:crypto，零原生依赖。
+ */
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
+const MAX_FILE_SIZE = 50 * 1024 * 1024; // 50MB 滚动新文件
+const FLUSH_DELAY = 3000;
+const FLUSH_THRESHOLD = 50;
+const READ_CHUNK = 64 * 1024;
+/** 从日志推导 sessionId（与 fs-database.extractSessionIdFromLog 同源逻辑） */
+function extractSessionId(log) {
+    var _a;
+    const headers = log.headers || {};
+    const headerSessionId = headers['session-id'] || headers['session_id'];
+    if (typeof headerSessionId === 'string')
+        return headerSessionId;
+    if (log.body) {
+        try {
+            const body = typeof log.body === 'string' ? JSON.parse(log.body) : log.body;
+            if ((_a = body === null || body === void 0 ? void 0 : body.metadata) === null || _a === void 0 ? void 0 : _a.user_id) {
+                const userId = body.metadata.user_id;
+                try {
+                    const parsed = JSON.parse(userId);
+                    if (parsed && typeof parsed === 'object' && parsed.session_id) {
+                        return parsed.session_id;
+                    }
+                }
+                catch (_b) {
+                    return userId;
+                }
+            }
+        }
+        catch (_c) {
+            // 忽略
+        }
+    }
+    return null;
+}
+function utcDate(ts) {
+    return new Date(ts).toISOString().split('T')[0];
+}
+/** 判断一条记录（描述符或已解析日志）是否命中字段筛选条件（AND 组合） */
+function matchEntry(rec, filters) {
+    if (filters.targetType && rec.targetType !== filters.targetType)
+        return false;
+    if (filters.vendorId && rec.vendorId !== filters.vendorId)
+        return false;
+    if (filters.targetServiceId && rec.targetServiceId !== filters.targetServiceId)
+        return false;
+    if (filters.targetModel && rec.targetModel !== filters.targetModel)
+        return false;
+    if (filters.routeId && rec.routeId !== filters.routeId)
+        return false;
+    return true;
+}
+/** 筛选条件是否非空 */
+function hasFilters(filters) {
+    return !!(filters && (filters.targetType || filters.vendorId || filters.targetServiceId || filters.targetModel || filters.routeId));
+}
+function nsDirName(ns) {
+    // 'global' -> 'global'；'key:{keyId}' -> 直接用 keyId 作目录名（keyId 本身已带 key_ 前缀，避免 key-key_ 重复）
+    return ns === 'global' ? 'global' : ns.slice('key:'.length);
+}
+class LogStore {
+    constructor(rootDir) {
+        Object.defineProperty(this, "rootDir", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "namespaces", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "initialized", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        this.rootDir = rootDir;
+    }
+    /** 启动时加载所有已存在 namespace 的索引 */
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.initialized)
+                return;
+            this.initialized = true;
+            yield fs_1.promises.mkdir(this.rootDir, { recursive: true });
+            let entries = [];
+            try {
+                entries = yield fs_1.promises.readdir(this.rootDir);
+            }
+            catch (_a) {
+                entries = [];
+            }
+            for (const name of entries) {
+                if (name === 'legacy-backup')
+                    continue;
+                const full = path_1.default.join(this.rootDir, name);
+                let stat;
+                try {
+                    stat = yield fs_1.promises.stat(full);
+                }
+                catch (_b) {
+                    continue;
+                }
+                if (!stat.isDirectory())
+                    continue;
+                // 'global' 目录 → global；其余目录名即 keyId，重建 namespace = key:{keyId}
+                if (name === 'global') {
+                    yield this.ensureNs('global');
+                }
+                else {
+                    yield this.ensureNs(`key:${name}`);
+                }
+            }
+        });
+    }
+    ensureNs(ns) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let st = this.namespaces.get(ns);
+            if (st && st.loaded)
+                return st;
+            const dir = path_1.default.join(this.rootDir, nsDirName(ns));
+            yield fs_1.promises.mkdir(dir, { recursive: true });
+            if (!st) {
+                st = {
+                    name: ns,
+                    dir,
+                    shards: [],
+                    sessionRefs: new Map(),
+                    tombstones: new Set(),
+                    timeline: [],
+                    timelineReady: false,
+                    appendLocks: new Map(),
+                    flushTimer: null,
+                    dirtyCount: 0,
+                    loaded: false,
+                };
+                this.namespaces.set(ns, st);
+            }
+            yield this.loadNsState(st);
+            return st;
+        });
+    }
+    loadNsState(st) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const shardsRaw = yield fs_1.promises.readFile(path_1.default.join(st.dir, 'shards-index.json'), 'utf-8');
+                st.shards = JSON.parse(shardsRaw);
+                if (!Array.isArray(st.shards))
+                    st.shards = [];
+            }
+            catch (_a) {
+                st.shards = [];
+            }
+            try {
+                const refsRaw = yield fs_1.promises.readFile(path_1.default.join(st.dir, 'session-index.json'), 'utf-8');
+                const parsed = JSON.parse(refsRaw);
+                st.sessionRefs = new Map(Array.isArray(parsed) ? parsed : Object.entries(parsed));
+            }
+            catch (_b) {
+                st.sessionRefs = new Map();
+            }
+            try {
+                const tombRaw = yield fs_1.promises.readFile(path_1.default.join(st.dir, 'tombstones.json'), 'utf-8');
+                const parsed = JSON.parse(tombRaw);
+                st.tombstones = new Set(Array.isArray(parsed) ? parsed : []);
+            }
+            catch (_c) {
+                st.tombstones = new Set();
+            }
+            // 时间线索引：加载 sidecar 并做 count 一致性校验
+            const expectedCount = st.shards.reduce((sum, s) => sum + s.count, 0);
+            let loaded = null;
+            try {
+                const tlRaw = yield fs_1.promises.readFile(path_1.default.join(st.dir, 'timeline-index.json'), 'utf-8');
+                const parsed = JSON.parse(tlRaw);
+                if (Array.isArray(parsed))
+                    loaded = parsed;
+            }
+            catch (_d) {
+                loaded = null;
+            }
+            if (loaded && loaded.length === expectedCount) {
+                st.timeline = loaded;
+                st.timelineReady = true;
+            }
+            else {
+                // sidecar 缺失/过期：置空，后台重建；期间查询回退扫描
+                st.timeline = [];
+                st.timelineReady = false;
+                if (expectedCount > 0) {
+                    void this.rebuildTimeline(st);
+                }
+                else {
+                    st.timelineReady = true; // 空库视为就绪
+                }
+            }
+            st.loaded = true;
+        });
+    }
+    /**
+     * 后台一次性重建时间线索引：按 startTime 升序遍历分片，逐行取 id/ts/筛选字段。
+     * 仅在 sidecar 缺失/过期时触发；重建完成后 flush 落盘。
+     */
+    rebuildTimeline(st) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, e_1, _b, _c;
+            try {
+                const sorted = [...st.shards].sort((a, b) => a.startTime - b.startTime);
+                const timeline = [];
+                for (const shard of sorted) {
+                    try {
+                        for (var _d = true, _e = (e_1 = void 0, __asyncValues(this.readLines(st, shard.filename))), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                            _c = _f.value;
+                            _d = false;
+                            const ln = _c;
+                            let log;
+                            try {
+                                log = JSON.parse(ln.text);
+                            }
+                            catch (_g) {
+                                continue;
+                            }
+                            timeline.push({
+                                file: shard.filename,
+                                offset: ln.offset,
+                                length: ln.length,
+                                ts: log.timestamp || 0,
+                                id: log.id,
+                                targetType: log.targetType,
+                                vendorId: log.vendorId,
+                                targetServiceId: log.targetServiceId,
+                                targetModel: log.targetModel,
+                                routeId: log.routeId,
+                            });
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                }
+                st.timeline = timeline;
+                st.timelineReady = true;
+                this.scheduleFlush(st);
+            }
+            catch (_h) {
+                // 重建失败：保持 timelineReady=false，查询继续走扫描回退
+            }
+        });
+    }
+    // ============ 写入 ============
+    append(ns, logIn) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const st = yield this.ensureNs(ns);
+            const id = logIn.id || crypto_1.default.randomUUID();
+            const log = Object.assign(Object.assign({}, logIn), { id });
+            const dateStr = utcDate(log.timestamp);
+            const filename = this.pickActiveFile(st, dateStr);
+            const lockKey = filename;
+            const prev = st.appendLocks.get(lockKey) || Promise.resolve();
+            const work = prev.then(() => __awaiter(this, void 0, void 0, function* () {
+                const filePath = path_1.default.join(st.dir, filename);
+                const line = Buffer.from(JSON.stringify(log) + '\n', 'utf8');
+                let offset = 0;
+                try {
+                    const stat = yield fs_1.promises.stat(filePath);
+                    offset = stat.size;
+                }
+                catch (_a) {
+                    offset = 0;
+                }
+                yield fs_1.promises.appendFile(filePath, line);
+                let meta = st.shards.find(s => s.filename === filename);
+                if (!meta) {
+                    meta = {
+                        filename,
+                        date: dateStr,
+                        startTime: log.timestamp,
+                        endTime: log.timestamp,
+                        count: 0,
+                        size: 0,
+                    };
+                    st.shards.push(meta);
+                }
+                meta.count += 1;
+                if (log.timestamp < meta.startTime)
+                    meta.startTime = log.timestamp;
+                if (log.timestamp > meta.endTime)
+                    meta.endTime = log.timestamp;
+                meta.size = offset + line.length;
+                const sid = extractSessionId(log);
+                if (sid) {
+                    const ref = {
+                        file: filename,
+                        offset,
+                        length: line.length - 1,
+                        timestamp: log.timestamp,
+                        logId: id,
+                    };
+                    let arr = st.sessionRefs.get(sid);
+                    if (!arr) {
+                        arr = [];
+                        st.sessionRefs.set(sid, arr);
+                    }
+                    arr.push(ref);
+                }
+                // 时间线索引：append 顺序 push（最旧在前），查询时反向遍历
+                st.timeline.push({
+                    file: filename,
+                    offset,
+                    length: line.length - 1,
+                    ts: log.timestamp,
+                    id,
+                    targetType: log.targetType,
+                    vendorId: log.vendorId,
+                    targetServiceId: log.targetServiceId,
+                    targetModel: log.targetModel,
+                    routeId: log.routeId,
+                });
+                st.timelineReady = true;
+                this.scheduleFlush(st);
+                const res = { id, namespace: ns, file: filename, offset, length: line.length - 1 };
+                return res;
+            }));
+            st.appendLocks.set(lockKey, work);
+            try {
+                return yield work;
+            }
+            finally {
+                if (st.appendLocks.get(lockKey) === work)
+                    st.appendLocks.delete(lockKey);
+            }
+        });
+    }
+    pickActiveFile(st, dateStr) {
+        const sameDay = st.shards.filter(s => s.date === dateStr);
+        for (let i = sameDay.length - 1; i >= 0; i--) {
+            if (sameDay[i].size < MAX_FILE_SIZE)
+                return sameDay[i].filename;
+        }
+        const seq = sameDay.length;
+        return seq === 0 ? `${dateStr}.ndjson` : `${dateStr}.${seq}.ndjson`;
+    }
+    // ============ 查询 ============
+    count(ns) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const st = yield this.ensureNs(ns);
+            return st.shards.reduce((sum, s) => sum + s.count, 0);
+        });
+    }
+    /** 最近日志（newest-first，分页）。优先走时间线索引（零扫描），未就绪时回退扫描。 */
+    getRecent(ns_1) {
+        return __awaiter(this, arguments, void 0, function* (ns, opts = {}) {
+            var _a, _b;
+            const st = yield this.ensureNs(ns);
+            if (!st.timelineReady)
+                return this.getRecentScan(st, opts);
+            const limit = (_a = opts.limit) !== null && _a !== void 0 ? _a : 100;
+            const offset = (_b = opts.offset) !== null && _b !== void 0 ? _b : 0;
+            const since = opts.since;
+            const page = [];
+            let skipped = 0;
+            // timeline 为 append 顺序（最旧在前），反向遍历得到 newest-first
+            for (let i = st.timeline.length - 1; i >= 0 && page.length < limit; i--) {
+                const r = st.timeline[i];
+                if (since != null && r.ts < since)
+                    break; // newest-first：一旦早于 since 即终止
+                if (st.tombstones.has(r.id))
+                    continue;
+                if (skipped < offset) {
+                    skipped++;
+                    continue;
+                }
+                page.push(r);
+            }
+            return this.hydrate(st, page);
+        });
+    }
+    /** getRecent 的扫描回退实现（冷启动索引未就绪时使用） */
+    getRecentScan(st, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, e_2, _b, _c;
+            var _d, _e;
+            const limit = (_d = opts.limit) !== null && _d !== void 0 ? _d : 100;
+            const offset = (_e = opts.offset) !== null && _e !== void 0 ? _e : 0;
+            const since = opts.since;
+            const need = offset + limit;
+            const collected = [];
+            const sorted = [...st.shards].sort((a, b) => b.endTime - a.endTime);
+            for (const shard of sorted) {
+                if (since != null && shard.endTime < since)
+                    break; // 整片早于 since，跳过
+                if (collected.length >= need)
+                    break;
+                try {
+                    for (var _f = true, _g = (e_2 = void 0, __asyncValues(this.readLines(st, shard.filename))), _h; _h = yield _g.next(), _a = _h.done, !_a; _f = true) {
+                        _c = _h.value;
+                        _f = false;
+                        const ln = _c;
+                        let log;
+                        try {
+                            log = JSON.parse(ln.text);
+                        }
+                        catch (_j) {
+                            continue; // 坏行跳过（NDJSON 逐行容错）
+                        }
+                        if (since != null && (log.timestamp || 0) < since)
+                            continue;
+                        if (st.tombstones.has(log.id))
+                            continue;
+                        collected.push({ file: shard.filename, offset: ln.offset, length: ln.length, ts: log.timestamp || 0, id: log.id });
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (!_f && !_a && (_b = _g.return)) yield _b.call(_g);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+            }
+            collected.sort((a, b) => b.ts - a.ts);
+            const page = collected.slice(offset, offset + limit);
+            return this.hydrate(st, page);
+        });
+    }
+    /**
+     * 统一查询：字段筛选 + 关键词 + 时间窗 + 分页 + 全量命中总数。
+     * - 无关键词且索引就绪：走快路径，在描述符上直接筛选（零全量扫描、零 JSON.parse）。
+     * - 有关键词或索引未就绪：回退扫描，match 谓词同时检查字段筛选与正文子串。
+     */
+    query(ns, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const st = yield this.ensureNs(ns);
+            const limit = opts.limit;
+            const offset = opts.offset;
+            const filters = opts.filters;
+            const keyword = (opts.keyword || '').toLowerCase().trim();
+            // 快路径：无关键词且索引就绪
+            if (!keyword && st.timelineReady) {
+                const need = offset + limit;
+                const page = [];
+                let total = 0;
+                for (let i = st.timeline.length - 1; i >= 0; i--) {
+                    const r = st.timeline[i];
+                    if (opts.since != null && r.ts < opts.since)
+                        break;
+                    if (opts.until != null && r.ts > opts.until)
+                        continue;
+                    if (st.tombstones.has(r.id))
+                        continue;
+                    if (hasFilters(filters) && !matchEntry(r, filters))
+                        continue;
+                    total++;
+                    if (page.length < need)
+                        page.push(r);
+                }
+                const slice = page.slice(offset, offset + limit);
+                const data = yield this.hydrate(st, slice);
+                return { data, total };
+            }
+            // 慢路径：扫描（关键词必须查正文，或索引未就绪）
+            return this.queryScan(st, opts, keyword);
+        });
+    }
+    /** query 的扫描回退实现 */
+    queryScan(st, opts, keyword) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, e_3, _b, _c;
+            const limit = opts.limit;
+            const offset = opts.offset;
+            const filters = opts.filters;
+            const need = offset + limit;
+            const page = [];
+            let total = 0;
+            const sorted = [...st.shards].sort((a, b) => b.endTime - a.endTime);
+            for (const shard of sorted) {
+                if (opts.since != null && shard.endTime < opts.since)
+                    break;
+                if (opts.until != null && shard.startTime > opts.until)
+                    continue;
+                try {
+                    for (var _d = true, _e = (e_3 = void 0, __asyncValues(this.readLines(st, shard.filename))), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                        _c = _f.value;
+                        _d = false;
+                        const ln = _c;
+                        // 关键词先在原始文本上做廉价 substring 命中
+                        if (keyword && !ln.text.toLowerCase().includes(keyword))
+                            continue;
+                        let log;
+                        try {
+                            log = JSON.parse(ln.text);
+                        }
+                        catch (_g) {
+                            continue;
+                        }
+                        const ts = log.timestamp || 0;
+                        if (opts.since != null && ts < opts.since)
+                            continue;
+                        if (opts.until != null && ts > opts.until)
+                            continue;
+                        if (st.tombstones.has(log.id))
+                            continue;
+                        if (hasFilters(filters) && !matchEntry(log, filters))
+                            continue;
+                        total++;
+                        if (page.length < need) {
+                            page.push({ file: shard.filename, offset: ln.offset, length: ln.length, ts, id: log.id });
+                        }
+                    }
+                }
+                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                    }
+                    finally { if (e_3) throw e_3.error; }
+                }
+            }
+            page.sort((a, b) => b.ts - a.ts);
+            const slice = page.slice(offset, offset + limit);
+            const data = yield this.hydrate(st, slice);
+            return { data, total };
+        });
+    }
+    getBySession(ns_1, sessionId_1) {
+        return __awaiter(this, arguments, void 0, function* (ns, sessionId, opts = {}) {
+            var _a, _b;
+            const st = yield this.ensureNs(ns);
+            const limit = (_a = opts.limit) !== null && _a !== void 0 ? _a : 100;
+            const offset = (_b = opts.offset) !== null && _b !== void 0 ? _b : 0;
+            const since = opts.since;
+            let refs = st.sessionRefs.get(sessionId) || [];
+            if (since != null)
+                refs = refs.filter(r => r.timestamp >= since);
+            const filtered = [...refs].filter(r => !st.tombstones.has(r.logId));
+            filtered.sort((a, b) => b.timestamp - a.timestamp);
+            const page = filtered.slice(offset, offset + limit);
+            return this.hydrate(st, page);
+        });
+    }
+    /** 批量按会话取近期日志（跨会话合并文件读取），用于 Agent Map 启动重建。 */
+    getBySessionsBatch(ns_1, sessionIds_1) {
+        return __awaiter(this, arguments, void 0, function* (ns, sessionIds, opts = {}) {
+            var _a;
+            const st = yield this.ensureNs(ns);
+            const result = new Map();
+            if (sessionIds.length === 0)
+                return result;
+            const since = opts.since;
+            const perLimit = (_a = opts.perSessionLimit) !== null && _a !== void 0 ? _a : 100;
+            const picked = [];
+            for (const sid of sessionIds) {
+                let refs = st.sessionRefs.get(sid) || [];
+                if (since != null)
+                    refs = refs.filter(r => r.timestamp >= since);
+                refs = refs.filter(r => !st.tombstones.has(r.logId));
+                refs.sort((a, b) => a.timestamp - b.timestamp);
+                const tail = refs.slice(-perLimit);
+                for (const r of tail)
+                    picked.push(Object.assign(Object.assign({}, r), { sessionId: sid }));
+            }
+            if (picked.length === 0)
+                return result;
+            // 2) 按文件分组，每文件打开一次
+            const byFile = new Map();
+            for (const p of picked) {
+                let arr = byFile.get(p.file);
+                if (!arr) {
+                    arr = [];
+                    byFile.set(p.file, arr);
+                }
+                arr.push(p);
+            }
+            const buckets = new Map();
+            for (const [file, group] of byFile) {
+                const fd = yield fs_1.promises.open(path_1.default.join(st.dir, file), 'r');
+                try {
+                    for (const p of group) {
+                        const buf = Buffer.alloc(p.length);
+                        yield fd.read(buf, 0, p.length, p.offset);
+                        let log;
+                        try {
+                            log = JSON.parse(buf.toString('utf8'));
+                        }
+                        catch (_b) {
+                            continue;
+                        }
+                        let bucket = buckets.get(p.sessionId);
+                        if (!bucket) {
+                            bucket = [];
+                            buckets.set(p.sessionId, bucket);
+                        }
+                        bucket.push(log);
+                    }
+                }
+                finally {
+                    yield fd.close();
+                }
+            }
+            for (const [sid, logs] of buckets) {
+                logs.sort((a, b) => (b.timestamp || 0) - (a.timestamp || 0));
+                result.set(sid, logs);
+            }
+            return result;
+        });
+    }
+    /** 两阶段搜索：流式收集匹配描述符 → 切页 → 字节范围回填正文。 */
+    search(ns_1, query_1) {
+        return __awaiter(this, arguments, void 0, function* (ns, query, opts = {}) {
+            var _a, e_4, _b, _c;
+            var _d, _e;
+            const st = yield this.ensureNs(ns);
+            const q = (query || '').toLowerCase().trim();
+            if (!q)
+                return this.getRecent(ns, opts);
+            const limit = (_d = opts.limit) !== null && _d !== void 0 ? _d : 100;
+            const offset = (_e = opts.offset) !== null && _e !== void 0 ? _e : 0;
+            const need = offset + limit;
+            const matches = [];
+            const sorted = [...st.shards].sort((a, b) => b.endTime - a.endTime);
+            for (const shard of sorted) {
+                if (matches.length >= need)
+                    break;
+                try {
+                    for (var _f = true, _g = (e_4 = void 0, __asyncValues(this.readLines(st, shard.filename))), _h; _h = yield _g.next(), _a = _h.done, !_a; _f = true) {
+                        _c = _h.value;
+                        _f = false;
+                        const ln = _c;
+                        // 先在原始文本上做廉价 substring 命中，命中再 parse
+                        if (!ln.text.toLowerCase().includes(q))
+                            continue;
+                        let log;
+                        try {
+                            log = JSON.parse(ln.text);
+                        }
+                        catch (_j) {
+                            continue;
+                        }
+                        if (st.tombstones.has(log.id))
+                            continue;
+                        matches.push({ file: shard.filename, offset: ln.offset, length: ln.length, ts: log.timestamp || 0, id: log.id });
+                    }
+                }
+                catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                finally {
+                    try {
+                        if (!_f && !_a && (_b = _g.return)) yield _b.call(_g);
+                    }
+                    finally { if (e_4) throw e_4.error; }
+                }
+            }
+            matches.sort((a, b) => b.ts - a.ts);
+            const page = matches.slice(offset, offset + limit);
+            return this.hydrate(st, page);
+        });
+    }
+    /** search 的匹配计数（流式，不持正文） */
+    searchCount(ns, query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, e_5, _b, _c;
+            const st = yield this.ensureNs(ns);
+            const q = (query || '').toLowerCase().trim();
+            if (!q)
+                return this.count(ns);
+            let n = 0;
+            const sorted = [...st.shards].sort((a, b) => b.endTime - a.endTime);
+            for (const shard of sorted) {
+                try {
+                    for (var _d = true, _e = (e_5 = void 0, __asyncValues(this.readLines(st, shard.filename))), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                        _c = _f.value;
+                        _d = false;
+                        const ln = _c;
+                        if (!ln.text.toLowerCase().includes(q))
+                            continue;
+                        n++;
+                    }
+                }
+                catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                    }
+                    finally { if (e_5) throw e_5.error; }
+                }
+            }
+            return n;
+        });
+    }
+    /** 按字节范围回填一组 ref 的正文，按文件分组、每文件打开一次 */
+    hydrate(st, refs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (refs.length === 0)
+                return [];
+            const byFile = new Map();
+            for (let i = 0; i < refs.length; i++) {
+                const ref = refs[i];
+                let arr = byFile.get(ref.file);
+                if (!arr) {
+                    arr = [];
+                    byFile.set(ref.file, arr);
+                }
+                arr.push({ idx: i, ref });
+            }
+            const out = new Array(refs.length);
+            for (const [file, group] of byFile) {
+                const fd = yield fs_1.promises.open(path_1.default.join(st.dir, file), 'r');
+                try {
+                    for (const g of group) {
+                        const buf = Buffer.alloc(g.ref.length);
+                        yield fd.read(buf, 0, g.ref.length, g.ref.offset);
+                        try {
+                            out[g.idx] = JSON.parse(buf.toString('utf8'));
+                        }
+                        catch (_a) {
+                            // 坏行跳过
+                        }
+                    }
+                }
+                finally {
+                    yield fd.close();
+                }
+            }
+            return out.filter(Boolean);
+        });
+    }
+    // ============ 流式逐行读（带字节偏移） ============
+    readLines(st, filename) {
+        return __asyncGenerator(this, arguments, function* readLines_1() {
+            const filePath = path_1.default.join(st.dir, filename);
+            let fd;
+            try {
+                fd = yield __await(fs_1.promises.open(filePath, 'r'));
+            }
+            catch (_a) {
+                return yield __await(void 0);
+            }
+            try {
+                let carry = Buffer.alloc(0);
+                let carryOffset = 0;
+                let filePos = 0;
+                while (true) {
+                    const buf = Buffer.alloc(READ_CHUNK);
+                    const { bytesRead } = yield __await(fd.read(buf, 0, READ_CHUNK, filePos));
+                    if (bytesRead === 0) {
+                        if (carry.length > 0) {
+                            yield yield __await({ text: carry.toString('utf8'), offset: carryOffset, length: carry.length });
+                            carry = Buffer.alloc(0);
+                        }
+                        break;
+                    }
+                    const data = buf.subarray(0, bytesRead);
+                    const block = carry.length > 0 ? Buffer.concat([carry, data]) : data;
+                    const blockStart = carryOffset;
+                    let searchFrom = 0;
+                    let nl = block.indexOf(0x0a, searchFrom);
+                    while (nl !== -1) {
+                        const lineBuf = block.subarray(searchFrom, nl);
+                        yield yield __await({
+                            text: lineBuf.toString('utf8'),
+                            offset: blockStart + searchFrom,
+                            length: lineBuf.length,
+                        });
+                        searchFrom = nl + 1;
+                        nl = block.indexOf(0x0a, searchFrom);
+                    }
+                    carry = block.subarray(searchFrom);
+                    carryOffset = blockStart + searchFrom;
+                    filePos += bytesRead;
+                }
+            }
+            finally {
+                yield __await(fd.close());
+            }
+        });
+    }
+    // ============ 删除 / 清理 ============
+    /** 按会话删除日志（tombstone + 清理 sessionRefs） */
+    deleteLogsBySession(ns, sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const st = yield this.ensureNs(ns);
+            const refs = st.sessionRefs.get(sessionId) || [];
+            let n = 0;
+            for (const r of refs) {
+                if (!st.tombstones.has(r.logId)) {
+                    st.tombstones.add(r.logId);
+                    n++;
+                }
+            }
+            st.sessionRefs.delete(sessionId);
+            if (n > 0)
+                this.scheduleFlush(st);
+            return n;
+        });
+    }
+    /** 按 id 批量删除（tombstone） */
+    deleteLogsByIds(ns, ids) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const st = yield this.ensureNs(ns);
+            let n = 0;
+            for (const id of ids) {
+                if (id && !st.tombstones.has(id)) {
+                    st.tombstones.add(id);
+                    n++;
+                }
+            }
+            if (n > 0)
+                this.scheduleFlush(st);
+            return n;
+        });
+    }
+    /** 清空某 namespace 全部日志 */
+    clear(ns) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const st = yield this.ensureNs(ns);
+            for (const s of st.shards) {
+                try {
+                    yield fs_1.promises.unlink(path_1.default.join(st.dir, s.filename));
+                }
+                catch (_a) {
+                    // 忽略
+                }
+            }
+            st.shards = [];
+            st.sessionRefs.clear();
+            st.tombstones.clear();
+            st.timeline = [];
+            st.timelineReady = true;
+            yield this.flushNow(st);
+        });
+    }
+    /** 保留最近 N 天，删除更早的分片文件（整文件删，ref 自带 file，零逐条修正） */
+    retain(ns, days) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const st = yield this.ensureNs(ns);
+            const cutoff = Date.now() - days * 24 * 60 * 60 * 1000;
+            const toDelete = st.shards.filter(s => s.endTime < cutoff);
+            if (toDelete.length === 0)
+                return 0;
+            const deleted = new Set(toDelete.map(s => s.filename));
+            for (const s of toDelete) {
+                try {
+                    yield fs_1.promises.unlink(path_1.default.join(st.dir, s.filename));
+                }
+                catch (_a) {
+                    // 忽略
+                }
+            }
+            st.shards = st.shards.filter(s => !deleted.has(s.filename));
+            // 清理指向已删文件的 sessionRefs
+            for (const [sid, refs] of st.sessionRefs) {
+                const remaining = refs.filter(r => !deleted.has(r.file));
+                if (remaining.length === 0)
+                    st.sessionRefs.delete(sid);
+                else if (remaining.length < refs.length)
+                    st.sessionRefs.set(sid, remaining);
+            }
+            // 清理时间线索引中指向已删文件的描述符
+            if (st.timeline.length > 0) {
+                st.timeline = st.timeline.filter(r => !deleted.has(r.file));
+            }
+            yield this.flushNow(st);
+            return toDelete.length;
+        });
+    }
+    /**
+     * 流式遍历某 namespace 的全部日志（逐行 parse，跳过坏行与 tombstone）。
+     * 供统计 contentType 分布重建、迁移校验等「需要扫全量」的场景；查询走 getRecent/search。
+     */
+    streamAll(ns_1) {
+        return __asyncGenerator(this, arguments, function* streamAll_1(ns, opts = {}) {
+            var _a, e_6, _b, _c;
+            const st = yield __await(this.ensureNs(ns));
+            const sorted = [...st.shards].sort((a, b) => a.startTime - b.startTime);
+            for (const shard of sorted) {
+                try {
+                    for (var _d = true, _e = (e_6 = void 0, __asyncValues(this.readLines(st, shard.filename))), _f; _f = yield __await(_e.next()), _a = _f.done, !_a; _d = true) {
+                        _c = _f.value;
+                        _d = false;
+                        const ln = _c;
+                        let log;
+                        try {
+                            log = JSON.parse(ln.text);
+                        }
+                        catch (_g) {
+                            continue;
+                        }
+                        if (opts.skipTombstone && log.id && st.tombstones.has(log.id))
+                            continue;
+                        yield yield __await(log);
+                    }
+                }
+                catch (e_6_1) { e_6 = { error: e_6_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
+                    }
+                    finally { if (e_6) throw e_6.error; }
+                }
+            }
+        });
+    }
+    /**
+     * 带过滤的分页查询：流式扫描全量，对每条日志应用 match 谓词（+ 可选 since/until 时间窗），
+     * 收集轻量描述符直到够一页，同时继续计数得到 total；最后按字节范围回填当前页。
+     * 返回 { data, total }。内存仅持描述符 + 当前页。
+     */
+    getFiltered(ns, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, e_7, _b, _c;
+            const st = yield this.ensureNs(ns);
+            const limit = opts.limit;
+            const offset = opts.offset;
+            const need = offset + limit;
+            const page = [];
+            let total = 0;
+            const sorted = [...st.shards].sort((a, b) => b.endTime - a.endTime);
+            outer: for (const shard of sorted) {
+                if (opts.since != null && shard.endTime < opts.since)
+                    break;
+                if (opts.until != null && shard.startTime > opts.until)
+                    continue;
+                try {
+                    for (var _d = true, _e = (e_7 = void 0, __asyncValues(this.readLines(st, shard.filename))), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                        _c = _f.value;
+                        _d = false;
+                        const ln = _c;
+                        let log;
+                        try {
+                            log = JSON.parse(ln.text);
+                        }
+                        catch (_g) {
+                            continue;
+                        }
+                        const ts = log.timestamp || 0;
+                        if (opts.since != null && ts < opts.since)
+                            continue;
+                        if (opts.until != null && ts > opts.until)
+                            continue;
+                        if (st.tombstones.has(log.id))
+                            continue;
+                        if (opts.match && !opts.match(log))
+                            continue;
+                        total++;
+                        if (page.length < need) {
+                            page.push({ file: shard.filename, offset: ln.offset, length: ln.length, ts, id: log.id });
+                        }
+                        if (page.length >= need && opts.since == null && opts.until == null && !opts.match) {
+                            // 无过滤时可提前结束（total == page.length 满足分页即可）
+                            break outer;
+                        }
+                    }
+                }
+                catch (e_7_1) { e_7 = { error: e_7_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                    }
+                    finally { if (e_7) throw e_7.error; }
+                }
+            }
+            page.sort((a, b) => b.ts - a.ts);
+            const slice = page.slice(offset, offset + limit);
+            const data = yield this.hydrate(st, slice);
+            return { data, total };
+        });
+    }
+    /** 列出所有已加载的 namespace（供定时清理遍历 AccessKey） */
+    listNamespaces() {
+        return Array.from(this.namespaces.keys());
+    }
+    // ============ 索引持久化（防抖） ============
+    scheduleFlush(st) {
+        st.dirtyCount += 1;
+        if (st.dirtyCount >= FLUSH_THRESHOLD) {
+            if (st.flushTimer) {
+                clearTimeout(st.flushTimer);
+                st.flushTimer = null;
+            }
+            this.flushNow(st).catch(() => { });
+            return;
+        }
+        if (!st.flushTimer) {
+            st.flushTimer = setTimeout(() => {
+                st.flushTimer = null;
+                this.flushNow(st).catch(() => { });
+            }, FLUSH_DELAY);
+            if (typeof st.flushTimer.unref === 'function')
+                st.flushTimer.unref();
+        }
+    }
+    flushNow(st) {
+        return __awaiter(this, void 0, void 0, function* () {
+            st.dirtyCount = 0;
+            if (st.flushTimer) {
+                clearTimeout(st.flushTimer);
+                st.flushTimer = null;
+            }
+            const tmp1 = path_1.default.join(st.dir, '.tmp-shards-index.json');
+            const tmp2 = path_1.default.join(st.dir, '.tmp-session-index.json');
+            const tmp3 = path_1.default.join(st.dir, '.tmp-tombstones.json');
+            const tmp4 = path_1.default.join(st.dir, '.tmp-timeline-index.json');
+            yield fs_1.promises.writeFile(tmp1, JSON.stringify(st.shards));
+            yield fs_1.promises.rename(tmp1, path_1.default.join(st.dir, 'shards-index.json'));
+            yield fs_1.promises.writeFile(tmp2, JSON.stringify(Array.from(st.sessionRefs.entries())));
+            yield fs_1.promises.rename(tmp2, path_1.default.join(st.dir, 'session-index.json'));
+            yield fs_1.promises.writeFile(tmp3, JSON.stringify(Array.from(st.tombstones)));
+            yield fs_1.promises.rename(tmp3, path_1.default.join(st.dir, 'tombstones.json'));
+            yield fs_1.promises.writeFile(tmp4, JSON.stringify(st.timeline));
+            yield fs_1.promises.rename(tmp4, path_1.default.join(st.dir, 'timeline-index.json'));
+        });
+    }
+    /**
+     * store 是否真的有数据文件（看实际 *.ndjson，不信 shards-index.json 元数据，
+     * 防「索引还在、数据文件被删」的误判）。
+     */
+    storeHasData() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let ents = [];
+            try {
+                ents = yield fs_1.promises.readdir(this.rootDir);
+            }
+            catch (_a) {
+                return false;
+            }
+            for (const name of ents) {
+                if (name === 'legacy-backup')
+                    continue;
+                if (name.startsWith('.'))
+                    continue;
+                const full = path_1.default.join(this.rootDir, name);
+                try {
+                    const stat = yield fs_1.promises.stat(full);
+                    if (!stat.isDirectory())
+                        continue;
+                }
+                catch (_b) {
+                    continue;
+                }
+                try {
+                    const files = yield fs_1.promises.readdir(full);
+                    if (files.some(f => f.endsWith('.ndjson')))
+                        return true;
+                }
+                catch (_c) {
+                    // 忽略
+                }
+            }
+            return false;
+        });
+    }
+    /**
+     * 流式收集某 namespace 已存在的全部 logId，供迁移去重。
+     * 仅在迁移启动时为「有数据的 namespace」调用一次；store 空则返回空 Set。
+     */
+    collectIds(ns) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, e_8, _b, _c;
+            const ids = new Set();
+            try {
+                try {
+                    for (var _d = true, _e = __asyncValues(this.streamAll(ns)), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                        _c = _f.value;
+                        _d = false;
+                        const log = _c;
+                        if (log.id)
+                            ids.add(log.id);
+                    }
+                }
+                catch (e_8_1) { e_8 = { error: e_8_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                    }
+                    finally { if (e_8) throw e_8.error; }
+                }
+            }
+            catch (_g) {
+                // 忽略
+            }
+            return ids;
+        });
+    }
+    /**
+     * 稳健迁移旧 JSON 日志到 NDJSON（main.ts 在 listen 之前调用）。
+     * - 主库：{dataPath}/logs.json（旧单文件）+ {dataPath}/logs/logs-*.json（旧分片）→ 'global'
+     * - AccessKey：{dataPath}/key-logs/<keyId>/*.json（跳过 logs-index.json）→ 'key:{keyId}'
+     *
+     * 设计（幂等 + 非破坏性 + 内容感知）：
+     * - gate：仅当 `标记缺失 OR store 实际无数据文件` 才进入迁移。正常重启（标记在 + 数据在）直接跳过，不扫源。
+     * - 去重：进入迁移时，先为每个有数据的 namespace 用 collectIds 建已存在 idSet，
+     *   迁移时 idSet.has(id) 则跳过。于是「部分残留/中断续跑/标记过期重跑」都不产生重复。
+     * - 非破坏性：不 wipe 任何目录；源头 logs/、key-logs/ 始终只读、永不移动/删除（见 UPGRADE.md）。
+     * - 标记 `.log-store-migration` 仅作「已完成」提示，不单独决定跳过——必须同时 storeHasData()。
+     */
+    migrateLegacy(dataPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield fs_1.promises.mkdir(this.rootDir, { recursive: true });
+            // 兼容：清理旧版本标记名
+            try {
+                yield fs_1.promises.unlink(path_1.default.join(this.rootDir, '.legacy-migrated'));
+            }
+            catch (_a) {
+                // 无旧标记，忽略
+            }
+            const marker = path_1.default.join(this.rootDir, '.log-store-migration');
+            let hasMarker = false;
+            try {
+                yield fs_1.promises.access(marker);
+                hasMarker = true;
+            }
+            catch (_b) {
+                hasMarker = false;
+            }
+            const hasData = yield this.storeHasData();
+            // 快速路径：标记在 + store 真有数据 → 已完成，跳过（不扫源）
+            if (hasMarker && hasData) {
+                return { global: 0, keys: {} };
+            }
+            console.log(`[LogStore] migrate: start (marker=${hasMarker}, hasData=${hasData})`);
+            // store 无实际数据文件时，可能残留指向已删文件的 stale 索引（shards-index.json 等）。
+            // 清掉这些索引 + 内存态，避免「索引说有、文件没有」的幽灵；.ndjson 本就不存在，无数据丢失风险。
+            if (!hasData) {
+                for (const ns of this.listNamespaces()) {
+                    const dir = path_1.default.join(this.rootDir, nsDirName(ns));
+                    for (const idxFile of ['shards-index.json', 'session-index.json', 'tombstones.json', 'timeline-index.json']) {
+                        try {
+                            yield fs_1.promises.unlink(path_1.default.join(dir, idxFile));
+                        }
+                        catch (_c) {
+                            // 忽略
+                        }
+                    }
+                }
+                this.namespaces.clear();
+            }
+            // 为每个有数据的 namespace 建去重 idSet（防部分残留导致重复追加）
+            const idSets = new Map();
+            for (const ns of this.listNamespaces()) {
+                try {
+                    const dir = path_1.default.join(this.rootDir, nsDirName(ns));
+                    const files = yield fs_1.promises.readdir(dir);
+                    if (files.some(f => f.endsWith('.ndjson'))) {
+                        idSets.set(ns, yield this.collectIds(ns));
+                    }
+                }
+                catch (_d) {
+                    // 忽略
+                }
+            }
+            const ensureIdSet = (ns) => {
+                let s = idSets.get(ns);
+                if (!s) {
+                    s = new Set();
+                    idSets.set(ns, s);
+                }
+                return s;
+            };
+            const result = { global: 0, keys: {} };
+            let sourceFiles = 0;
+            const migrateFile = (ns, file) => __awaiter(this, void 0, void 0, function* () {
+                // ★ 不变量：源头文件（logs/、key-logs/、logs.json）只读——本函数只 readFile，
+                //   绝不 unlink / rm / rename 任何源文件，也不把源文件移动到别处。
+                //   所有写入只落到 log-store/{namespace}/ 内。违反此约束会破坏用户数据可恢复性。
+                if (file.startsWith(this.rootDir)) {
+                    console.error(`[LogStore] migrate: refuse to touch file inside log-store (${file}); source must be logs/ or key-logs/`);
+                    return 0;
+                }
+                let content;
+                try {
+                    content = yield fs_1.promises.readFile(file, 'utf-8');
+                }
+                catch (_a) {
+                    return 0;
+                }
+                sourceFiles++;
+                // 旧分片可能含 \x00 损坏：截断到首个 NUL
+                const nul = content.indexOf('\x00');
+                if (nul !== -1)
+                    content = content.substring(0, nul);
+                let arr;
+                try {
+                    arr = JSON.parse(content);
+                    if (!Array.isArray(arr))
+                        arr = [];
+                }
+                catch (_b) {
+                    console.warn(`[LogStore] migrate: skip unparseable file ${file}`);
+                    return 0;
+                }
+                const idSet = ensureIdSet(ns);
+                let written = 0;
+                let skippedDup = 0;
+                for (const log of arr) {
+                    if (!log || typeof log !== 'object')
+                        continue;
+                    if (!log.id)
+                        log.id = crypto_1.default.randomUUID();
+                    if (typeof log.timestamp !== 'number')
+                        log.timestamp = Date.now();
+                    if (idSet.has(log.id)) {
+                        skippedDup++;
+                        continue; // 去重：已存在则跳过
+                    }
+                    try {
+                        yield this.append(ns, log);
+                        idSet.add(log.id);
+                        written++;
+                    }
+                    catch (err) {
+                        console.error(`[LogStore] migrate: append failed in ${file}`, err);
+                    }
+                }
+                if (skippedDup > 0) {
+                    console.log(`[LogStore] migrate: ${file} dedup-skipped=${skippedDup} written=${written}`);
+                }
+                return written;
+            });
+            // 主库：logs.json + logs/logs-*.json
+            const oldSingle = path_1.default.join(dataPath, 'logs.json');
+            try {
+                yield fs_1.promises.access(oldSingle);
+                result.global += yield migrateFile('global', oldSingle);
+            }
+            catch (_e) {
+                // 无单文件
+            }
+            const oldLogsDir = path_1.default.join(dataPath, 'logs');
+            try {
+                const files = yield fs_1.promises.readdir(oldLogsDir);
+                for (const f of files) {
+                    if (!f.endsWith('.json'))
+                        continue;
+                    if (!/^logs-.*\.json$/.test(f))
+                        continue;
+                    result.global += yield migrateFile('global', path_1.default.join(oldLogsDir, f));
+                }
+            }
+            catch (_f) {
+                // 无 logs 目录
+            }
+            // AccessKey：key-logs/<keyId>/*.json
+            const keyRoot = path_1.default.join(dataPath, 'key-logs');
+            try {
+                const keyDirs = yield fs_1.promises.readdir(keyRoot);
+                for (const kd of keyDirs) {
+                    const kdFull = path_1.default.join(keyRoot, kd);
+                    let st;
+                    try {
+                        st = yield fs_1.promises.stat(kdFull);
+                    }
+                    catch (_g) {
+                        continue;
+                    }
+                    if (!st.isDirectory())
+                        continue;
+                    const ns = `key:${kd}`;
+                    let files;
+                    try {
+                        files = yield fs_1.promises.readdir(kdFull);
+                    }
+                    catch (_h) {
+                        continue;
+                    }
+                    let n = 0;
+                    for (const f of files) {
+                        if (!f.endsWith('.json'))
+                            continue;
+                        if (f === 'logs-index.json')
+                            continue; // 跳过旧索引
+                        n += yield migrateFile(ns, path_1.default.join(kdFull, f));
+                    }
+                    if (n > 0)
+                        result.keys[kd] = (result.keys[kd] || 0) + n;
+                }
+            }
+            catch (_j) {
+                // 无 key-logs
+            }
+            // 落盘所有 namespace
+            for (const nss of this.namespaces.values()) {
+                try {
+                    yield this.flushNow(nss);
+                }
+                catch (_k) {
+                    // 忽略
+                }
+            }
+            // 写标记（记录版本/时间/源文件数，便于排查；仍需 storeHasData 才会在下次跳过）
+            yield fs_1.promises.writeFile(marker, JSON.stringify({ version: 1, finishedAt: Date.now(), sources: sourceFiles }));
+            if (result.global > 0 || Object.keys(result.keys).length > 0 || !hasData) {
+                console.log(`[LogStore] migration done: global=${result.global} keys=${JSON.stringify(result.keys)} sources=${sourceFiles}`);
+            }
+            return result;
+        });
+    }
+    /** 关闭时强制落盘所有 namespace */
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const st of this.namespaces.values()) {
+                try {
+                    yield this.flushNow(st);
+                }
+                catch (_a) {
+                    // 忽略
+                }
+            }
+        });
+    }
+}
+exports.LogStore = LogStore;