const test = require('node:test');
const assert = require('node:assert');
const fs = require('fs');
const os = require('os');
const path = require('path');
const crypto = require('crypto');

const sessionsPath = require.resolve('../reader/ai-sessions.js');
const imagesPath = require.resolve('../reader/ai-images.js');

const dirs = [];

function tmp(tag) {
  const dir = fs.mkdtempSync(path.join(os.tmpdir(), `peoplelib-ai-sessions-${tag}-`));
  dirs.push(dir);
  return dir;
}

function fresh(tag = 'x') {
  const dir = tmp(tag);
  return at(dir);
}

function at(dir) {
  delete require.cache[sessionsPath];
  delete require.cache[imagesPath];
  const images = require(imagesPath);
  const sessions = require(sessionsPath);
  images.init(dir);
  sessions.init(dir);
  return { sessions, images, dir };
}

function sessionDir(dir) {
  return path.join(dir, 'reader-ai-sessions');
}

function sessionFile(dir, id) {
  return path.join(sessionDir(dir), `${id}.json`);
}

function imageDir(dir) {
  return path.join(dir, 'reader-ai-images');
}

// 最小可解码 JPEG：SOI + APP0 + 一段填充 + EOI。put 只校验 SOI 魔数，内容差异即哈希差异。
function jpeg(seed, size = 64) {
  const bytes = Buffer.alloc(size, seed & 0xff);
  bytes[0] = 0xff;
  bytes[1] = 0xd8;
  bytes[2] = 0xff;
  bytes[3] = 0xe0;
  bytes[size - 2] = 0xff;
  bytes[size - 1] = 0xd9;
  return bytes;
}

// atomic-file 通过 fd 写入，因此统计 openSync('<file>.tmp','w') 而不是 writeFileSync 的路径
function countWrites(matcher, fn) {
  const originalOpen = fs.openSync;
  let writes = 0;
  fs.openSync = function counting(target, flags, ...rest) {
    if (matcher(String(target)) && String(flags).startsWith('w')) writes++;
    return originalOpen.call(this, target, flags, ...rest);
  };
  try { fn(); } finally { fs.openSync = originalOpen; }
  return writes;
}

function round(s, id, question, answer) {
  s.appendUser(id, { text: question, task: 'ask' });
  const placeholder = s.appendAssistant(id, {});
  return s.finishAssistant(id, placeholder.id, { text: answer });
}

test.after(() => {
  for (const dir of dirs) {
    try { fs.rmSync(dir, { recursive: true, force: true }); } catch (e) { /* ignore */ }
  }
});

// --- 基本读写 ---

test('会话按 per-session 文件落盘，索引可枚举', () => {
  const { sessions, dir } = fresh('basic');
  const a = sessions.create({ entryId: 'e1', title: '甲会话' });
  const b = sessions.create({ entryId: 'e2' });
  assert.match(a.id, /^chat_[a-z0-9]+_[a-z0-9]+$/, '会话 ID 必须是可安全拼进文件名的形状');
  assert.strictEqual(a.entryId, 'e1');
  assert.strictEqual(b.entryId, 'e2');
  const files = fs.readdirSync(sessionDir(dir)).sort();
  assert.deepStrictEqual(files, ['index.json', `${a.id}.json`, `${b.id}.json`].sort(),
    '每个会话应独占一个文件，加上一份索引');
  assert.deepStrictEqual(sessions.list().map((row) => row.id).sort(), [a.id, b.id].sort());
  assert.deepStrictEqual(sessions.list({ entryId: 'e1' }).map((row) => row.id), [a.id]);
  assert.deepStrictEqual(sessions.list({ entryId: 'e404' }), []);
});

test('未指定 entryId 的会话落到 GLOBAL_ENTRY_ID，与独立笔记伪条目不同', () => {
  const { sessions } = fresh('global');
  const g = sessions.create({});
  assert.strictEqual(g.entryId, 'system:global-chat');
  assert.notStrictEqual(sessions.GLOBAL_ENTRY_ID, 'system:standalone-notes',
    '全局会话与独立笔记是两个伪条目，混用会让笔记与会话互相污染');
});

test('list 按 pinned desc, updatedAt desc 排序', () => {
  const { sessions } = fresh('sort');
  const a = sessions.create({ title: 'a' });
  const b = sessions.create({ title: 'b' });
  const c = sessions.create({ title: 'c' });
  sessions.rename(b.id, 'b2');
  sessions.setPinned(a.id, true);
  const ids = sessions.list().map((row) => row.id);
  assert.strictEqual(ids[0], a.id, 'pinned 的会话必须排最前');
  assert.ok(ids.indexOf(b.id) < ids.indexOf(c.id), '未 pin 的按 updatedAt 倒序');
});

test('一轮对话可完整读回，占位回答在 finish 时才成为消息', () => {
  const { sessions } = fresh('round');
  const meta = sessions.create({ entryId: 'e1' });
  sessions.appendUser(meta.id, { text: '这是问题', task: 'ask' });
  assert.strictEqual(sessions.messages(meta.id).messages.length, 1);
  const placeholder = sessions.appendAssistant(meta.id, {});
  assert.strictEqual(sessions.messages(meta.id).messages.length, 1,
    '占位回答不落盘，否则流式过程中每个增量都会整文件重写');
  const done = sessions.finishAssistant(meta.id, placeholder.id, { text: '这是回答' });
  assert.strictEqual(done.id, placeholder.id, 'finish 必须复用占位 ID，渲染层靠它对齐流式片段');
  const read = sessions.messages(meta.id);
  assert.deepStrictEqual(read.messages.map((m) => m.role), ['user', 'assistant']);
  assert.strictEqual(read.messages[1].text, '这是回答');
  assert.strictEqual(read.meta.messageCount, 2);
  assert.strictEqual(read.meta.title, '这是问题', '首轮问题应自动成为标题');
});

test('finishAssistant 可记录取消与错误，且 cancelled 保留残片', () => {
  const { sessions } = fresh('finish');
  const meta = sessions.create({});
  sessions.appendUser(meta.id, { text: 'q' });
  const p1 = sessions.appendAssistant(meta.id, {});
  const cancelled = sessions.finishAssistant(meta.id, p1.id, { text: '半句', cancelled: true });
  assert.strictEqual(cancelled.cancelled, true);
  assert.strictEqual(cancelled.text, '半句', '中途停止时残片必须保留，用户看到的就是它');
  sessions.appendUser(meta.id, { text: 'q2' });
  const p2 = sessions.appendAssistant(meta.id, {});
  const failed = sessions.finishAssistant(meta.id, p2.id, { text: '', error: '接口超时' });
  assert.strictEqual(failed.error, '接口超时');
  assert.throws(() => sessions.finishAssistant(meta.id, 'msg_nope', { text: 'x' }), /会话消息不存在/);
});

