@baique/pi-web-sky 0.1.35 → 0.1.37

package/lib/session-scanner.test.mjs

@@ -0,0 +1,151 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { createJiti } from "jiti";
+
+const jiti = createJiti(import.meta.url);
+const { scanSessionFiles } = await jiti.import("./session-scanner.ts");
+
+function makeRoot() {
+  const root = mkdtempSync(join(tmpdir(), "pi-scan-"));
+  const projDir = join(root, "--home-wa-project-demo--");
+  mkdirSync(projDir, { recursive: true });
+  return { root, projDir };
+}
+
+test("scanSessionFiles：读取 header + 首条用户消息，忽略正文", async () => {
+  const { root, projDir } = makeRoot();
+  try {
+    const file = join(projDir, "2026-01-01T00-00-00-000Z_aaa.jsonl");
+    writeFileSync(file, [
+      '{"type":"session","version":3,"id":"aaa","timestamp":"2026-01-01T00:00:00.000Z","cwd":"/home/wa/project/demo","parentSession":"/x/bbb.jsonl"}',
+      '{"type":"model_change","id":"m1","parentId":null,"provider":"p","modelId":"m","timestamp":"2026-01-01T00:00:01.000Z"}',
+      '{"type":"message","id":"u1","parentId":null,"message":{"role":"user","content":"你好，请帮我看看这个项目"}}',
+      '{"type":"message","id":"a1","parentId":"u1","message":{"role":"assistant","content":[{"type":"text","text":"好的，我看看"}]}}',
+      '{"type":"message","id":"u2","parentId":"a1","message":{"role":"user","content":"再帮我优化一下"}}',
+    ].join("\n") + "\n");
+
+    const result = await scanSessionFiles(root);
+    assert.equal(result.length, 1);
+    const s = result[0];
+    assert.equal(s.id, "aaa");
+    assert.equal(s.cwd, "/home/wa/project/demo");
+    assert.equal(s.firstMessage, "你好，请帮我看看这个项目");
+    assert.equal(s.parentSessionPath, "/x/bbb.jsonl");
+    assert.equal(s.created.toISOString(), "2026-01-01T00:00:00.000Z");
+    assert.ok(s.modified.getTime() > 0);
+    assert.equal(typeof s.name, "undefined");
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("scanSessionFiles：扫描读取最后一个 session_info 的自定义名", async () => {
+  const { root, projDir } = makeRoot();
+  try {
+    const file = join(projDir, "2026-01-01T00-00-00-000Z_bbb.jsonl");
+    writeFileSync(file, [
+      '{"type":"session","version":3,"id":"bbb","timestamp":"2026-01-01T00:00:00.000Z","cwd":"/home/wa/project/demo"}',
+      '{"type":"message","id":"u1","parentId":null,"message":{"role":"user","content":"第一条消息"}}',
+      '{"type":"session_info","id":"s1","parentId":"a1","name":"旧名字","timestamp":"2026-01-01T00:00:05.000Z"}',
+      '{"type":"session_info","id":"s2","parentId":"a1","name":"最终名字","timestamp":"2026-01-01T00:00:06.000Z"}',
+    ].join("\n") + "\n");
+
+    const result = await scanSessionFiles(root);
+    assert.equal(result.length, 1);
+    // 扫描直接读名字（反向分块），取最后一个 session_info。
+    assert.equal(result[0].name, "最终名字");
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("scanSessionFiles：改名后大量新消息把 session_info 推远也能读到（旧 bug 场景）", async () => {
+  const { root, projDir } = makeRoot();
+  try {
+    const file = join(projDir, "2026-01-01T00-00-00-000Z_far.jsonl");
+    const lines = [
+      '{"type":"session","version":3,"id":"far","timestamp":"2026-01-01T00:00:00.000Z","cwd":"/home/wa/project/demo"}',
+      '{"type":"session_info","id":"s1","parentId":"a1","name":"深藏的名字","timestamp":"2026-01-01T00:00:05.000Z"}',
+    ];
+    const filler = "x".repeat(1024);
+    for (let i = 0; i < 200; i++) {
+      lines.push(`{"type":"message","id":"m${i}","parentId":"p","message":{"role":"assistant","content":"${filler}"}}`);
+    }
+    writeFileSync(file, lines.join("\n") + "\n");
+
+    const result = await scanSessionFiles(root);
+    assert.equal(result.length, 1);
+    assert.equal(result[0].name, "深藏的名字");
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("scanSessionFiles：非会话文件（首行不是 session）跳过", async () => {
+  const { root, projDir } = makeRoot();
+  try {
+    writeFileSync(join(projDir, "junk.jsonl"), '{"type":"message",...}\n');
+    writeFileSync(join(projDir, "empty.jsonl"), "");
+    const result = await scanSessionFiles(root);
+    assert.equal(result.length, 0);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("scanSessionFiles：超大正文不影响扫描，只取首部简述", async () => {
+  const { root, projDir } = makeRoot();
+  try {
+    const file = join(projDir, "2026-01-01T00-00-00-000Z_ccc.jsonl");
+    // 中间故意放一个巨大的 assistant 消息（模拟大会话文件）。
+    const hugeText = "x".repeat(1024 * 1024);
+    writeFileSync(file, [
+      '{"type":"session","version":3,"id":"ccc","timestamp":"2026-01-01T00:00:00.000Z","cwd":"/home/wa/project/demo"}',
+      '{"type":"message","id":"u1","parentId":null,"message":{"role":"user","content":"帮我写一篇文章"}}',
+      `{"type":"message","id":"a1","parentId":"u1","message":{"role":"assistant","content":[{"type":"text","text":"${hugeText}"}]}}`,
+      '{"type":"message","id":"u2","parentId":"a1","message":{"role":"user","content":"再改改"}}',
+    ].join("\n") + "\n");
+
+    const t0 = Date.now();
+    const result = await scanSessionFiles(root);
+    const elapsed = Date.now() - t0;
+    assert.equal(result.length, 1);
+    assert.equal(result[0].id, "ccc");
+    assert.equal(result[0].firstMessage, "帮我写一篇文章");
+    assert.ok(elapsed < 2000, `大文件扫描应远快于读全量（实际 ${elapsed}ms）`);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("scanSessionFiles：按 modified（文件 mtime）降序排序", async () => {
+  const { root, projDir } = makeRoot();
+  try {
+    const old = join(projDir, "2026-01-01T00-00-00-000Z_old.jsonl");
+    const fresh = join(projDir, "2026-01-02T00-00-00-000Z_new.jsonl");
+    writeFileSync(old, '{"type":"session","version":3,"id":"old","timestamp":"2026-01-01T00:00:00.000Z","cwd":"/home/wa/project/demo"}\n');
+    // 新文件 mtime 更新。
+    await new Promise((resolve) => setTimeout(resolve, 30));
+    writeFileSync(fresh, '{"type":"session","version":3,"id":"new","timestamp":"2026-01-02T00:00:00.000Z","cwd":"/home/wa/project/demo"}\n');
+
+    const result = await scanSessionFiles(root);
+    assert.deepEqual(result.map((s) => s.id), ["new", "old"]);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("scanSessionFiles：缺失 timestamp 的 header 用 mtime 兜底", async () => {
+  const { root, projDir } = makeRoot();
+  try {
+    writeFileSync(join(projDir, "2026-01-01T00-00-00-000Z_noTs.jsonl"), '{"type":"session","version":3,"id":"noTs","cwd":"/home/wa/project/demo"}\n');
+    const result = await scanSessionFiles(root);
+    assert.equal(result.length, 1);
+    assert.ok(Number.isFinite(result[0].created.getTime()), "created 不可为 Invalid Date");
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});

package/lib/session-scanner.ts

@@ -0,0 +1,238 @@
+import { closeSync, openSync, readSync, statSync } from "fs";
+import { readdir } from "fs/promises";
+import { join as joinPath } from "path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+
+/**
+ * 轻量会话列表扫描：只读取每个 jsonl 的「头部」（session header + 首条用户
+ * 消息简述）和「尾部」（自定义名 session_info，反向分块读），中间内容一律
+ * 不读，最后活动时间直接用文件 mtime。列表展示只需要标题 + 时间 + 名字。
+ */
+
+interface HeaderEntry {
+  type: "session";
+  id?: unknown;
+  cwd?: unknown;
+  timestamp?: unknown;
+  parentSession?: unknown;
+}
+
+export interface SessionScanResult {
+  path: string;
+  id: string;
+  cwd: string;
+  name?: string;
+  created: Date;
+  modified: Date;
+  firstMessage: string;
+  /** 最后一条 assistant 回复文本（截断），无则为空串 */
+  lastReply: string;
+  parentSessionPath?: string;
+}
+
+// 初始读块：前几条 entry（header + 首条用户消息）通常远小于此；
+// 不足时再按需扩读，直到拿到首条消息或达到上限。
+const HEAD_INITIAL_BYTES = 4 * 1024;
+const HEAD_MAX_BYTES = 48 * 1024;
+// 列表里的首条消息只做简述展示（sidebar 也只截取前 50 字符）。
+const FIRST_MESSAGE_PREVIEW_LENGTH = 300;
+
+function parseLine(line: string): unknown {
+  if (!line.trim()) return null;
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
+}
+
+function extractTextContent(message: { content?: unknown }): string {
+  const content = message.content;
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content
+    .filter((block) => block && block.type === "text" && typeof block.text === "string")
+    .map((block) => block.text)
+    .join(" ");
+}
+
+/**
+ * 读取文件头部：拿 header + 首条用户消息。
+ * 策略：先读小块（4KB），解析完整行；若首条消息已拿到则停；若块尾行
+ * 不完整（可能被截断），或还没拿到首条消息，则扩大读取继续。
+ * 首行必须是 session 头，否则视为非本应用会话文件。
+ */
+function scanHead(path: string, size: number): { header: HeaderEntry; firstMessage: string } | null {
+  let readLen = Math.min(HEAD_INITIAL_BYTES, size);
+  let text = "";
+  const fd = openSync(path, "r");
+  try {
+    let header: HeaderEntry | null = null;
+    let firstMessage = "";
+
+    while (true) {
+      const buf = Buffer.alloc(readLen);
+      readSync(fd, buf, 0, readLen, 0);
+      const chunk = buf.toString("utf8");
+      // 块尾可能是半行：丢到最后完整换行处，避免解析半行。
+      const lastNl = chunk.lastIndexOf("\n");
+      const end = lastNl === -1 ? chunk.length : lastNl + 1;
+      text += chunk.slice(0, end);
+
+      for (const line of text.split("\n")) {
+        const entry = parseLine(line) as
+          | HeaderEntry
+          | { type?: unknown; message?: { role?: unknown; content?: unknown } }
+          | null;
+        if (!entry) continue;
+        if (!header) {
+          // 首条 entry 必须是 session 头，否则不是本应用的会话文件。
+          if (entry.type !== "session") return null;
+          header = entry as HeaderEntry;
+          continue;
+        }
+        if (entry.type === "message" && entry.message?.role === "user") {
+          const msgText = extractTextContent(entry.message).trim();
+          if (msgText) {
+            firstMessage = msgText.slice(0, FIRST_MESSAGE_PREVIEW_LENGTH);
+            break;
+          }
+        }
+      }
+
+      if (!header) return null;
+      if (firstMessage) break; // 已拿到首条消息，收工。
+
+      // 还没拿到首条消息：已读满上限或已到文件尾则放弃；否则扩读。
+      if (readLen >= HEAD_MAX_BYTES || readLen >= size) break;
+      readLen = Math.min(readLen * 2, HEAD_MAX_BYTES, size);
+      if (readLen <= 0) break;
+    }
+    return { header, firstMessage };
+  } finally {
+    closeSync(fd);
+  }
+}
+
+// 从文件末尾向前翻的块大小与上限。反向分块：session_info 是 append 写入的，
+// 改名后继续聊会被推到更靠前的位置；从尾部向前找最后一个 session_info
+// 与 SDK getSessionName 语义一致，且大多数会话第一块就命中（改名后没怎么聊）。
+const NAME_BLOCK_BYTES = 64 * 1024;
+const NAME_MAX_BLOCKS = 256; // 约 16MB，超出视为无名字
+
+/** 读取文件尾部：最后一个 session_info 的自定义名 + 最后一条 assistant 回复。
+ *  同一趟反向分块里同时取两样：名字（显式清空 → undefined）、
+ *  lastReply（最后一个 text 块，完整不截断）。返回 { name, lastReply }。 */
+function scanTail(
+  path: string,
+  size: number,
+): { name: string | undefined; lastReply: string } {
+  const result: { name: string | undefined; lastReply: string } = { name: undefined, lastReply: "" };
+  if (size <= 0) return result;
+  const fd = openSync(path, "r");
+  try {
+    let offset = size;
+    for (let block = 0; block < NAME_MAX_BLOCKS && offset > 0; block++) {
+      const start = Math.max(0, offset - NAME_BLOCK_BYTES);
+      const len = offset - start;
+      const buf = Buffer.alloc(len);
+      readSync(fd, buf, 0, len, start);
+      const text = buf.toString("utf8");
+      const lines = text.split("\n");
+      // 块首可能截断一行（前一行的后半），跳过第一行；块尾对齐 offset 完整。
+      // 从后往前找本块内最后一个 session_info 与最后一条 assistant 回复。
+      for (let i = lines.length - 1; i >= 1; i--) {
+        if (result.name !== undefined && result.lastReply) continue;
+        const entry = parseLine(lines[i]) as
+          | { type?: string; name?: unknown; message?: { role?: unknown; content?: unknown } }
+          | null;
+        if (!entry) continue;
+        if (result.name === undefined && entry.type === "session_info" && typeof entry.name === "string") {
+          const name = entry.name.trim();
+          if (name) result.name = name; // 显式清空 → undefined
+        } else if (!result.lastReply && entry.type === "message" && entry.message?.role === "assistant") {
+          const reply = extractTextContent(entry.message).trim();
+          // 不截断：收合卡完整展示最后一条消息（跨 64KB 块的超大回复仍可能缺块首，极端场景）
+          if (reply) result.lastReply = reply;
+        }
+        if (result.name !== undefined && result.lastReply) break; // 两个都拿到，收工
+      }
+      offset = start;
+    }
+    return result;
+  } finally {
+    closeSync(fd);
+  }
+}
+
+function scanOneSessionFile(path: string): SessionScanResult | null {
+  let stat;
+  try {
+    stat = statSync(path);
+  } catch {
+    return null;
+  }
+  if (!stat.isFile() || stat.size === 0) return null;
+
+  const scanned = scanHead(path, stat.size);
+  if (!scanned) return null;
+  const { header, firstMessage } = scanned;
+
+  const id = typeof header.id === "string" ? header.id : "";
+  if (!id) return null;
+  const created = new Date(typeof header.timestamp === "string" ? header.timestamp : "");
+  if (Number.isNaN(created.getTime())) created.setTime(stat.mtime.getTime());
+
+  const tail = scanTail(path, stat.size);
+
+  return {
+    path,
+    id,
+    cwd: typeof header.cwd === "string" ? header.cwd : "",
+    name: tail.name,
+    created,
+    modified: stat.mtime,
+    firstMessage: firstMessage || "(no messages)",
+    lastReply: tail.lastReply,
+    parentSessionPath: typeof header.parentSession === "string" ? header.parentSession : undefined,
+  };
+}
+
+/**
+ * 扫描 <agentDir>/sessions 下所有 jsonl。同步小 IO 串行即可（单文件只读
+ * 头部小块 + 尾部反向分块），`sessionsDir` 仅在测试时注入。
+ */
+export async function scanSessionFiles(sessionsDir?: string): Promise<SessionScanResult[]> {
+  const root = sessionsDir ?? joinPath(getAgentDir(), "sessions");
+  let projectDirs: string[];
+  try {
+    const entries = await readdir(root, { withFileTypes: true });
+    projectDirs = entries
+      .filter((entry) => entry.isDirectory() || entry.isSymbolicLink())
+      .map((entry) => joinPath(root, entry.name));
+  } catch {
+    return [];
+  }
+
+  const files: string[] = [];
+  for (const dir of projectDirs) {
+    try {
+      for (const name of await readdir(dir)) {
+        if (name.endsWith(".jsonl")) files.push(joinPath(dir, name));
+      }
+    } catch {
+      // 单目录不可读则跳过，不影响其它目录。
+    }
+  }
+
+  const results: SessionScanResult[] = [];
+  for (const file of files) {
+    const scanned = scanOneSessionFile(file);
+    if (scanned) results.push(scanned);
+  }
+  results.sort((a, b) => b.modified.getTime() - a.modified.getTime());
+  return results;
+}
+
+// 以对象形式暴露扫描入口，测试可替换实现（ESM 的模块绑定本身只读）。
+export const sessionScanner = { scan: scanSessionFiles };

package/lib/session-search.test.mjs

@@ -0,0 +1,173 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { createJiti } from "jiti";
+
+const jiti = createJiti(import.meta.url, { interopDefault: true, moduleCache: false });
+const { setDbForTesting } = await jiti.import("./sqlite-db.ts");
+const { extractSessionText, ensureSearchIndex, searchSessions, fuzzyQueryForTerm } =
+  await jiti.import("./session-search.ts");
+
+function freshDb() {
+  setDbForTesting(new DatabaseSync(":memory:"));
+}
+
+function makeSession(id, path, opts = {}) {
+  return {
+    path,
+    id,
+    cwd: "/tmp/proj",
+    name: opts.name,
+    created: "2026-08-27T00:00:00.000Z",
+    modified: opts.modified ?? "2026-08-27T01:00:00.000Z",
+    messageCount: 1,
+    firstMessage: opts.firstMessage ?? "",
+  };
+}
+
+const SAMPLE_LINES = [
+  '{"type":"session","version":3,"id":"s1","timestamp":"2026-08-27T00:00:00.000Z","cwd":"/tmp/proj"}',
+  '{"type":"message","id":"u1","parentId":null,"timestamp":"2026-08-27T00:00:01.000Z","message":{"role":"user","content":"修复登录接口的 bug"}}',
+  '{"type":"message","id":"a1","parentId":"u1","timestamp":"2026-08-27T00:00:02.000Z","message":{"role":"assistant","content":[{"type":"text","text":"我先改了 Token 逻辑"},{"type":"toolCall","id":"tc1","toolName":"read","input":{"path":"a.ts"}}]}}',
+  '{"type":"message","id":"r1","parentId":"a1","timestamp":"2026-08-27T00:00:03.000Z","message":{"role":"toolResult","toolCallId":"tc1","content":[{"type":"text","text":"文件内容 ok"},{"type":"image","source":{"type":"base64","data":"QUFBQUFBQUFB"}}]}}',
+  '{"type":"message","id":"b1","parentId":"r1","timestamp":"2026-08-27T00:00:04.000Z","message":{"role":"bashExecution","command":"npm test","output":"12 passed","excludeFromContext":true}}',
+  '{"type":"compaction","id":"c1","parentId":"b1","timestamp":"2026-08-27T00:00:05.000Z","summary":"跳过早期讨论","firstKeptEntryId":"u1","tokensBefore":100}',
+];
+
+function fixtureDir(files) {
+  const dir = mkdtempSync(join(tmpdir(), "pi-search-test-"));
+  for (const [name, lines] of Object.entries(files)) {
+    writeFileSync(join(dir, name), lines.join("\n"));
+  }
+  return dir;
+}
+
+test("extractSessionText pulls title, messages, tools, bash, compaction; skips base64", () => {
+  const dir = fixtureDir({ "s1.jsonl": SAMPLE_LINES });
+  try {
+    const { title, body } = extractSessionText(makeSession("s1", join(dir, "s1.jsonl"), { name: "登录重构" }));
+    assert.equal(title, "登录重构");
+    assert.ok(body.includes("修复登录接口"), "user message");
+    assert.ok(body.includes("Token 逻辑"), "assistant text");
+    assert.ok(body.includes("[tool:read]"), "tool call name");
+    assert.ok(body.includes('"path":"a.ts"'), "tool call input");
+    assert.ok(body.includes("npm test"), "bash command");
+    assert.ok(body.includes("12 passed"), "bash output");
+    assert.ok(body.includes("跳过早期讨论"), "compaction summary");
+    assert.ok(!body.includes("QUFBQUFBQUFB"), "base64 image data must be dropped");
+    assert.ok(!body.includes("[image]"), "toolResult images must be omitted");
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("ensureSearchIndex re-indexes on mtime change, drops vanished sessions", async () => {
+  freshDb();
+  const dir = fixtureDir({ "s1.jsonl": SAMPLE_LINES });
+  try {
+    const session = makeSession("s1", join(dir, "s1.jsonl"), { name: "登录重构" });
+    const first = await ensureSearchIndex([session]);
+    assert.equal(first.indexing, true);
+    const again = await ensureSearchIndex([session]);
+    assert.equal(again.indexing, false, "unchanged mtime must be a no-op");
+
+    const modified = { ...session, modified: "2026-08-27T02:00:00.000Z" };
+    const reindexed = await ensureSearchIndex([modified]);
+    assert.equal(reindexed.indexing, true, "mtime change must re-index");
+
+    const dropped = await ensureSearchIndex([]);
+    assert.equal(dropped.indexing, true);
+    const { results } = await searchSessions("登录接口", 10, []);
+    assert.equal(results.length, 0, "index must drop vanished sessions");
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("searchSessions matches Chinese substring, 2-char LIKE fallback, English, titleMatch", async () => {
+  freshDb();
+  const dir = fixtureDir({ "s1.jsonl": SAMPLE_LINES });
+  try {
+    const s1 = makeSession("s1", join(dir, "s1.jsonl"), { name: "登录重构" });
+    const s2 = {
+      ...makeSession("s2", join(dir, "missing.jsonl"), {}),
+      name: "SQLite FTS index",
+    };
+    const sessions = [s1, s2];
+
+    // 4-char Chinese substring in body — title "登录重构" does NOT contain it,
+    // so this is a pure body hit.
+    const { results: m1 } = await searchSessions("登录接口", 10, sessions);
+    assert.deepEqual(m1.map((r) => r.session.id), ["s1"]);
+    assert.equal(m1[0].titleMatch, false);
+    assert.ok(m1[0].snippet.length > 0, "snippet should carry highlight markers");
+
+    // Title-hitting 4-char query sets titleMatch.
+    const { results: mTitle } = await searchSessions("登录重构", 10, sessions);
+    assert.deepEqual(mTitle.map((r) => r.session.id), ["s1"]);
+    assert.equal(mTitle[0].titleMatch, true);
+
+    // 2-char Chinese query — MATCH misses, LIKE fallback hits.
+    const { results: m2 } = await searchSessions("登录", 10, sessions);
+    assert.deepEqual(m2.map((r) => r.session.id), ["s1"]);
+
+    // English word.
+    const { results: m3 } = await searchSessions("fts", 10, sessions);
+    assert.deepEqual(m3.map((r) => r.session.id), ["s2"]);
+    assert.equal(m3[0].titleMatch, true);
+
+    // No results.
+    const { results: none } = await searchSessions("不存在的词xyz", 10, sessions);
+    assert.equal(none.length, 0);
+
+    // Quoted/special chars must not throw.
+    const { results: safe } = await searchSessions('a"b', 10, sessions);
+    assert.equal(safe.length, 0);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("searchSessions 多关键字空格分隔 AND（FTS 与 LIKE 回退）", async () => {
+  freshDb();
+  const dir = fixtureDir({ "s1.jsonl": SAMPLE_LINES });
+  try {
+    const s1 = makeSession("s1", join(dir, "s1.jsonl"), { name: "登录重构" });
+    const s2 = {
+      ...makeSession("s2", join(dir, "missing.jsonl"), {}),
+      name: "SQLite FTS index",
+    };
+    const sessions = [s1, s2];
+
+    // FTS 路径（两词均 ≥3 字符，且都在 s1 body 命中）："登录接口 token" → s1
+    const { results: fts } = await searchSessions("登录接口 token", 10, sessions);
+    assert.deepEqual(fts.map((r) => r.session.id), ["s1"], "FTS 多词 AND");
+
+    // LIKE 回退（含 2 字符词）title 命中："登录 重构" → s1（title="登录重构"）
+    const { results: likeTitle } = await searchSessions("登录 重构", 10, sessions);
+    assert.deepEqual(likeTitle.map((r) => r.session.id), ["s1"], "LIKE 回退多词 AND title");
+    assert.equal(likeTitle[0].titleMatch, true);
+
+    // LIKE 回退 body 场景："登录 token" → s1（body 含两词）
+    const { results: likeBody } = await searchSessions("登录 token", 10, sessions);
+    assert.deepEqual(likeBody.map((r) => r.session.id), ["s1"], "LIKE 回退多词 AND body");
+
+    // 缺任一词不命中：s1 无 "不存在词xyz"
+    const { results: miss } = await searchSessions("登录接口 不存在词xyz", 10, sessions);
+    assert.equal(miss.length, 0, "缺一词不命中");
+
+    // 多空格/首尾空格容忍
+    const { results: spaced } = await searchSessions("  登录  token  ", 10, sessions);
+    assert.deepEqual(spaced.map((r) => r.session.id), ["s1"], "多空格容忍");
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("fuzzyQueryForTerm escapes quotes into an FTS phrase", () => {
+  assert.equal(fuzzyQueryForTerm('a"b'), '"a""b"');
+  assert.equal(fuzzyQueryForTerm("登录"), '"登录"');
+});