nlm-memory 0.5.0 → 0.5.1

package/tests/unit/core/adapters/windsurf.test.ts

@@ -1,416 +0,0 @@
-/**
- * WindsurfAdapter unit tests.
- *
- * Each test builds a fake Windsurf workspaceStorage directory tree with
- * in-memory SQLite DBs written to temp files so the adapter can open them
- * in readonly mode.
- */
-
-import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import Database from "better-sqlite3";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { WindsurfAdapter } from "../../../../src/core/adapters/windsurf.js";
-
-// ── Schema helpers ────────────────────────────────────────────────────────────
-
-const CHAT_KEY = "workbench.panel.aichat.view.aichat.chatdata";
-
-function createWorkspaceDb(dbPath: string): Database.Database {
-  const db = new Database(dbPath);
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS ItemTable (
-      key   TEXT PRIMARY KEY,
-      value TEXT
-    );
-  `);
-  return db;
-}
-
-interface Bubble {
-  type: "user" | "ai";
-  text?: string;
-  rawText?: string;
-}
-
-interface Tab {
-  tabId: string;
-  chatTitle?: string;
-  lastSendTime?: number;
-  bubbles?: Bubble[];
-}
-
-function writeChatData(db: Database.Database, tabs: Tab[]): void {
-  db.prepare(`INSERT OR REPLACE INTO ItemTable (key, value) VALUES (?, ?)`).run(
-    CHAT_KEY,
-    JSON.stringify({ tabs }),
-  );
-}
-
-// ── Fixtures ──────────────────────────────────────────────────────────────────
-
-let tmp: string;
-let userDir: string;
-let wsStorageDir: string;
-let adapter: WindsurfAdapter;
-
-beforeEach(() => {
-  tmp = mkdtempSync(join(tmpdir(), "nlm-windsurf-"));
-  userDir = join(tmp, "Windsurf", "User");
-  wsStorageDir = join(userDir, "workspaceStorage");
-  mkdirSync(wsStorageDir, { recursive: true });
-  adapter = new WindsurfAdapter({ userDir });
-});
-
-afterEach(() => {
-  rmSync(tmp, { recursive: true, force: true });
-});
-
-function addWorkspace(name: string, tabs: Tab[]): string {
-  const wsDir = join(wsStorageDir, name);
-  mkdirSync(wsDir, { recursive: true });
-  const dbPath = join(wsDir, "state.vscdb");
-  const db = createWorkspaceDb(dbPath);
-  writeChatData(db, tabs);
-  db.close();
-  return dbPath;
-}
-
-// ── detect() ─────────────────────────────────────────────────────────────────
-
-describe("detect()", () => {
-  it("returns enabled when userDir exists", () => {
-    const result = adapter.detect();
-    expect(result.enabled).toBe(true);
-    expect(result.path).toBe(userDir);
-    expect(result.hint).toBeNull();
-  });
-
-  it("returns disabled when userDir is absent", () => {
-    const noDir = new WindsurfAdapter({ userDir: join(tmp, "nonexistent") });
-    const result = noDir.detect();
-    expect(result.enabled).toBe(false);
-    expect(result.path).toBeNull();
-    expect(result.hint).toMatch(/Windsurf/);
-  });
-});
-
-// ── discover() ───────────────────────────────────────────────────────────────
-
-describe("discover()", () => {
-  it("returns empty array when workspaceStorage has no DBs", async () => {
-    expect(await adapter.discover()).toEqual([]);
-  });
-
-  it("returns prefixed tabIds across workspace DBs", async () => {
-    addWorkspace("ws1", [
-      { tabId: "tab-aaa", bubbles: [{ type: "user", text: "Hello" }] },
-    ]);
-    addWorkspace("ws2", [
-      { tabId: "tab-bbb", bubbles: [{ type: "user", text: "Hi" }] },
-      { tabId: "tab-ccc", bubbles: [{ type: "ai", text: "Bye" }] },
-    ]);
-
-    const ids = await adapter.discover();
-    expect(ids.sort()).toEqual(["ws_tab-aaa", "ws_tab-bbb", "ws_tab-ccc"].sort());
-  });
-
-  it("skips tabs with no bubbles", async () => {
-    addWorkspace("ws1", [
-      { tabId: "empty-tab", bubbles: [] },
-      { tabId: "good-tab", bubbles: [{ type: "user", text: "Hello" }] },
-    ]);
-
-    const ids = await adapter.discover();
-    expect(ids).toEqual(["ws_good-tab"]);
-  });
-
-  it("deduplicates tabIds appearing in multiple workspaces", async () => {
-    // Edge case: same tab ID in two workspace DBs (migration artifact)
-    addWorkspace("ws1", [{ tabId: "dup-tab", bubbles: [{ type: "user", text: "A" }] }]);
-    addWorkspace("ws2", [{ tabId: "dup-tab", bubbles: [{ type: "user", text: "B" }] }]);
-
-    const ids = await adapter.discover();
-    expect(ids.filter((id) => id === "ws_dup-tab").length).toBe(1);
-  });
-
-  it("filters by since using lastSendTime", async () => {
-    const old = Date.now() - 10 * 24 * 3600_000;
-    const recent = Date.now();
-    addWorkspace("ws1", [
-      { tabId: "old-tab", lastSendTime: old, bubbles: [{ type: "user", text: "Old" }] },
-      { tabId: "new-tab", lastSendTime: recent, bubbles: [{ type: "user", text: "New" }] },
-    ]);
-
-    const cutoff = new Date(Date.now() - 5 * 24 * 3600_000);
-    const ids = await adapter.discover({ since: cutoff });
-    expect(ids).toEqual(["ws_new-tab"]);
-  });
-
-  it("includes tab with lastSendTime=0 even when since is set (zero means unknown age)", async () => {
-    addWorkspace("ws1", [
-      { tabId: "zero-ts-tab", lastSendTime: 0, bubbles: [{ type: "user", text: "Hi" }] },
-    ]);
-
-    const cutoff = new Date(); // very recent cutoff that would exclude everything with a real ts
-    const ids = await adapter.discover({ since: cutoff });
-    expect(ids).toContain("ws_zero-ts-tab");
-  });
-});
-
-// ── parseSession() ────────────────────────────────────────────────────────────
-
-describe("parseSession()", () => {
-  it("returns null for unknown tabId", async () => {
-    addWorkspace("ws1", [{ tabId: "real-tab", bubbles: [{ type: "user", text: "Hello" }] }]);
-    expect(await adapter.parseSession("ghost-tab")).toBeNull();
-  });
-
-  it("returns null for tab with no usable bubbles", async () => {
-    addWorkspace("ws1", [{ tabId: "empty-tab", bubbles: [] }]);
-    expect(await adapter.parseSession("empty-tab")).toBeNull();
-  });
-
-  it("extracts user and assistant turns", async () => {
-    addWorkspace("ws1", [
-      {
-        tabId: "chat-tab",
-        chatTitle: "My chat",
-        bubbles: [
-          { type: "user", text: "Hello AI" },
-          { type: "ai", rawText: "Hi human" },
-        ],
-      },
-    ]);
-
-    const chunk = await adapter.parseSession("chat-tab");
-    expect(chunk).not.toBeNull();
-    expect(chunk!.turnCount).toBe(2);
-    expect(chunk!.text).toContain("user: Hello AI");
-    expect(chunk!.text).toContain("assistant: Hi human");
-  });
-
-  it("prefers rawText over text for bubble content", async () => {
-    addWorkspace("ws1", [
-      {
-        tabId: "rawtext-tab",
-        bubbles: [
-          { type: "user", rawText: "Raw question", text: "text version" },
-        ],
-      },
-    ]);
-
-    const chunk = await adapter.parseSession("rawtext-tab");
-    expect(chunk!.text).toContain("Raw question");
-    expect(chunk!.text).not.toContain("text version");
-  });
-
-  it("uses chatTitle as label", async () => {
-    addWorkspace("ws1", [
-      {
-        tabId: "titled-tab",
-        chatTitle: "Refactoring session",
-        bubbles: [{ type: "user", text: "Let's refactor" }],
-      },
-    ]);
-
-    const chunk = await adapter.parseSession("titled-tab");
-    expect(chunk!.label).toBe("Refactoring session");
-  });
-
-  it("falls back to first user turn as label when chatTitle is absent", async () => {
-    addWorkspace("ws1", [
-      {
-        tabId: "notitle-tab",
-        bubbles: [{ type: "user", text: "What is a monad?" }],
-      },
-    ]);
-
-    const chunk = await adapter.parseSession("notitle-tab");
-    expect(chunk!.label).toBe("What is a monad?");
-  });
-
-  it("sets correct id prefix and runtimeSessionId", async () => {
-    addWorkspace("ws1", [
-      { tabId: "id-check", bubbles: [{ type: "user", text: "Hello" }] },
-    ]);
-
-    const chunk = await adapter.parseSession("id-check");
-    expect(chunk!.runtimeSessionId).toBe("id-check");
-    expect(chunk!.id).toMatch(/^ws_/);
-  });
-
-  it("sets sourcePath to dbPath::tabId", async () => {
-    const dbPath = addWorkspace("ws1", [
-      { tabId: "path-tab", bubbles: [{ type: "user", text: "Hello" }] },
-    ]);
-
-    const chunk = await adapter.parseSession("path-tab");
-    expect(chunk!.sourcePath).toBe(`${dbPath}::path-tab`);
-  });
-
-  it("finds tab in second workspace when not in first", async () => {
-    addWorkspace("ws1", [{ tabId: "tab-ws1", bubbles: [{ type: "user", text: "In ws1" }] }]);
-    addWorkspace("ws2", [{ tabId: "tab-ws2", bubbles: [{ type: "user", text: "In ws2" }] }]);
-
-    const chunk = await adapter.parseSession("tab-ws2");
-    expect(chunk).not.toBeNull();
-    expect(chunk!.text).toContain("In ws2");
-  });
-
-  it("skips bubbles with empty text", async () => {
-    addWorkspace("ws1", [
-      {
-        tabId: "sparse-tab",
-        bubbles: [
-          { type: "user", text: "" },
-          { type: "user", text: "Real question" },
-          { type: "ai", text: "Real answer" },
-        ],
-      },
-    ]);
-
-    const chunk = await adapter.parseSession("sparse-tab");
-    expect(chunk!.turnCount).toBe(2);
-  });
-
-  it("populates byteRange[1] equal to transcript byte length", async () => {
-    addWorkspace("ws1", [
-      {
-        tabId: "bytes-tab",
-        bubbles: [
-          { type: "user", text: "Hello" },
-          { type: "ai", text: "Hi" },
-        ],
-      },
-    ]);
-
-    const chunk = await adapter.parseSession("bytes-tab");
-    expect(chunk!.byteRange[1]).toBe(Buffer.byteLength(chunk!.text, "utf8"));
-  });
-});
-
-// ── global DB agent sessions (wsg_) ──────────────────────────────────────────
-
-describe("global DB agent sessions (wsg_)", () => {
-  let globalDb: Database.Database;
-  let globalDbPath: string;
-
-  beforeEach(() => {
-    const globalDir = join(userDir, "globalStorage");
-    mkdirSync(globalDir, { recursive: true });
-    globalDbPath = join(globalDir, "state.vscdb");
-    globalDb = new Database(globalDbPath);
-  });
-
-  afterEach(() => {
-    try { globalDb.close(); } catch { /* already closed */ }
-  });
-
-  function addCursorDiskKVSession(
-    composerId: string,
-    opts: { name?: string; createdAt?: string; lastUpdatedAt?: string; conversation?: Array<{ type?: number; role?: string; text: string }> } = {},
-  ): void {
-    globalDb.exec(`CREATE TABLE IF NOT EXISTS cursorDiskKV (key TEXT PRIMARY KEY, value TEXT);`);
-    const data = {
-      composerId,
-      name: opts.name,
-      createdAt: opts.createdAt ?? new Date(Date.now() - 3600_000).toISOString(),
-      lastUpdatedAt: opts.lastUpdatedAt ?? new Date().toISOString(),
-      conversation: opts.conversation ?? [],
-    };
-    globalDb.prepare(`INSERT INTO cursorDiskKV (key, value) VALUES (?, ?)`).run(
-      `composerData:${composerId}`,
-      JSON.stringify(data),
-    );
-    globalDb.close();
-  }
-
-  function addItemTableSession(
-    composerId: string,
-    opts: { name?: string; conversation?: Array<{ type?: number; role?: string; text: string }> } = {},
-  ): void {
-    globalDb.exec(`CREATE TABLE IF NOT EXISTS ItemTable (key TEXT PRIMARY KEY, value TEXT);`);
-    const data = {
-      composerId,
-      name: opts.name,
-      conversation: opts.conversation ?? [],
-    };
-    // Use an agent-style key so the fallback LIKE query matches
-    globalDb.prepare(`INSERT INTO ItemTable (key, value) VALUES (?, ?)`).run(
-      `cascade:${composerId}`,
-      JSON.stringify(data),
-    );
-    globalDb.close();
-  }
-
-  it("discover() returns wsg_ ids from cursorDiskKV global sessions", async () => {
-    addCursorDiskKVSession("agent-aaa", {
-      conversation: [{ type: 1, text: "Hello" }],
-    });
-
-    const ids = await adapter.discover();
-    expect(ids).toContain("wsg_agent-aaa");
-  });
-
-  it("discover() returns wsg_ ids from ItemTable fallback", async () => {
-    addItemTableSession("flow-bbb", {
-      conversation: [{ role: "user", text: "Hi" }],
-    });
-
-    const ids = await adapter.discover();
-    expect(ids).toContain("wsg_flow-bbb");
-  });
-
-  it("parseSession(wsg_<id>) extracts turns via cursorDiskKV", async () => {
-    addCursorDiskKVSession("agent-parse", {
-      name: "My flow",
-      conversation: [
-        { type: 1, text: "Build a widget" },
-        { type: 2, text: "Built!" },
-      ],
-    });
-
-    const chunk = await adapter.parseSession("wsg_agent-parse");
-    expect(chunk).not.toBeNull();
-    expect(chunk!.turnCount).toBe(2);
-    expect(chunk!.text).toContain("user: Build a widget");
-    expect(chunk!.text).toContain("assistant: Built!");
-    expect(chunk!.label).toBe("My flow");
-    expect(chunk!.id).toMatch(/^wsg_/);
-    expect(chunk!.runtimeSessionId).toBe("agent-parse");
-  });
-
-  it("parseSession(wsg_<id>) returns null when conversation is empty", async () => {
-    addCursorDiskKVSession("empty-agent", { conversation: [] });
-    expect(await adapter.parseSession("wsg_empty-agent")).toBeNull();
-  });
-
-  it("discover() wsg_ filters by since using lastUpdatedAt", async () => {
-    const recentDb = new Database(globalDbPath);
-    recentDb.exec(`CREATE TABLE IF NOT EXISTS cursorDiskKV (key TEXT PRIMARY KEY, value TEXT);`);
-    const old = new Date(Date.now() - 10 * 24 * 3600_000).toISOString();
-    const recent = new Date().toISOString();
-    const oldData = { composerId: "old-agent", lastUpdatedAt: old, conversation: [{ type: 1, text: "Old" }] };
-    const newData = { composerId: "new-agent", lastUpdatedAt: recent, conversation: [{ type: 1, text: "New" }] };
-    recentDb.prepare(`INSERT INTO cursorDiskKV (key, value) VALUES (?, ?)`).run("composerData:old-agent", JSON.stringify(oldData));
-    recentDb.prepare(`INSERT INTO cursorDiskKV (key, value) VALUES (?, ?)`).run("composerData:new-agent", JSON.stringify(newData));
-    recentDb.close();
-
-    const cutoff = new Date(Date.now() - 5 * 24 * 3600_000);
-    const ids = await adapter.discover({ since: cutoff });
-    expect(ids).not.toContain("wsg_old-agent");
-    expect(ids).toContain("wsg_new-agent");
-  });
-});
-
-// ── metadata ──────────────────────────────────────────────────────────────────
-
-describe("adapter metadata", () => {
-  it("has correct name, runtimeVersion, and transcriptKind", () => {
-    expect(adapter.name).toBe("windsurf");
-    expect(adapter.runtimeVersion).toBe("windsurf/1.0");
-    expect(adapter.transcriptKind).toBe("windsurf-sqlite");
-  });
-});

package/tests/unit/core/classifier/prompt.test.ts

@@ -1,126 +0,0 @@
-/**
- * coerceClassifyResult — defensive parser over raw LLM JSON output. Focuses
- * on the Phase B.2 facts[] additions; existing fields are covered by the
- * end-to-end OllamaClient tests.
- */
-
-import { describe, expect, it } from "vitest";
-import {
-  CLASSIFIER_SYSTEM_PROMPT,
-  PREDICATE_VOCABULARY,
-  coerceClassifyResult,
-} from "../../../../src/core/classifier/prompt.js";
-
-describe("coerceClassifyResult — facts", () => {
-  function baseFields() {
-    return {
-      label: "L",
-      summary: "S",
-      entities: [],
-      decisions: [],
-      open: [],
-      confidence: 0.8,
-    };
-  }
-
-  it("returns an empty facts array when the key is missing entirely", () => {
-    expect(coerceClassifyResult(baseFields()).facts).toEqual([]);
-  });
-
-  it("returns an empty facts array when facts is not an array", () => {
-    expect(
-      coerceClassifyResult({ ...baseFields(), facts: "not-an-array" }).facts,
-    ).toEqual([]);
-  });
-
-  it("normalizes subject + predicate to lowercase and trims value", () => {
-    const out = coerceClassifyResult({
-      ...baseFields(),
-      facts: [
-        { kind: "decision", subject: "NLM-Memory-TS", predicate: "Framework", value: "  Hono  " },
-      ],
-    });
-    expect(out.facts).toEqual([
-      { kind: "decision", subject: "nlm-memory-ts", predicate: "framework", value: "Hono" },
-    ]);
-  });
-
-  it("drops facts with predicates outside the closed vocabulary (no 'other' escape hatch)", () => {
-    const out = coerceClassifyResult({
-      ...baseFields(),
-      facts: [
-        { kind: "decision", subject: "x", predicate: "color-of-the-bikeshed", value: "blue" },
-        { kind: "decision", subject: "x", predicate: "framework", value: "Hono" },
-      ],
-    });
-    expect(out.facts.map((f) => f.predicate)).toEqual(["framework"]);
-  });
-
-  it("PREDICATE_VOCABULARY does not include 'other'", () => {
-    // Removed in Phase B.5 after pilot showed `other` was 43% of writes and
-    // almost all slop. Off-vocab facts now get dropped by the coercer rather
-    // than forced into a catch-all bucket.
-    expect(PREDICATE_VOCABULARY).not.toContain("other");
-  });
-
-  it("drops facts missing required fields (subject, predicate, value)", () => {
-    const out = coerceClassifyResult({
-      ...baseFields(),
-      facts: [
-        { kind: "decision", subject: "", predicate: "framework", value: "Hono" },
-        { kind: "decision", subject: "x", predicate: "", value: "Hono" },
-        { kind: "decision", subject: "x", predicate: "framework", value: "" },
-        { kind: "decision", subject: "good", predicate: "framework", value: "Hono" },
-      ],
-    });
-    expect(out.facts).toEqual([
-      { kind: "decision", subject: "good", predicate: "framework", value: "Hono" },
-    ]);
-  });
-
-  it("drops facts with an invalid kind", () => {
-    const out = coerceClassifyResult({
-      ...baseFields(),
-      facts: [
-        { kind: "garbage", subject: "x", predicate: "framework", value: "Hono" },
-        { kind: "attribute", subject: "x", predicate: "framework", value: "Hono" },
-      ],
-    });
-    expect(out.facts.map((f) => f.kind)).toEqual(["attribute"]);
-  });
-
-  it("clamps sourceQuote to 500 chars and trims whitespace", () => {
-    const long = " ".repeat(10) + "a".repeat(600) + " ".repeat(10);
-    const out = coerceClassifyResult({
-      ...baseFields(),
-      facts: [
-        { kind: "decision", subject: "x", predicate: "framework", value: "Hono", sourceQuote: long },
-      ],
-    });
-    expect(out.facts[0]?.sourceQuote).toBe("a".repeat(500));
-  });
-
-  it("omits sourceQuote when blank or non-string", () => {
-    const out = coerceClassifyResult({
-      ...baseFields(),
-      facts: [
-        { kind: "decision", subject: "a", predicate: "framework", value: "v", sourceQuote: "   " },
-        { kind: "decision", subject: "b", predicate: "framework", value: "v", sourceQuote: 42 },
-      ],
-    });
-    expect(out.facts[0]?.sourceQuote).toBeUndefined();
-    expect(out.facts[1]?.sourceQuote).toBeUndefined();
-  });
-});
-
-describe("CLASSIFIER_SYSTEM_PROMPT", () => {
-  it("includes the facts field in the requested JSON shape", () => {
-    expect(CLASSIFIER_SYSTEM_PROMPT).toContain('"facts"');
-  });
-
-  it("inlines the predicate vocabulary so the LLM sees the closed list", () => {
-    for (const p of PREDICATE_VOCABULARY) {
-      expect(CLASSIFIER_SYSTEM_PROMPT).toContain(p);
-    }
-  });
-});

package/tests/unit/core/embedding/chunk-body.test.ts

@@ -1,100 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  chunkSessionText,
-  MAX_CHUNK_CHARS,
-  OVERLAP_CHARS,
-} from "../../../../src/core/embedding/chunk-body.js";
-
-describe("chunkSessionText", () => {
-  it("returns empty array when label, summary, and body are all blank", () => {
-    expect(chunkSessionText({})).toEqual([]);
-    expect(chunkSessionText({ label: "", summary: "  ", body: "" })).toEqual([]);
-  });
-
-  it("returns a header-only chunk when body is empty", () => {
-    const chunks = chunkSessionText({ label: "Meeting notes", summary: "Q4 plan" });
-    expect(chunks).toEqual(["Meeting notes Q4 plan"]);
-  });
-
-  it("returns one chunk when header + body fits in maxChars", () => {
-    const chunks = chunkSessionText(
-      { label: "L", summary: "S", body: "hello world" },
-      { maxChars: 100, overlap: 10 },
-    );
-    expect(chunks).toEqual(["L S hello world"]);
-  });
-
-  it("splits body into multiple chunks with overlap when over maxChars", () => {
-    // body 250 chars, maxChars=100, overlap=20, no header → step=80
-    // chunk 0: body[0..100], chunk 1: body[80..180], chunk 2: body[160..250]
-    const body = "x".repeat(250);
-    const chunks = chunkSessionText(
-      { body },
-      { maxChars: 100, overlap: 20 },
-    );
-    expect(chunks).toHaveLength(3);
-    expect(chunks[0]!.length).toBe(100);
-    expect(chunks[1]!.length).toBe(100);
-    expect(chunks[2]!.length).toBe(90);
-  });
-
-  it("preserves overlap content between adjacent chunks", () => {
-    // Recognisable letters so we can confirm the boundary overlaps.
-    const body =
-      "A".repeat(50) +
-      "B".repeat(50) +
-      "C".repeat(50) +
-      "D".repeat(50); // 200 chars
-    const chunks = chunkSessionText(
-      { body },
-      { maxChars: 80, overlap: 20 },
-    );
-    // chunk 0: body[0..80] → AAA...AAA BBB...BBB BB (50 A + 30 B)
-    // chunk 1: body[60..140] → 40 B + 40 C overlapping the last 20 B from chunk 0
-    expect(chunks[0]!.slice(-10)).toBe("B".repeat(10));
-    expect(chunks[1]!.slice(0, 20)).toBe("B".repeat(20)); // overlap
-  });
-
-  it("accounts for header in first-chunk budget", () => {
-    const header = "h".repeat(20);
-    const body = "b".repeat(200);
-    const chunks = chunkSessionText(
-      { label: header, body },
-      { maxChars: 100, overlap: 10 },
-    );
-    // First chunk: 20-char header + space + body[0..79] = 100 chars total
-    // Second chunk: body[69..169] (90 chars body budget - 10 overlap from start of body)
-    expect(chunks[0]!.startsWith(header + " ")).toBe(true);
-    expect(chunks[0]!.length).toBeLessThanOrEqual(100);
-  });
-
-  it("respects defaults (MAX_CHUNK_CHARS, OVERLAP_CHARS) when no opts passed", () => {
-    const body = "y".repeat(MAX_CHUNK_CHARS * 2 + 1000);
-    const chunks = chunkSessionText({ body });
-    expect(chunks.length).toBeGreaterThan(1);
-    for (const c of chunks) {
-      expect(c.length).toBeLessThanOrEqual(MAX_CHUNK_CHARS);
-    }
-    // Overlap default sanity: consecutive chunks should share OVERLAP_CHARS
-    expect(OVERLAP_CHARS).toBeGreaterThan(0);
-  });
-
-  it("throws on invalid options", () => {
-    expect(() => chunkSessionText({ body: "x" }, { maxChars: 0 })).toThrow();
-    expect(() => chunkSessionText({ body: "x" }, { maxChars: 100, overlap: -1 })).toThrow();
-    expect(() => chunkSessionText({ body: "x" }, { maxChars: 100, overlap: 100 })).toThrow();
-  });
-
-  it("trims whitespace at chunk boundaries", () => {
-    const body = "alpha   " + "z".repeat(200);
-    const chunks = chunkSessionText({ body }, { maxChars: 100, overlap: 20 });
-    for (const c of chunks) {
-      expect(c).toBe(c.trim());
-    }
-  });
-
-  it("returns at least one chunk for tiny non-empty input", () => {
-    expect(chunkSessionText({ body: "x" })).toEqual(["x"]);
-    expect(chunkSessionText({ label: "x" })).toEqual(["x"]);
-  });
-});