test('clear 清空消息但保留会话，remove 删除会话与索引行', () => {
  const { sessions, dir } = fresh('lifecycle');
  const meta = sessions.create({ entryId: 'e1', title: '保留' });
  round(sessions, meta.id, '问', '答');
  const cleared = sessions.clear(meta.id);
  assert.strictEqual(cleared.messageCount, 0);
  assert.strictEqual(cleared.droppedMessages, 0);
  assert.strictEqual(cleared.title, '保留', 'clear 不应丢标题');
  assert.strictEqual(sessions.list().length, 1);
  assert.strictEqual(sessions.remove(meta.id), true);
  assert.strictEqual(sessions.remove(meta.id), false);
  assert.strictEqual(sessions.list().length, 0);
  assert.ok(!fs.existsSync(sessionFile(dir, meta.id)));
  assert.throws(() => sessions.messages(meta.id), /会话不存在/);
});

test('messages 支持 limit 与 before 游标翻页', () => {
  const { sessions } = fresh('paging');
  const meta = sessions.create({});
  for (let i = 0; i < 5; i++) round(sessions, meta.id, `问${i}`, `答${i}`);
  const tail = sessions.messages(meta.id, { limit: 4 });
  assert.strictEqual(tail.messages.length, 4);
  assert.strictEqual(tail.hasMore, true);
  assert.strictEqual(tail.messages[3].text, '答4');
  const older = sessions.messages(meta.id, { limit: 4, before: tail.messages[0].id });
  assert.strictEqual(older.messages[older.messages.length - 1].id !== tail.messages[0].id, true,
    'before 必须是排他的，否则翻页会重复一条');
  assert.throws(() => sessions.messages(meta.id, { before: 'msg_missing' }), /会话消息不存在/);
});

// --- 字段限长 ---

test('受限字段超长时截断而不是抛错', () => {
  const { sessions } = fresh('limits');
  const L = sessions.LIMITS;
  const meta = sessions.create({ title: '标'.repeat(L.title + 50) });
  assert.strictEqual(meta.title.length, L.title, `title 应截到 ${L.title}`);
  const user = sessions.appendUser(meta.id, { text: '问'.repeat(L.question + 100) });
  assert.strictEqual(user.text.length, L.question, `user 文本应截到 question=${L.question}`);
  const p = sessions.appendAssistant(meta.id, {});
  const done = sessions.finishAssistant(meta.id, p.id, {
    text: '回答',
    error: '错'.repeat(L.errorText + 100)
  });
  assert.strictEqual(done.text, '回答');
  assert.strictEqual(done.error.length, L.errorText, `error 应截到 ${L.errorText}`);
  const renamed = sessions.rename(meta.id, '新'.repeat(L.title + 10));
  assert.strictEqual(renamed.title.length, L.title);
});

test('超过 20000 字的 assistant 正文经 append、finish 与磁盘恢复后保持完整', () => {
  const { sessions, dir } = fresh('long-assistant');
  const meta = sessions.create({});
  sessions.appendUser(meta.id, { text: '请生成长回答' });
  const initial = `占位开头${'初'.repeat(21000)}占位结尾`;
  const placeholder = sessions.appendAssistant(meta.id, { text: initial });
  assert.strictEqual(placeholder.text, initial, 'appendAssistant 不应静默截断 assistant 正文');
  const answer = `回答开头${'答'.repeat(25000)}回答结尾`;
  const done = sessions.finishAssistant(meta.id, placeholder.id, { text: answer });
  assert.strictEqual(done.text, answer, 'finishAssistant 不应静默截断 assistant 正文');
  const raw = JSON.parse(fs.readFileSync(sessionFile(dir, meta.id), 'utf8'));
  assert.strictEqual(raw.messages[1].text, answer, '超过 20000 字的回答必须完整落盘');
  const restored = at(dir).sessions.messages(meta.id);
  assert.strictEqual(restored.messages[1].text, answer, '超过 20000 字的回答必须从磁盘完整读回');
});

test('标题规范化去掉控制字符与换行，自动标题取首轮问题前 40 字', () => {
  const { sessions } = fresh('title');
  const meta = sessions.create({ title: ' 带\n换行\u0007和控制符 ' });
  assert.strictEqual(meta.title, '带 换行 和控制符', '标题会进索引 JSON，控制字符必须清掉');
  const auto = sessions.create({});
  sessions.appendUser(auto.id, { text: '标'.repeat(100) });
  assert.strictEqual(sessions.messages(auto.id).meta.title.length, 40, '自动标题只取前 40 字');
});

test('非法上下文与任务被拒，contextRef 只在 user 消息上存在', () => {
  const { sessions } = fresh('shape');
  const meta = sessions.create({});
  assert.throws(() => sessions.appendUser(meta.id, {
    text: 'q', contextRef: { scope: 'whatever' }
  }), /会话上下文范围无效/);
  assert.throws(() => sessions.appendUser(meta.id, { text: 'q', task: 'hack' }), /会话任务类型无效/);
  const withContext = sessions.appendUser(meta.id, {
    text: 'q',
    contextRef: { scope: 'page', text: '正文内容', clipped: true, locator: { page: 3 }, documentKey: 'dk', fileIndex: 2 }
  });
  assert.strictEqual(withContext.contextRef.chars, 4);
  assert.strictEqual(withContext.contextRef.hash, sessions.hashContext('正文内容'));
  assert.strictEqual(withContext.contextRef.hash.length, 32, 'hash 固定 32 hex，用于判断上下文是否变了');
  assert.strictEqual(withContext.contextRef.clipped, true);
  assert.deepStrictEqual(withContext.contextRef.locator, { page: 3 });
  const p = sessions.appendAssistant(meta.id, { contextRef: { scope: 'page', text: 'x' } });
  assert.strictEqual(p.contextRef, null, 'assistant 消息不应带 contextRef');
  assert.throws(() => sessions.appendUser(meta.id, {
    text: 'q', contextRef: { scope: 'page', locator: { blob: 'x'.repeat(60000) } }
  }), /定位信息/);
});

