mu-agent-bridge 1.0.35 → 1.0.39

package/dist/tests-ts/session-archive.test.js

@@ -0,0 +1,422 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const strict_1 = __importDefault(require("node:assert/strict"));
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const node_test_1 = __importDefault(require("node:test"));
+const session_archive_1 = require("../src-ts/session-archive");
+const now = Date.parse("2026-10-21T12:00:00.000Z");
+function turn(overrides = {}) {
+    return { sessionId: "会话一", agentPlugin: "workbuddy", channel: "aun", principal: "用户一", source: "aun:本端:聊天:对端:话题", time: new Date(now).toISOString(), role: "user", text: "用户正文", completed: true, messageId: "消息一", ...overrides };
+}
+async function temporary(run) {
+    const root = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "mab-session-archive-"));
+    try {
+        await run(root);
+    }
+    finally {
+        await (0, promises_1.rm)(root, { recursive: true, force: true });
+    }
+}
+(0, node_test_1.default)("归档默认关闭且不会创建包含正文的文件", () => temporary(async (root) => {
+    const archive = new session_archive_1.SessionArchive(root);
+    await archive.recordTurn(turn());
+    strict_1.default.deepEqual(await (0, promises_1.readdir)(root), []);
+    strict_1.default.equal((await archive.listSessions()).total, 0);
+}));
+(0, node_test_1.default)("只保存完成轮次，附件去除字节且消息与请求重试去重", () => temporary(async (root) => {
+    const archive = new session_archive_1.SessionArchive(root, { enabled: true, now: () => now });
+    await archive.recordTurn(turn({ completed: false }));
+    const data = Buffer.from("不应保存附件字节");
+    const attachment = { filename: "报告.pdf", contentType: "application/pdf", sizeBytes: data.length, data };
+    await Promise.all([
+        archive.recordTurn(turn({ attachments: [attachment], requestId: "请求一" })),
+        archive.recordTurn(turn({ messageId: "重发消息", requestId: "请求一" })),
+        archive.recordTurn(turn({ role: "assistant", messageId: "回复一", requestId: "请求一", text: "完成回复" })),
+    ]);
+    const loaded = new session_archive_1.SessionArchive(root, { enabled: true, now: () => now });
+    const page = await loaded.readSession("会话一");
+    strict_1.default.equal(page.turns.length, 2);
+    strict_1.default.deepEqual(page.turns[0].attachments, [{ filename: "报告.pdf", contentType: "application/pdf", sizeBytes: data.length }]);
+    strict_1.default.equal(page.session?.source, turn().source);
+    strict_1.default.equal(page.session?.principal, "用户一");
+    strict_1.default.equal(page.complete, true);
+    for (const filename of await (0, promises_1.readdir)(root)) {
+        strict_1.default.equal((await (0, promises_1.stat)((0, node_path_1.join)(root, filename))).mode & 0o777, 0o600);
+        strict_1.default.equal((await (0, promises_1.readFile)((0, node_path_1.join)(root, filename), "utf8")).includes("不应保存附件字节"), false);
+    }
+}));
+(0, node_test_1.default)("会话身份不可跨来源复用，非法角色不能落盘", () => temporary(async (root) => {
+    const archive = new session_archive_1.SessionArchive(root, { enabled: true, now: () => now });
+    await archive.recordTurn(turn());
+    await strict_1.default.rejects(archive.recordTurn(turn({ source: "其他来源" })), /来源/);
+    await strict_1.default.rejects(archive.recordTurn(turn({ role: "system" })), /角色/);
+    strict_1.default.equal((await archive.readSession("会话一")).turns.length, 1);
+}));
+(0, node_test_1.default)("固定默认上限且 UTF-8 超限正文明确标记截断", () => temporary(async (root) => {
+    strict_1.default.equal(session_archive_1.SESSION_ARCHIVE_LIMITS.maxTextBytes, 64 * 1024);
+    strict_1.default.equal(session_archive_1.SESSION_ARCHIVE_LIMITS.maxSessionBytes, 8 * 1024 * 1024);
+    strict_1.default.equal(session_archive_1.SESSION_ARCHIVE_LIMITS.maxTotalBytes, 256 * 1024 * 1024);
+    strict_1.default.equal(session_archive_1.SESSION_ARCHIVE_LIMITS.retentionDays, 30);
+    const archive = new session_archive_1.SessionArchive(root, { enabled: true, now: () => now });
+    await archive.recordTurn(turn({ text: "中".repeat(30_000) }));
+    const page = await archive.readSession("会话一");
+    strict_1.default.ok(Buffer.byteLength(page.turns[0].text) <= 64 * 1024);
+    strict_1.default.equal(page.turns[0].text.includes("�"), false);
+    strict_1.default.equal(page.complete, false);
+    strict_1.default.ok(page.missingReasons.some((reason) => reason.includes("文本")));
+}));
+(0, node_test_1.default)("会话字节与轮数上限拒绝继续保存并暴露缺口", () => temporary(async (root) => {
+    const archive = new session_archive_1.SessionArchive(root, { enabled: true, now: () => now, limits: { maxSessionBytes: 1024, maxTurnsPerSession: 2 } });
+    for (let i = 0; i < 4; i++)
+        await archive.recordTurn(turn({ messageId: `${i}`, text: "长".repeat(100) }));
+    const page = await archive.readSession("会话一");
+    strict_1.default.ok(page.turns.length > 0 && page.turns.length <= 2);
+    strict_1.default.equal(page.complete, false);
+    const files = (await (0, promises_1.readdir)(root)).filter((name) => name.endsWith(".jsonl"));
+    strict_1.default.ok((await (0, promises_1.stat)((0, node_path_1.join)(root, files[0]))).size <= 1024);
+}));
+(0, node_test_1.default)("总字节与会话数上限会清理旧会话并标记目录不完整", () => temporary(async (root) => {
+    const archive = new session_archive_1.SessionArchive(root, { enabled: true, now: () => now, limits: { maxTotalBytes: 1500, maxSessions: 2 } });
+    for (let i = 0; i < 5; i++)
+        await archive.recordTurn(turn({ sessionId: `${i}`, messageId: `${i}`, time: new Date(now + i).toISOString(), text: "长".repeat(100) }));
+    const page = await archive.listSessions();
+    strict_1.default.ok(page.total > 0 && page.total <= 2);
+    strict_1.default.equal(page.complete, false);
+    let bytes = 0;
+    for (const filename of await (0, promises_1.readdir)(root))
+        bytes += (await (0, promises_1.stat)((0, node_path_1.join)(root, filename))).size;
+    strict_1.default.ok(bytes <= 1500);
+}));
+(0, node_test_1.default)("分页上限为五十个会话和一百条消息且来源过滤发生在分页前", () => temporary(async (root) => {
+    const archive = new session_archive_1.SessionArchive(root, { enabled: true, now: () => now });
+    for (let i = 0; i < 55; i++)
+        await archive.recordTurn(turn({ sessionId: `会话${i}`, messageId: `${i}` }));
+    for (let i = 0; i < 101; i++)
+        await archive.recordTurn(turn({ sessionId: "分页会话", messageId: `${i}`, source: "独立来源" }));
+    const list = await archive.listSessions({ limit: 100 });
+    strict_1.default.equal(list.sessions.length, 50);
+    strict_1.default.equal(list.hasNext, true);
+    strict_1.default.equal((await archive.listSessions({ sources: ["独立来源"] })).total, 1);
+    const first = await archive.readSession("分页会话", { limit: 500 });
+    strict_1.default.equal(first.turns.length, 100);
+    strict_1.default.equal(first.hasNext, true);
+    strict_1.default.equal((await archive.readSession("分页会话", { page: 2 })).turns.length, 1);
+}));
+(0, node_test_1.default)("保留期逐条清理进行中的旧历史并保留不完整标记", () => temporary(async (root) => {
+    let clock = now - 31 * 86400_000;
+    const archive = new session_archive_1.SessionArchive(root, { enabled: true, now: () => clock });
+    await archive.recordTurn(turn({ time: new Date(clock).toISOString() }));
+    clock = now;
+    await archive.recordTurn(turn({ messageId: "新消息", text: "保留", time: new Date(now).toISOString() }));
+    await archive.prune();
+    const page = await archive.readSession("会话一");
+    strict_1.default.deepEqual(page.turns.map((item) => item.text), ["保留"]);
+    strict_1.default.equal(page.complete, false);
+    strict_1.default.ok(page.missingReasons.some((reason) => reason.includes("过期")));
+}));
+(0, node_test_1.default)("损坏和缺失正文显式报告不完整，删除和清空可重启验证", () => temporary(async (root) => {
+    const archive = new session_archive_1.SessionArchive(root, { enabled: true, now: () => now });
+    await archive.recordTurn(turn());
+    const filename = (await (0, promises_1.readdir)(root)).find((name) => name.endsWith(".jsonl"));
+    await (0, promises_1.appendFile)((0, node_path_1.join)(root, filename), "{坏行\n");
+    const page = await archive.readSession("会话一");
+    strict_1.default.equal(page.turns.length, 1);
+    strict_1.default.equal(page.complete, false);
+    strict_1.default.ok(page.missingReasons.some((reason) => reason.includes("损坏")));
+    await (0, promises_1.rm)((0, node_path_1.join)(root, filename));
+    strict_1.default.equal((await archive.readSession("会话一")).complete, false);
+    await archive.deleteSession("会话一");
+    strict_1.default.equal((await new session_archive_1.SessionArchive(root).listSessions()).total, 0);
+    await archive.recordTurn(turn({ sessionId: "二" }));
+    await archive.clear();
+    strict_1.default.equal((await new session_archive_1.SessionArchive(root).listSessions()).total, 0);
+    strict_1.default.equal((await (0, promises_1.readdir)(root)).filter((name) => name.endsWith(".jsonl")).length, 0);
+}));
+(0, node_test_1.default)("损坏目录不会伪装成完整空列表或覆盖原文件", () => temporary(async (root) => {
+    const archive = new session_archive_1.SessionArchive(root, { enabled: true, now: () => now });
+    await archive.recordTurn(turn());
+    const filename = (await (0, promises_1.readdir)(root)).find((name) => name.endsWith(".json"));
+    await (0, promises_1.appendFile)((0, node_path_1.join)(root, filename), "坏数据");
+    const broken = new session_archive_1.SessionArchive(root, { enabled: true, now: () => now });
+    strict_1.default.equal((await broken.listSessions()).complete, false);
+    await strict_1.default.rejects(broken.recordTurn(turn({ sessionId: "新会话" })), /目录/);
+    strict_1.default.ok((await (0, promises_1.readFile)((0, node_path_1.join)(root, filename), "utf8")).endsWith("坏数据"));
+}));
+(0, node_test_1.default)("启停设置与写入按调用顺序执行，目录快照不被后续更新改变", () => temporary(async (root) => {
+    const archive = new session_archive_1.SessionArchive(root, { now: () => now });
+    archive.setEnabled(true);
+    const pending = archive.recordTurn(turn());
+    archive.setEnabled(false);
+    await pending;
+    await archive.recordTurn(turn({ messageId: "不保存" }));
+    const snapshot = await archive.snapshotSessions();
+    strict_1.default.equal(snapshot.sessions[0].turnCount, 1);
+    archive.setEnabled(true);
+    await archive.recordTurn(turn({ messageId: "保存" }));
+    strict_1.default.equal(snapshot.sessions[0].turnCount, 1);
+    strict_1.default.equal((await archive.readSession("会话一")).turns.length, 2);
+}));
+(0, node_test_1.default)("会话数拒录不删除现有会话，单会话不完整不影响目录可信度", () => temporary(async (root) => {
+    const archive = new session_archive_1.SessionArchive(root, { enabled: true, now: () => now, limits: { maxSessions: 1, maxTextBytes: 4 } });
+    await archive.recordTurn(turn());
+    strict_1.default.equal((await archive.listSessions()).complete, true);
+    strict_1.default.equal((await archive.readSession("会话一")).complete, false);
+    await archive.recordTurn(turn({ sessionId: "会话二" }));
+    strict_1.default.equal((await archive.listSessions()).sessions[0].sessionId, "会话一");
+    strict_1.default.equal((await archive.listSessions()).complete, false);
+}));
+(0, node_test_1.default)("写入失败不会假装成功且保留可查询的缺口", () => temporary(async (root) => {
+    const archive = new session_archive_1.SessionArchive(root, { enabled: true, now: () => now });
+    await archive.recordTurn(turn());
+    const filename = (await (0, promises_1.readdir)(root)).find((name) => name.endsWith(".jsonl"));
+    await (0, promises_1.rm)((0, node_path_1.join)(root, filename));
+    const { mkdir } = await Promise.resolve().then(() => __importStar(require("node:fs/promises")));
+    await mkdir((0, node_path_1.join)(root, filename));
+    await strict_1.default.rejects(archive.recordTurn(turn({ messageId: "写入失败" })));
+    const page = await archive.readSession("会话一");
+    strict_1.default.equal(page.complete, false);
+    strict_1.default.ok(page.missingReasons.some((reason) => reason.includes("写入失败")));
+}));
+(0, node_test_1.default)("闲置超过保留期后所有查询入口先清理过期正文", () => temporary(async (root) => {
+    for (const query of ["read", "list", "snapshot"]) {
+        let clock = now;
+        const path = (0, node_path_1.join)(root, query);
+        const archive = new session_archive_1.SessionArchive(path, { enabled: true, now: () => clock });
+        await archive.recordTurn(turn());
+        clock += 31 * 86400_000;
+        if (query === "read") {
+            const page = await archive.readSession("会话一");
+            strict_1.default.equal(page.turns.length, 0);
+            strict_1.default.equal(page.complete, false);
+        }
+        else if (query === "list")
+            strict_1.default.equal((await archive.listSessions()).total, 0);
+        else
+            strict_1.default.equal((await archive.snapshotSessions()).sessions.length, 0);
+        strict_1.default.equal((await (0, promises_1.readdir)(path)).some((file) => file.endsWith(".jsonl")), false);
+    }
+}));
+(0, node_test_1.default)("保留期刚届满且距离上次清理不到一小时也不能读取", () => temporary(async (root) => {
+    let clock = now;
+    const archive = new session_archive_1.SessionArchive(root, { enabled: true, now: () => clock });
+    await archive.recordTurn(turn({ time: new Date(now - 30 * 86400_000 + 1000).toISOString() }));
+    await archive.prune();
+    clock += 1001;
+    strict_1.default.equal((await archive.readSession("会话一")).turns.length, 0);
+}));
+(0, node_test_1.default)("合法 JSON 中的损坏目录字段会被标记且拒绝覆盖", () => temporary(async (root) => {
+    const archive = new session_archive_1.SessionArchive(root, { enabled: true, now: () => now });
+    await archive.recordTurn(turn());
+    const path = (0, node_path_1.join)(root, "metadata.json");
+    const original = JSON.parse(await (0, promises_1.readFile)(path, "utf8"));
+    for (const mutate of [
+        (value) => { value.sessions = []; },
+        (value) => { value.sessions["会话一"] = null; },
+        (value) => { value.sessions["会话一"].title = { 无效: true }; },
+        (value) => { value.sessions["会话一"].firstSeenAt = 2026; },
+        (value) => { value.sessions["会话一"].incomplete = "错误"; },
+        (value) => { value.sessions["会话一"].turnCount = 1.2; },
+    ]) {
+        const metadata = structuredClone(original);
+        mutate(metadata);
+        await (0, promises_1.writeFile)(path, JSON.stringify(metadata));
+        const broken = new session_archive_1.SessionArchive(root, { enabled: true, now: () => now });
+        strict_1.default.equal((await broken.listSessions()).complete, false);
+        await strict_1.default.rejects(broken.recordTurn(turn()), /目录/);
+    }
+}));
+(0, node_test_1.default)("记录中的非法时间和附件元数据不能作为正文返回", () => temporary(async (root) => {
+    const archive = new session_archive_1.SessionArchive(root, { enabled: true, now: () => now });
+    await archive.recordTurn(turn());
+    const file = (0, node_path_1.join)(root, (await (0, promises_1.readdir)(root)).find((name) => name.endsWith(".jsonl")));
+    const original = JSON.parse((await (0, promises_1.readFile)(file, "utf8")).trim());
+    for (const patch of [{ time: 2026 }, { attachments: {} }, { attachments: [null] }, { attachments: [{ filename: 123, contentType: "text/plain", sizeBytes: 5 }] }, { attachments: [{ filename: "报告", contentType: "text/plain", sizeBytes: -1 }] }]) {
+        await (0, promises_1.writeFile)(file, `${JSON.stringify({ ...original, ...patch })}\n`);
+        const page = await archive.readSession("会话一");
+        strict_1.default.equal(page.turns.length, 0);
+        strict_1.default.equal(page.complete, false);
+    }
+}));
+(0, node_test_1.default)("超大归档文件在读入前拒绝且返回不完整", () => temporary(async (root) => {
+    const archive = new session_archive_1.SessionArchive(root, { enabled: true, now: () => now });
+    await archive.recordTurn(turn());
+    const file = (0, node_path_1.join)(root, (await (0, promises_1.readdir)(root)).find((name) => name.endsWith(".jsonl")));
+    await (0, promises_1.truncate)(file, session_archive_1.SESSION_ARCHIVE_LIMITS.maxSessionBytes + 1);
+    const page = await archive.readSession("会话一");
+    strict_1.default.equal(page.turns.length, 0);
+    strict_1.default.equal(page.complete, false);
+    strict_1.default.ok(page.missingReasons.some((reason) => reason.includes("大小")));
+    await (0, promises_1.truncate)((0, node_path_1.join)(root, "metadata.json"), 8 * 1024 * 1024 + 1);
+    strict_1.default.equal((await new session_archive_1.SessionArchive(root, { now: () => now }).snapshotSessions()).complete, false);
+}));
+(0, node_test_1.default)("拒录产生的完整性元数据同样受总磁盘字节上限约束", () => temporary(async (root) => {
+    const initial = new session_archive_1.SessionArchive(root, { enabled: true, now: () => now });
+    await initial.recordTurn(turn());
+    let bytes = 0;
+    for (const filename of await (0, promises_1.readdir)(root))
+        bytes += (await (0, promises_1.stat)((0, node_path_1.join)(root, filename))).size;
+    const archive = new session_archive_1.SessionArchive(root, { enabled: true, now: () => now, limits: { maxTotalBytes: bytes, maxTurnsPerSession: 1 } });
+    await archive.recordTurn(turn({ messageId: "超额" }));
+    let after = 0;
+    for (const filename of await (0, promises_1.readdir)(root))
+        after += (await (0, promises_1.stat)((0, node_path_1.join)(root, filename))).size;
+    strict_1.default.ok(after <= bytes, `${after} > ${bytes}`);
+}));
+(0, node_test_1.default)("删除正文失败时保留原目录并明确报告缺口", () => temporary(async (root) => {
+    const archive = new session_archive_1.SessionArchive(root, { enabled: true, now: () => now });
+    await archive.recordTurn(turn());
+    const file = (0, node_path_1.join)(root, (await (0, promises_1.readdir)(root)).find((name) => name.endsWith(".jsonl")));
+    await (0, promises_1.rm)(file);
+    const { mkdir } = await Promise.resolve().then(() => __importStar(require("node:fs/promises")));
+    await mkdir(file);
+    await strict_1.default.rejects(archive.deleteSession("会话一"));
+    strict_1.default.equal((await archive.listSessions()).total, 1);
+    strict_1.default.equal((await archive.readSession("会话一")).complete, false);
+    strict_1.default.equal((await new session_archive_1.SessionArchive(root, { now: () => now }).listSessions()).total, 1);
+}));
+(0, node_test_1.default)("整轮批量归档和读取串行执行，读取不会看到半轮", () => temporary(async (root) => {
+    const archive = new session_archive_1.SessionArchive(root, { enabled: true, now: () => now });
+    const response = turn({ role: "assistant", messageId: "回复", text: "完整回复" });
+    const writing = archive.recordTurns([turn(), response]);
+    const reading = archive.readSession("会话一");
+    await writing;
+    strict_1.default.deepEqual((await reading).turns.map((item) => item.role), ["user", "assistant"]);
+    const before = archive.readSession("会话一");
+    const next = archive.recordTurns([turn({ messageId: "下一问" }), turn({ ...response, messageId: "下一答" })]);
+    strict_1.default.equal((await before).turns.length, 2);
+    await next;
+    strict_1.default.equal((await archive.readSession("会话一")).turns.length, 4);
+}));
+(0, node_test_1.default)("整轮归档中途写入失败时已写入部分明确不完整", () => temporary(async (root) => {
+    const archive = new session_archive_1.SessionArchive(root, { enabled: true, now: () => now });
+    await archive.recordTurn(turn());
+    const file = (0, node_path_1.join)(root, (await (0, promises_1.readdir)(root)).find((name) => name.endsWith(".jsonl")));
+    await (0, promises_1.rm)(file);
+    const { mkdir } = await Promise.resolve().then(() => __importStar(require("node:fs/promises")));
+    await mkdir(file);
+    await strict_1.default.rejects(archive.recordTurns([turn({ messageId: "新消息" }), turn({ messageId: "失败" })]));
+    strict_1.default.equal((await archive.readSession("会话一")).complete, false);
+}));
+(0, node_test_1.default)("查询已经启动时后续批量写入删除及清空必须等待整个快照读取", () => temporary(async (root) => {
+    for (const query of ["read", "list", "snapshot"]) {
+        for (const mutation of ["record", "delete", "clear"]) {
+            const archive = new session_archive_1.SessionArchive((0, node_path_1.join)(root, `${query}-${mutation}`), { enabled: true, now: () => now });
+            await archive.recordTurn(turn());
+            let release;
+            let started;
+            const blocked = new Promise((resolve) => { release = resolve; });
+            const entered = new Promise((resolve) => { started = resolve; });
+            const internal = archive;
+            const loadMetadata = internal.loadMetadata.bind(archive);
+            let loads = 0;
+            let mutationEntered = false;
+            internal.loadMetadata = async () => {
+                const metadata = await loadMetadata();
+                if (++loads === 2) {
+                    started();
+                    await blocked;
+                }
+                else if (loads > 2)
+                    mutationEntered = true;
+                return metadata;
+            };
+            const reading = query === "read" ? archive.readSession("会话一") : query === "list" ? archive.listSessions() : archive.snapshotSessions();
+            await entered;
+            let mutationFinished = false;
+            const change = (mutation === "record" ? archive.recordTurns([turn({ messageId: "下一问" }), turn({ messageId: "下一答", role: "assistant" })]) : mutation === "delete" ? archive.deleteSession("会话一") : archive.clear()).then(() => { mutationFinished = true; });
+            await new Promise((resolve) => setImmediate(resolve));
+            const enteredBeforeQueryFinished = mutationEntered || mutationFinished;
+            release();
+            const result = await reading;
+            if ("turns" in result)
+                strict_1.default.equal(result.turns.length, 1);
+            else
+                strict_1.default.equal(result.sessions[0].turnCount, 1);
+            await change;
+            strict_1.default.equal(enteredBeforeQueryFinished, false, `${query}/${mutation} 在查询期间修改了归档`);
+        }
+    }
+}));
+(0, node_test_1.default)("完整来源键超过单维标识上限时仍可归档并重启读取", () => temporary(async (root) => {
+    const source = JSON.stringify(["aun", "本端", "聊天", "对端", "话题".repeat(250)]);
+    strict_1.default.ok(source.length > 512 && source.length <= 4096);
+    const archive = new session_archive_1.SessionArchive(root, { enabled: true, now: () => now });
+    await archive.recordTurn(turn({ source, principal: source }));
+    const restarted = new session_archive_1.SessionArchive(root, { now: () => now });
+    const page = await restarted.readSession("会话一");
+    strict_1.default.equal(page.complete, true);
+    strict_1.default.equal(page.turns[0].text, "用户正文");
+    strict_1.default.equal(page.session?.source, source);
+    strict_1.default.equal(page.session?.principal, source);
+}));
+(0, node_test_1.default)("来源和主体拒绝超长或含控制字符的键，会话标识仍限制单维长度", () => temporary(async (root) => {
+    const archive = new session_archive_1.SessionArchive(root, { enabled: true, now: () => now });
+    for (const field of ["source", "principal"]) {
+        for (const value of ["长".repeat(4097), "含\u0000字符", "含\r字符", "含\n字符"])
+            await strict_1.default.rejects(archive.recordTurn(turn({ [field]: value })), /无效/);
+    }
+    await strict_1.default.rejects(archive.recordTurn(turn({ sessionId: "长".repeat(513) })), /会话标识/);
+}));
+(0, node_test_1.default)("长来源累计目录元数据超过读取上限时清理旧会话并保持可重启读取", () => temporary(async (root) => {
+    const archive = new session_archive_1.SessionArchive(root, { enabled: true, now: () => now });
+    await archive.recordTurn(turn());
+    const internal = archive;
+    const source = JSON.stringify(["aun", "本端", "聊天", "对端", "话".repeat(4000)]);
+    for (let index = 0; index < 400; index++)
+        internal.metadata.sessions[`长来源${index}`] = {
+            sessionId: `长来源${index}`, source, principal: source, channel: "aun", agentPlugin: "workbuddy", firstSeenAt: new Date(now).toISOString(), updatedAt: new Date(now).toISOString(), turnCount: 0,
+        };
+    strict_1.default.ok(Buffer.byteLength(JSON.stringify(internal.metadata)) > 8 * 1024 * 1024);
+    await internal.saveMetadata(internal.metadata);
+    strict_1.default.ok((await (0, promises_1.stat)((0, node_path_1.join)(root, "metadata.json"))).size <= 8 * 1024 * 1024);
+    const restarted = new session_archive_1.SessionArchive(root, { now: () => now });
+    const snapshot = await restarted.snapshotSessions();
+    strict_1.default.ok(snapshot.sessions.length > 0 && snapshot.sessions.length < 401);
+    strict_1.default.equal(snapshot.complete, false);
+    strict_1.default.ok(snapshot.missingReasons.some((reason) => reason.includes("目录元数据")));
+    strict_1.default.equal(snapshot.missingReasons.some((reason) => reason.includes("损坏")), false);
+}));
+(0, node_test_1.default)("批量归档在首个落盘前预校验全部消息，避免半轮完整记录", () => temporary(async (root) => {
+    const archive = new session_archive_1.SessionArchive(root, { enabled: true, now: () => now });
+    const invalid = turn({ role: "assistant", messageId: "无效", attachments: [{ filename: "过长".repeat(300), contentType: "text/plain", sizeBytes: 1 }] });
+    await strict_1.default.rejects(archive.recordTurns([turn({ messageId: "批次用户" }), invalid]), /附件/);
+    strict_1.default.equal((await archive.listSessions()).total, 0);
+}));