// --- 上限策略 ---

test('会话数达上限抛中文错误，且不删除已有会话', () => {
  const { sessions, dir } = fresh('total');
  const total = sessions.LIMITS.sessionsTotal;
  const ids = [];
  for (let i = 0; i < total; i++) ids.push(sessions.create({ title: `会话${i}` }).id);
  const before = fs.readdirSync(sessionDir(dir)).length;
  assert.throws(() => sessions.create({ title: '溢出' }), /会话数量已达上限/,
    '达到上限必须拒绝新建，绝不能静默删用户的旧会话');
  assert.strictEqual(fs.readdirSync(sessionDir(dir)).length, before, '拒绝新建不应改动磁盘');
  assert.strictEqual(sessions.list().length, total);
  sessions.remove(ids[0]);
  assert.ok(sessions.create({ title: '腾出位置后可建' }).id, '删掉一个后应能继续新建');
});

test('单会话消息达上限成对淘汰，首轮保留且不出现孤立 assistant', () => {
  const { sessions } = fresh('evict');
  const max = sessions.LIMITS.messagesPerSession;
  const meta = sessions.create({});
  sessions.appendUser(meta.id, { text: '首轮问题', contextRef: { scope: 'document', text: '正文' } });
  const first = sessions.appendAssistant(meta.id, {});
  sessions.finishAssistant(meta.id, first.id, { text: '首轮回答' });
  for (let i = 0; i < max; i++) round(sessions, meta.id, `问${i}`, `答${i}`);
  const read = sessions.messages(meta.id, { limit: max });
  assert.ok(read.meta.messageCount <= max, `消息数不得超过 ${max}`);
  assert.strictEqual(read.messages[0].text, '首轮问题', '承载正文的首轮必须永久保留');
  assert.ok(read.messages[0].contextRef, '首轮的 contextRef 不能被淘汰掉');
  assert.ok(read.meta.droppedMessages > 0, 'droppedMessages 必须累加，供历史里的省略标记使用');
  assert.strictEqual(read.meta.droppedMessages % 2, 0, '成对淘汰时丢弃数应为偶数');
  assert.strictEqual(
    read.meta.messageCount + read.meta.droppedMessages,
    (max + 1) * 2,
    '保留数加丢弃数应等于写入总数，说明没有额外丢失'
  );
  const roles = read.messages.map((m) => m.role);
  for (let i = 1; i < roles.length; i++) {
    assert.notStrictEqual(roles[i], roles[i - 1],
      '成对淘汰后不允许出现连续同角色，否则历史里会有没有提问的孤立回答');
  }
});

// appendUser 之后、finishAssistant 之前的这个中间态就是构造请求时 historyFor 看到的状态。
// 逐条丢弃在整轮结束时会被第二次丢弃恰好补回来，只有在中间态才能看出角色错位。
test('淘汰后的中间态也不出现连续同角色', () => {
  const { sessions } = fresh('evict-mid');
  const max = sessions.LIMITS.messagesPerSession;
  const meta = sessions.create({});
  for (let i = 0; i < max / 2; i++) round(sessions, meta.id, `问${i}`, `答${i}`);
  assert.strictEqual(sessions.messages(meta.id, { limit: max }).meta.messageCount, max, '先填满到上限');
  sessions.appendUser(meta.id, { text: '新问题' });
  const read = sessions.messages(meta.id, { limit: max });
  assert.strictEqual(read.meta.droppedMessages, 2, '一次淘汰应成对丢弃两条，而不是单条');
  const roles = read.messages.map((m) => m.role);
  for (let i = 1; i < roles.length; i++) {
    assert.notStrictEqual(roles[i], roles[i - 1],
      '中间态出现连续同角色，说明淘汰是逐条而非成对，这会让历史里出现两条相邻的回答');
  }
  assert.strictEqual(roles[0], 'user');
  assert.strictEqual(read.messages[0].text, '问0', '首轮提问必须还在');
  assert.strictEqual(roles[roles.length - 1], 'user');
  const out = sessions.historyFor(meta.id, { maxChars: 100000, maxMessages: max, maxMessageChars: 2000 });
  assert.strictEqual(
    out.messages.length,
    read.messages.length,
    '中间态角色已经交替，historyFor 不该再需要合并任何消息；需要合并说明淘汰留下了错位'
  );
});

test('图像数达上限时丢弃最早消息的图像引用但保留文本', () => {
  const { sessions, images } = fresh('img-evict');
  const max = sessions.LIMITS.imagesPerSession;
  const meta = sessions.create({});
  const ids = [];
  for (let i = 0; i <= max; i++) {
    const put = images.put(jpeg(i + 1), 'image/jpeg');
    ids.push(put.imageId);
    sessions.appendUser(meta.id, {
      text: `第 ${i} 张`,
      images: [{ imageId: put.imageId, mimeType: 'image/jpeg', width: 10, height: 10, bytes: put.bytes }]
    });
    const p = sessions.appendAssistant(meta.id, {});
    sessions.finishAssistant(meta.id, p.id, { text: `答 ${i}` });
  }
  const read = sessions.messages(meta.id, { limit: 500 });
  const totalImages = read.messages.reduce((n, m) => n + m.images.length, 0);
  assert.ok(totalImages <= max, `会话内图像引用不得超过 ${max}`);
  assert.strictEqual(read.messages[0].text, '第 0 张', '丢图像引用不应丢文本');
  assert.strictEqual(read.messages[0].images.length, 0, '最早的图像引用先被丢弃');
  assert.ok(!sessions.imageIds().includes(ids[0]), '被丢弃的引用不应再出现在 GC 白名单里');
});

// --- 文件隔离与写放大 ---

test('追加消息只重写自己那个会话文件', () => {
  const { sessions, dir } = fresh('isolate');
  const a = sessions.create({ title: 'a' });
  const b = sessions.create({ title: 'b' });
  const bFile = sessionFile(dir, b.id);
  const before = crypto.createHash('sha256').update(fs.readFileSync(bFile)).digest('hex');
  round(sessions, a.id, '问', '答');
  const after = crypto.createHash('sha256').update(fs.readFileSync(bFile)).digest('hex');
  assert.strictEqual(after, before, '写 a 不应碰 b 的字节，否则 100 个会话就是 100 倍写放大');
  const writesToB = countWrites((t) => t === `${bFile}.tmp`, () => {
    round(sessions, a.id, '问2', '答2');
  });
  assert.strictEqual(writesToB, 0, '其他会话文件的写入次数必须是 0');
});

test('一轮对话对会话文件只写两次，索引写入不随消息数增长', () => {
  const { sessions, dir } = fresh('writes');
  const meta = sessions.create({});
  const file = sessionFile(dir, meta.id);
  const isSession = (t) => t === `${file}.tmp`;
  const oneRound = countWrites(isSession, () => {
    sessions.appendUser(meta.id, { text: '问' });
    const p = sessions.appendAssistant(meta.id, {});
    for (let i = 0; i < 50; i++) sessions.appendAssistant; // 流式增量不经过存储层
    sessions.finishAssistant(meta.id, p.id, { text: '答'.repeat(500) });
  });
  assert.strictEqual(oneRound, 2, '一轮对话最多两次会话文件写入：appendUser 一次，finishAssistant 一次');
  // 对照：两轮就是四次，证明计数器没失灵
  const twoRounds = countWrites(isSession, () => {
    round(sessions, meta.id, '问2', '答2');
    round(sessions, meta.id, '问3', '答3');
  });
  assert.strictEqual(twoRounds, 4, '两轮应写四次，用于对照说明上面的 2 不是计数器失灵');
  const idxFile = path.join(sessionDir(dir), 'index.json');
  const idxWrites = countWrites((t) => t === `${idxFile}.tmp`, () => {
    round(sessions, meta.id, '问4', '答4');
  });
  assert.strictEqual(idxWrites, 2, '索引跟着会话文件一起更新，一轮两次');
});

test('会话文件解析结果按内容缓存，同 mtime 同体积但内容不同也不会读到旧值', () => {
  const { sessions, dir } = fresh('cache');
  const meta = sessions.create({});
  round(sessions, meta.id, '原始问题', '原始回答');
  const file = sessionFile(dir, meta.id);
  const raw = JSON.parse(fs.readFileSync(file, 'utf8'));
  // utimesSync 会丢掉 mtime 的小数毫秒，先钉成整秒再取基准，否则构造本身对不上
  const fixed = new Date(1700000000000);
  fs.utimesSync(file, fixed, fixed);
  const stat = fs.statSync(file);
  assert.strictEqual(sessions.messages(meta.id).messages[0].text, '原始问题');
  // 等长替换 + 还原 mtime：按 mtime+size 判定的缓存在这里会返回旧内容
  raw.messages[0].text = '篡改问题';
  const rewritten = JSON.stringify(raw, null, 2);
  assert.strictEqual(Buffer.byteLength(rewritten, 'utf8'), stat.size, '构造用例要求体积不变');
  fs.writeFileSync(file, rewritten);
  fs.utimesSync(file, fixed, fixed);
  assert.strictEqual(fs.statSync(file).mtimeMs, stat.mtimeMs, '构造用例要求 mtime 不变');
  assert.strictEqual(fs.statSync(file).size, stat.size, '构造用例要求体积不变');
  assert.strictEqual(sessions.messages(meta.id).messages[0].text, '篡改问题',
    '缓存必须按内容哈希失效，按 mtime+size 会漏掉同毫秒内的改写');
});

// --- 损坏自愈 ---

test('主文件损坏时从 .bak 恢复', () => {
  const { sessions, dir } = fresh('bak');
  const meta = sessions.create({ entryId: 'e1' });
  round(sessions, meta.id, '问', '答');
  const file = sessionFile(dir, meta.id);
  fs.copyFileSync(file, `${file}.bak`);
  fs.writeFileSync(file, '{ 这不是 JSON');
  const read = sessions.messages(meta.id);
  assert.strictEqual(read.messages.length, 2, '.bak 完好时必须恢复出完整对话');
  assert.strictEqual(read.messages[0].text, '问');
  const corrupt = fs.readdirSync(sessionDir(dir)).filter((n) => n.includes('.corrupt-'));
  assert.strictEqual(corrupt.length, 1, '损坏的主文件应被隔离留档而不是直接删除');
});

test('主文件与 .bak 都损坏时隔离成 .corrupt- 并返回空会话', () => {
  const { sessions, dir } = fresh('corrupt');
  const meta = sessions.create({ entryId: 'e1', title: '标题' });
  round(sessions, meta.id, '问', '答');
  const file = sessionFile(dir, meta.id);
  fs.writeFileSync(file, 'broken');
  fs.writeFileSync(`${file}.bak`, 'also broken');
  const read = sessions.messages(meta.id);
  assert.deepStrictEqual(read.messages, [], '两份都坏只能返回空，不能抛错让界面卡死');
  assert.strictEqual(read.meta.entryId, 'e1', '空会话应从索引行恢复出归属，否则会变成孤立会话');
  const corrupt = fs.readdirSync(sessionDir(dir)).filter((n) => n.includes('.corrupt-'));
  assert.strictEqual(corrupt.length, 1);
  round(sessions, meta.id, '新问', '新答');
  assert.strictEqual(sessions.messages(meta.id).messages.length, 2, '自愈后应能继续写入');
});

test('index.json 丢失后扫目录重建，list 结果正确', () => {
  const { sessions, dir } = fresh('reindex');
  const a = sessions.create({ entryId: 'e1', title: '甲' });
  const b = sessions.create({ entryId: 'e2', title: '乙' });
  round(sessions, a.id, '问', '答');
  const idxFile = path.join(sessionDir(dir), 'index.json');
  fs.unlinkSync(idxFile);
  const reloaded = at(dir).sessions;
  const rows = reloaded.list();
  assert.strictEqual(rows.length, 2, '索引是派生缓存，丢失后必须能从会话文件重建');
  const rowA = rows.find((r) => r.id === a.id);
  assert.strictEqual(rowA.title, '甲');
  assert.strictEqual(rowA.entryId, 'e1');
  assert.strictEqual(rowA.messageCount, 2);
  assert.ok(rowA.bytes > 0, '重建的索引行应带上真实体积');
  assert.strictEqual(rows.find((r) => r.id === b.id).messageCount, 0);
  assert.ok(fs.existsSync(idxFile), '重建结果应回写磁盘');
});

test('index.json 损坏时重建，且损坏的索引不会让会话消失', () => {
  const { sessions, dir } = fresh('reindex2');
  const a = sessions.create({ title: '甲' });
  fs.writeFileSync(path.join(sessionDir(dir), 'index.json'), '[[[not json');
  const reloaded = at(dir).sessions;
  assert.deepStrictEqual(reloaded.list().map((r) => r.id), [a.id]);
});

test('索引里混入非法行时被丢弃，真实会话仍在', () => {
  const { sessions, dir } = fresh('reindex3');
  const a = sessions.create({ title: '甲' });
  const idxFile = path.join(sessionDir(dir), 'index.json');
  const idx = JSON.parse(fs.readFileSync(idxFile, 'utf8'));
  idx.sessions.push({ id: '../escape', title: '恶意' });
  idx.sessions.push({ id: '__proto__', title: '污染' });
  fs.writeFileSync(idxFile, JSON.stringify(idx, null, 2));
  const rows = at(dir).sessions.list();
  assert.deepStrictEqual(rows.map((r) => r.id), [a.id], '索引里的非法 ID 必须被丢弃');
});

test('会话文件里的坏消息被逐条丢弃，其余消息仍可读', () => {
  const { sessions, dir } = fresh('bad-msg');
  const meta = sessions.create({});
  round(sessions, meta.id, '好问题', '好回答');
  const file = sessionFile(dir, meta.id);
  const raw = JSON.parse(fs.readFileSync(file, 'utf8'));
  raw.messages.splice(1, 0, { role: 'nobody', text: '坏消息' }, null, 'not an object');
  raw.messages.push({ role: 'assistant', text: '尾部回答', images: 'not an array', task: '非法' });
  fs.writeFileSync(file, JSON.stringify(raw, null, 2));
  const read = at(dir).sessions.messages(meta.id);
  assert.deepStrictEqual(read.messages.map((m) => m.text), ['好问题', '好回答', '尾部回答'],
    '会话内容部分来自模型输出，坏条目要丢弃而不是让整个会话读不出来');
  assert.deepStrictEqual(read.messages[2].images, []);
  assert.strictEqual(read.messages[2].task, null);
});

// --- ID 校验 ---

test('非法会话 ID 被拒，不产生任何文件', () => {
  const { sessions, dir } = fresh('ids');
  const bad = ['', '../escape', 'a/b', 'a\\b', '__proto__', 'prototype', 'constructor',
    '.', '..', '-lead', 'x'.repeat(200), 'a.b', 'a:b', null, undefined, 'chat_ok\u0000'];
  for (const id of bad) {
    assert.throws(() => sessions.messages(id), /会话 ID 无效/, `会话 ID ${JSON.stringify(id)} 必须被拒`);
    assert.throws(() => sessions.remove(id), /会话 ID 无效/);
    assert.throws(() => sessions.appendUser(id, { text: 'x' }), /会话 ID 无效/);
  }
  assert.ok(!fs.existsSync(sessionDir(dir)) || !fs.readdirSync(sessionDir(dir)).some((n) => n !== 'index.json'),
    '被拒的 ID 不应在磁盘上留下文件');
});

test('非法 entryId 与 messageId 被拒', () => {
  const { sessions } = fresh('ids2');
  for (const entryId of ['../x', 'a/b', '__proto__', 'x'.repeat(200), '.', '..']) {
    assert.throws(() => sessions.create({ entryId }), /会话条目 ID 无效/);
  }
  const meta = sessions.create({ entryId: 'e1' });
  for (const msgId of ['', '../x', 'a/b', '__proto__', 'x'.repeat(200)]) {
    assert.throws(() => sessions.finishAssistant(meta.id, msgId, { text: 'x' }), /会话消息 ID 无效/);
  }
  for (const msgId of ['../x', 'a/b', '__proto__', 'x'.repeat(200)]) {
    assert.throws(() => sessions.messages(meta.id, { before: msgId }), /会话消息 ID 无效/);
  }
  assert.doesNotThrow(() => sessions.messages(meta.id, { before: '' }), '空游标等价于不传，取最新一页');
});

test('finishAssistant 不能跨会话认领占位消息', () => {
  const { sessions } = fresh('cross');
  const a = sessions.create({});
  const b = sessions.create({});
  sessions.appendUser(a.id, { text: 'q' });
  const p = sessions.appendAssistant(a.id, {});
  assert.throws(() => sessions.finishAssistant(b.id, p.id, { text: '越界' }), /会话消息不存在/,
    '占位消息必须绑定会话，否则渲染层可以把回答写进别的会话');
});

// --- historyFor ---

function history(sessions, id, budget) {
  return sessions.historyFor(id, budget);
}

test('historyFor 始终 pin 首条 user 消息', () => {
  const { sessions } = fresh('hist-pin');
  const meta = sessions.create({});
  sessions.appendUser(meta.id, { text: `正文${'甲'.repeat(300)}`, contextRef: { scope: 'document', text: 'x' } });
  const p = sessions.appendAssistant(meta.id, {});
  sessions.finishAssistant(meta.id, p.id, { text: '首答' });
  for (let i = 0; i < 20; i++) round(sessions, meta.id, `问${i}`.repeat(20), `答${i}`.repeat(20));
  const out = history(sessions, meta.id, { maxChars: 600, maxMessages: 6, maxMessageChars: 400 });
  assert.strictEqual(out.messages[0].role, 'user');
  assert.ok(out.messages[0].text.includes('正文'),
    '承载正文的首条 user 必须永远在历史里，否则后续追问会失去参照');
  assert.ok(out.messages.length < 42, '预算内应确实丢掉了中间轮次');
  assert.ok(out.dropped > 0);
});

test('historyFor 的省略标记折进现有消息而不是新增消息', () => {
  const { sessions } = fresh('hist-mark');
  const meta = sessions.create({});
  for (let i = 0; i < 12; i++) round(sessions, meta.id, `问题${i}`.repeat(20), `回答${i}`.repeat(20));
  const out = history(sessions, meta.id, { maxChars: 500, maxMessages: 5, maxMessageChars: 400 });
  const marked = out.messages.filter((m) => /已省略较早的 \d+ 轮对话/.test(m.text));
  assert.strictEqual(marked.length, 1, '省略标记只应出现一次');
  assert.strictEqual(marked[0], out.messages[0], '标记必须折进最旧那条保留消息');
  assert.ok(marked[0].text.length > '[……已省略较早的 1 轮对话……]\n'.length,
    '标记是折进去的，所以这条消息里还应有原本的正文，而不是一条只有标记的空消息');
  assert.ok(out.messages.every((m) => m.role === 'user' || m.role === 'assistant'),
    '不允许为了放标记而造出 system 之类的新角色');
});

test('historyFor 总字符不超过 maxChars', () => {
  const { sessions } = fresh('hist-total');
  const meta = sessions.create({});
  for (let i = 0; i < 15; i++) round(sessions, meta.id, `问${i}`.repeat(50), `答${i}`.repeat(50));
  for (const maxChars of [200, 500, 1200, 3000]) {
    const out = history(sessions, meta.id, { maxChars, maxMessages: 30, maxMessageChars: 2000 });
    const total = out.messages.reduce((n, m) => n + m.text.length, 0);
    assert.ok(total <= maxChars, `maxChars=${maxChars} 时实际 ${total} 字符，超预算会直接被接口拒绝`);
  }
});

test('historyFor 单条超限中间挖空且保留尾部', () => {
  const { sessions } = fresh('hist-clip');
  const meta = sessions.create({});
  const head = '开头标记';
  const tail = '结尾标记';
  sessions.appendUser(meta.id, { text: `${head}${'填'.repeat(3000)}${tail}` });
  const p = sessions.appendAssistant(meta.id, {});
  sessions.finishAssistant(meta.id, p.id, { text: '答' });
  const out = history(sessions, meta.id, { maxChars: 4000, maxMessages: 10, maxMessageChars: 600 });
  const first = out.messages[0];
  assert.ok(first.text.length <= 600, '单条应被压到 maxMessageChars 以内');
  assert.ok(first.text.startsWith(head), '挖空必须保留头部');
  assert.ok(first.text.endsWith(tail), '挖空必须保留尾部，尾部往往是真正的提问');
  assert.ok(first.text.includes('中间内容已省略'), '挖空处要有可见标记');
  assert.strictEqual(first.truncated, true, 'truncated 标记供界面提示用户');
});

test('historyFor 裁剪后若首条是 assistant 则丢掉它', () => {
  const { sessions, dir } = fresh('hist-lead');
  const meta = sessions.create({});
  round(sessions, meta.id, '问', '答');
  // 恶性输入：直接把会话文件改成 assistant 领头，模拟历史数据或模型侧写坏
  const file = sessionFile(dir, meta.id);
  const raw = JSON.parse(fs.readFileSync(file, 'utf8'));
  raw.messages = [
    { id: 'msg_a1', role: 'assistant', text: '孤立回答', createdAt: 1 },
    { id: 'msg_u1', role: 'user', text: '真正的提问', createdAt: 2 },
    { id: 'msg_a2', role: 'assistant', text: '真正的回答', createdAt: 3 }
  ];
  fs.writeFileSync(file, JSON.stringify(raw, null, 2));
  const out = at(dir).sessions.historyFor(meta.id, { maxChars: 4000, maxMessages: 10, maxMessageChars: 400 });
  assert.strictEqual(out.messages[0].role, 'user',
    'Anthropic 的 /messages 要求 messages[0].role === "user"，领头的 assistant 必须丢掉');
  assert.ok(!out.messages.some((m) => m.text.includes('孤立回答')));
});

test('historyFor 不产生连续同角色消息', () => {
  const { sessions, dir } = fresh('hist-roles');
  const meta = sessions.create({});
  round(sessions, meta.id, '问', '答');
  const file = sessionFile(dir, meta.id);
  const raw = JSON.parse(fs.readFileSync(file, 'utf8'));
  raw.messages = [
    { id: 'msg_u1', role: 'user', text: '问一', createdAt: 1 },
    { id: 'msg_u2', role: 'user', text: '问二', createdAt: 2 },
    { id: 'msg_u3', role: 'user', text: '问三', createdAt: 3 },
    { id: 'msg_a1', role: 'assistant', text: '答一', createdAt: 4 },
    { id: 'msg_a2', role: 'assistant', text: '答二', createdAt: 5 },
    { id: 'msg_u4', role: 'user', text: '问四', createdAt: 6 }
  ];
  fs.writeFileSync(file, JSON.stringify(raw, null, 2));
  const reloaded = at(dir).sessions;
  for (const budget of [
    { maxChars: 4000, maxMessages: 10, maxMessageChars: 400 },
    { maxChars: 20, maxMessages: 3, maxMessageChars: 50 },
    { maxChars: 4000, maxMessages: 2, maxMessageChars: 400 }
  ]) {
    const out = reloaded.historyFor(meta.id, budget);
    const roles = out.messages.map((m) => m.role);
    for (let i = 1; i < roles.length; i++) {
      assert.notStrictEqual(roles[i], roles[i - 1],
        `预算 ${JSON.stringify(budget)} 下出现了连续同角色，Anthropic 会直接 400`);
    }
    if (roles.length) assert.strictEqual(roles[0], 'user');
    assert.ok(out.messages.find((m) => m.text.includes('问一')), '首条 user 仍应被 pin');
  }
});

test('historyFor 把已被物理丢弃的轮次计入省略标记', () => {
  const { sessions } = fresh('hist-dropped');
  const max = sessions.LIMITS.messagesPerSession;
  const meta = sessions.create({});
  for (let i = 0; i < max; i++) round(sessions, meta.id, `问${i}`, `答${i}`);
  const read = sessions.messages(meta.id, { limit: max });
  assert.ok(read.meta.droppedMessages > 0);
  const out = history(sessions, meta.id, { maxChars: 100000, maxMessages: max, maxMessageChars: 2000 });
  assert.ok(out.dropped >= read.meta.droppedMessages,
    '磁盘上已丢的轮次也要计入 dropped，否则模型会以为它看到了完整对话');
  assert.match(out.messages[0].text, /已省略较早的 \d+ 轮对话/);
});

test('historyFor 在空会话与单条会话上不炸', () => {
  const { sessions } = fresh('hist-edge');
  const meta = sessions.create({});
  assert.deepStrictEqual(sessions.historyFor(meta.id, {}), { messages: [], dropped: 0 });
  sessions.appendUser(meta.id, { text: '只有一条' });
  const out = sessions.historyFor(meta.id, { maxChars: 5, maxMessages: 1, maxMessageChars: 50 });
  assert.strictEqual(out.messages.length, 1, '首条 user 即使超预算也要留下，否则请求没有内容可发');
  assert.strictEqual(out.messages[0].role, 'user');
});

// --- imageIds 与 GC ---

test('imageIds 遍历全部会话文件，索引缺行也能找到引用', () => {
  const { sessions, images, dir } = fresh('gc-scan');
  const a = sessions.create({ title: '甲' });
  const b = sessions.create({ title: '乙' });
  const imgA = images.put(jpeg(11), 'image/jpeg');
  const imgB = images.put(jpeg(22), 'image/jpeg');
  sessions.appendUser(a.id, { text: '带图甲', images: [{ imageId: imgA.imageId, bytes: imgA.bytes }] });
  sessions.appendUser(b.id, { text: '带图乙', images: [{ imageId: imgB.imageId, bytes: imgB.bytes }] });
  // 故意让索引缺掉 b：只读索引的 GC 会把 b 引用的图当垃圾删掉
  const idxFile = path.join(sessionDir(dir), 'index.json');
  const idx = JSON.parse(fs.readFileSync(idxFile, 'utf8'));
  idx.sessions = idx.sessions.filter((row) => row.id !== b.id);
  fs.writeFileSync(idxFile, JSON.stringify(idx, null, 2));
  const reloaded = at(dir);
  assert.ok(!reloaded.sessions.list().some((row) => row.id === b.id) || true);
  const ids = reloaded.sessions.imageIds();
  assert.ok(ids.includes(imgB.imageId),
    'imageIds 必须扫目录而不是读索引，索引损坏时只读索引会静默删掉仍被引用的图');
  assert.ok(ids.includes(imgA.imageId));
  const removed = reloaded.images.cleanup(ids, { graceMs: 0 });
  assert.strictEqual(removed, 0, '全部图仍被引用时不该删任何东西');
  assert.ok(fs.existsSync(path.join(imageDir(dir), `${imgB.imageId}.jpg`)));
});

test('imageIds 覆盖 .bak 里的引用与内存中的占位消息', () => {
  const { sessions, images, dir } = fresh('gc-bak');
  const meta = sessions.create({});
  const img = images.put(jpeg(33), 'image/jpeg');
  sessions.appendUser(meta.id, { text: '带图', images: [{ imageId: img.imageId, bytes: img.bytes }] });
  const file = sessionFile(dir, meta.id);
  fs.copyFileSync(file, `${file}.bak`);
  fs.writeFileSync(file, 'broken');
  const reloaded = at(dir);
  assert.ok(reloaded.sessions.imageIds().includes(img.imageId),
    '主文件坏掉但 .bak 还引用着这张图，GC 不能删它');
  const pendingImg = images.put(jpeg(44), 'image/jpeg');
  const s2 = fresh('gc-pending');
  const m2 = s2.sessions.create({});
  s2.sessions.appendUser(m2.id, { text: 'q' });
  s2.sessions.appendAssistant(m2.id, { images: [{ imageId: pendingImg.imageId, bytes: pendingImg.bytes }] });
  assert.ok(s2.sessions.imageIds().includes(pendingImg.imageId),
    '未落盘的占位消息引用的图也要在白名单里，否则流式期间的 GC 会删掉它');
});

test('会话删除后其图像被 cleanup 回收', () => {
  const { sessions, images, dir } = fresh('gc-remove');
  const keep = sessions.create({ title: '留' });
  const drop = sessions.create({ title: '删' });
  const imgKeep = images.put(jpeg(55), 'image/jpeg');
  const imgDrop = images.put(jpeg(66), 'image/jpeg');
  sessions.appendUser(keep.id, { text: 'k', images: [{ imageId: imgKeep.imageId, bytes: imgKeep.bytes }] });
  sessions.appendUser(drop.id, { text: 'd', images: [{ imageId: imgDrop.imageId, bytes: imgDrop.bytes }] });
  sessions.remove(drop.id);
  const removed = images.cleanup(sessions.imageIds(), { graceMs: 0 });
  assert.strictEqual(removed, 1);
  assert.ok(fs.existsSync(path.join(imageDir(dir), `${imgKeep.imageId}.jpg`)));
  assert.ok(!fs.existsSync(path.join(imageDir(dir), `${imgDrop.imageId}.jpg`)));
});

// --- ai-images ---

test('ai-images 只收 JPEG，魔数不对直接拒', () => {
  const { images } = fresh('img-mime');
  const png = Buffer.from('89504e470d0a1a0a0000000d49484452', 'hex');
  assert.throws(() => images.put(png, 'image/png'), /仅支持 JPEG/);
  assert.throws(() => images.put(png, 'image/jpeg'), /不是有效的 JPEG/,
    '声明 JPEG 但内容是 PNG 必须被拒，否则视觉接口会收到无法解码的负载');
  assert.throws(() => images.put(Buffer.alloc(0), 'image/jpeg'), /数据为空/);
  assert.throws(() => images.put(Buffer.alloc(64, 0), 'image/jpeg'), /不是有效的 JPEG/);
  assert.throws(() => images.put('not a buffer', 'image/jpeg'), /数据为空/);
  assert.throws(() => images.put(jpeg(1, 4 * 1024 * 1024), 'image/jpeg'), /超过 3 MB/);
});

test('ai-images 内容寻址去重，同图两次 put 只占一份磁盘', () => {
  const { images, dir } = fresh('img-dedup');
  const bytes = jpeg(77, 1024);
  const first = images.put(bytes, 'image/jpeg');
  const second = images.put(Buffer.from(bytes), 'image/jpeg');
  assert.strictEqual(second.imageId, first.imageId, '同样的字节必须得到同样的 imageId');
  assert.strictEqual(fs.readdirSync(imageDir(dir)).length, 1, '去重后磁盘上只应有一份');
  assert.strictEqual(images.totalBytes(), 1024);
  assert.match(first.imageId, /^img_[a-f0-9]{64}$/);
  const other = images.put(jpeg(78, 1024), 'image/jpeg');
  assert.notStrictEqual(other.imageId, first.imageId, '不同字节必须得到不同 imageId');
  assert.strictEqual(images.totalBytes(), 2048);
});

test('ai-images 读回与 dataUrl 一致，非法 imageId 被拒', () => {
  const { images } = fresh('img-read');
  const bytes = jpeg(88, 256);
  const { imageId } = images.put(bytes, 'image/jpeg');
  assert.ok(images.read(imageId).equals(bytes));
  assert.strictEqual(images.dataUrl(imageId), `data:image/jpeg;base64,${bytes.toString('base64')}`);
  for (const bad of ['', 'img_short', '../escape', 'img_' + 'g'.repeat(64), '__proto__',
    `img_${'a'.repeat(64)}/../x`, null, 'pdf_' + 'a'.repeat(64)]) {
    assert.throws(() => images.read(bad), /会话图像标识无效/, `imageId ${JSON.stringify(bad)} 必须被拒`);
    assert.throws(() => images.dataUrl(bad), /会话图像标识无效/);
    assert.throws(() => images.safeImageId(bad), /会话图像标识无效/);
  }
  assert.throws(() => images.read(`img_${'a'.repeat(64)}`), /会话图像不存在/);
});

test('ai-images cleanup 只删未引用的，宽限期内的新文件不删', () => {
  const { images, dir } = fresh('img-cleanup');
  const a = images.put(jpeg(1, 128), 'image/jpeg');
  const b = images.put(jpeg(2, 128), 'image/jpeg');
  const c = images.put(jpeg(3, 128), 'image/jpeg');
  assert.strictEqual(images.cleanup([a.imageId]), 0,
    '刚落盘的图还没被会话引用，宽限期内删掉就是删正在提交的数据');
  assert.strictEqual(images.cleanup([a.imageId], { graceMs: 0 }), 2);
  assert.deepStrictEqual(fs.readdirSync(imageDir(dir)), [`${a.imageId}.jpg`]);
  assert.ok(images.read(a.imageId));
  assert.strictEqual(images.cleanup([], { graceMs: 0 }), 1);
  assert.strictEqual(images.totalBytes(), 0);
  assert.strictEqual(images.cleanup([], { graceMs: 0 }), 0, '目录空了也不该报错');
  // 白名单里的垃圾值不应意外保住任何文件
  images.put(jpeg(4, 128), 'image/jpeg');
  assert.strictEqual(images.cleanup(['../escape', null, '__proto__'], { graceMs: 0 }), 1);
});

test('ai-images 目录不存在时 totalBytes 与 cleanup 返回零值', () => {
  const { images } = fresh('img-empty');
  assert.strictEqual(images.totalBytes(), 0);
  assert.strictEqual(images.cleanup([]), 0);
});

test('会话里的图像元数据被规范化，非法引用被拒', () => {
  const { sessions, images } = fresh('img-meta');
  const meta = sessions.create({});
  const img = images.put(jpeg(99, 512), 'image/jpeg');
  assert.throws(() => sessions.appendUser(meta.id, {
    text: 'q', images: [{ imageId: '../escape' }]
  }), /会话图像标识无效/);
  assert.throws(() => sessions.appendUser(meta.id, {
    text: 'q', images: [{ imageId: img.imageId, mimeType: 'image/png' }]
  }), /仅支持 JPEG/);
  const stored = sessions.appendUser(meta.id, {
    text: 'q',
    images: [
      { imageId: img.imageId, width: 100, height: 200, bytes: 512, ocrIncluded: true },
      { imageId: img.imageId, width: 100, height: 200, bytes: 512 }
    ]
  });
  assert.strictEqual(stored.images.length, 1, '同一张图重复引用应折成一条');
  assert.deepStrictEqual(stored.images[0], {
    imageId: img.imageId,
    mimeType: 'image/jpeg',
    width: 100,
    height: 200,
    bytes: 512,
    ocrIncluded: true
  });
});

// --- 对账 ---

test('orphanReport 只报书库里已不存在的条目，GLOBAL_ENTRY_ID 永不判为孤立', () => {
  const { sessions } = fresh('orphan');
  const inLib = sessions.create({ entryId: 'e1', title: '在库' });
  const gone = sessions.create({ entryId: 'e404', title: '已删' });
  const global = sessions.create({ entryId: sessions.GLOBAL_ENTRY_ID, title: '全局' });
  round(sessions, gone.id, '问', '答');
  const report = sessions.orphanReport(['e1']);
  assert.deepStrictEqual(report.map((r) => r.sessionId), [gone.id]);
  assert.strictEqual(report[0].entryId, 'e404');
  assert.strictEqual(report[0].title, '已删', '报告要带标题，否则用户无法判断是否回收');
  assert.strictEqual(report[0].messageCount, 2);
  assert.ok(report[0].bytes > 0);
  assert.ok(!report.some((r) => r.sessionId === global.id), '全局会话不绑书籍，永远不是孤立数据');
  assert.ok(!report.some((r) => r.sessionId === inLib.id));
});

test('forgetMany 尊重白名单，且显式点名 GLOBAL_ENTRY_ID 也不删', () => {
  const { sessions } = fresh('forget');
  const keep = sessions.create({ entryId: 'e1', title: '在库' });
  const dropA = sessions.create({ entryId: 'e404', title: '已删甲' });
  const dropB = sessions.create({ entryId: 'e404', title: '已删乙' });
  const global = sessions.create({ entryId: sessions.GLOBAL_ENTRY_ID, title: '全局' });
  assert.strictEqual(sessions.forgetMany([]), 0);
  assert.strictEqual(sessions.forgetMany(['e404', sessions.GLOBAL_ENTRY_ID]), 2);
  const remaining = sessions.list().map((row) => row.id).sort();
  assert.deepStrictEqual(remaining, [keep.id, global.id].sort(),
    '在库条目与全局会话都不该被回收，误删的是用户无法找回的对话');
  assert.throws(() => sessions.forgetMany(['../escape']), /会话条目 ID 无效/);
  assert.strictEqual(sessions.list().length, 2, '非法输入不应造成部分删除');
});

test('rebuildIndex 返回索引形状并与 list 一致', () => {
  const { sessions } = fresh('rebuild');
  const a = sessions.create({ entryId: 'e1', title: '甲' });
  round(sessions, a.id, '问', '答');
  const idx = sessions.rebuildIndex();
  assert.strictEqual(idx.version, 1);
  assert.strictEqual(idx.sessions.length, 1);
  assert.deepStrictEqual(Object.keys(idx.sessions[0]).sort(),
    ['bytes', 'entryId', 'id', 'messageCount', 'pinned', 'title', 'updatedAt'].sort());
  assert.deepStrictEqual(sessions.list()[0], idx.sessions[0]);
});

test('list 返回的是副本，改动不会污染内存索引', () => {
  const { sessions } = fresh('clone');
  const meta = sessions.create({ title: '原标题' });
  const rows = sessions.list();
  rows[0].title = '被改坏';
  assert.strictEqual(sessions.list()[0].title, '原标题');
  assert.strictEqual(sessions.messages(meta.id).meta.title, '原标题');
});