nlm-memory 0.4.2 → 0.5.1

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"]);
-  });
-});

package/tests/unit/core/facts/extract-facts.test.ts

@@ -1,117 +0,0 @@
-/**
- * extractFacts — pure transform from ClassifyResult to Fact[]. No DB, no
- * randomness (idGenerator is injected).
- */
-
-import { describe, expect, it } from "vitest";
-import { extractFacts } from "../../../../src/core/facts/extract-facts.js";
-import type { ClassifyResult } from "../../../../src/ports/llm-client.js";
-
-function classifyResult(overrides: Partial<ClassifyResult> = {}): ClassifyResult {
-  return {
-    label: "L",
-    summary: "S",
-    entities: [],
-    decisions: [],
-    open: [],
-    confidence: 0.9,
-    facts: [],
-    ...overrides,
-  };
-}
-
-describe("extractFacts", () => {
-  it("returns an empty array when classify result has no facts", () => {
-    const out = extractFacts(classifyResult(), "sess_1", "2026-05-19T10:00:00Z");
-    expect(out).toEqual([]);
-  });
-
-  it("maps classifier facts to full Fact records with injected id + timestamp", () => {
-    let n = 0;
-    const result = classifyResult({
-      confidence: 0.85,
-      facts: [
-        { kind: "decision", subject: "nlm-memory-ts", predicate: "framework", value: "Hono" },
-        {
-          kind: "attribute",
-          subject: "mac-pro",
-          predicate: "endpoint",
-          value: "http://macpro:8080/v1",
-          sourceQuote: "endpoint at :8080",
-        },
-      ],
-    });
-    const out = extractFacts(result, "sess_1", "2026-05-19T10:00:00Z", {
-      idGenerator: () => `fact_${++n}`,
-    });
-    expect(out).toEqual([
-      {
-        id: "fact_1",
-        kind: "decision",
-        subject: "nlm-memory-ts",
-        predicate: "framework",
-        value: "Hono",
-        sourceSessionId: "sess_1",
-        sourceQuote: null,
-        createdAt: "2026-05-19T10:00:00Z",
-        supersededBy: null,
-        confidence: 0.85,
-      },
-      {
-        id: "fact_2",
-        kind: "attribute",
-        subject: "mac-pro",
-        predicate: "endpoint",
-        value: "http://macpro:8080/v1",
-        sourceSessionId: "sess_1",
-        sourceQuote: "endpoint at :8080",
-        createdAt: "2026-05-19T10:00:00Z",
-        supersededBy: null,
-        confidence: 0.85,
-      },
-    ]);
-  });
-
-  it("drops all facts when classifier confidence is below 0.4", () => {
-    const result = classifyResult({
-      confidence: 0.35,
-      facts: [
-        { kind: "decision", subject: "x", predicate: "framework", value: "y" },
-      ],
-    });
-    expect(extractFacts(result, "sess_1", "2026-05-19T10:00:00Z")).toEqual([]);
-  });
-
-  it("keeps facts when confidence is exactly the floor (0.4)", () => {
-    const result = classifyResult({
-      confidence: 0.4,
-      facts: [
-        { kind: "decision", subject: "x", predicate: "framework", value: "y" },
-      ],
-    });
-    expect(extractFacts(result, "sess_1", "2026-05-19T10:00:00Z")).toHaveLength(1);
-  });
-
-  it("uses default id generator (fact_<uuid>) when none provided", () => {
-    const result = classifyResult({
-      facts: [{ kind: "decision", subject: "x", predicate: "framework", value: "y" }],
-    });
-    const out = extractFacts(result, "sess_1", "2026-05-19T10:00:00Z");
-    expect(out[0]?.id).toMatch(/^fact_[0-9a-f-]{36}$/);
-  });
-
-  it("each fact gets its own id from the generator (no reuse)", () => {
-    let n = 0;
-    const result = classifyResult({
-      facts: [
-        { kind: "decision", subject: "a", predicate: "framework", value: "x" },
-        { kind: "decision", subject: "b", predicate: "framework", value: "y" },
-        { kind: "decision", subject: "c", predicate: "framework", value: "z" },
-      ],
-    });
-    const out = extractFacts(result, "sess_1", "2026-05-19T10:00:00Z", {
-      idGenerator: () => `fact_${++n}`,
-    });
-    expect(out.map((f) => f.id)).toEqual(["fact_1", "fact_2", "fact_3"]);
-  });
-});

package/tests/unit/core/filter.test.ts

@@ -1,40 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { applyFilter } from "../../../src/core/recall/filter.js";
-import { makeSession } from "../../fixtures/sessions.js";
-
-describe("applyFilter", () => {
-  const noDecisionsNoOpen = makeSession({ id: "a", entities: ["Whtnxt"] });
-  const onlyDecisions = makeSession({ id: "b", entities: ["NLM"], decisions: ["picked Hono"] });
-  const onlyOpen = makeSession({ id: "c", entities: ["NLM"], open: ["pgvector later"] });
-  const both = makeSession({
-    id: "d",
-    entities: ["NLM", "Whtnxt"],
-    decisions: ["use SQLite + sqlite-vec"],
-    open: ["Tauri or Electron"],
-  });
-  const corpus = [noDecisionsNoOpen, onlyDecisions, onlyOpen, both];
-
-  it("returns input unchanged when filter is empty", () => {
-    expect(applyFilter(corpus, {})).toEqual(corpus);
-  });
-
-  it("filters by entity tag", () => {
-    const result = applyFilter(corpus, { entity: "NLM" });
-    expect(result.map((s) => s.id)).toEqual(["b", "c", "d"]);
-  });
-
-  it("filters by kind=decision (drops sessions with no decisions)", () => {
-    const result = applyFilter(corpus, { kind: "decision" });
-    expect(result.map((s) => s.id)).toEqual(["b", "d"]);
-  });
-
-  it("filters by kind=open (drops sessions with no open questions)", () => {
-    const result = applyFilter(corpus, { kind: "open" });
-    expect(result.map((s) => s.id)).toEqual(["c", "d"]);
-  });
-
-  it("combines entity and kind constraints (AND semantics)", () => {
-    const result = applyFilter(corpus, { entity: "Whtnxt", kind: "decision" });
-    expect(result.map((s) => s.id)).toEqual(["d"]);
-  });
-});

package/tests/unit/core/hook/citation-detect-cite-session.test.ts

@@ -1,96 +0,0 @@
-/**
- * cite_session tool_use handling in the Stop hook detector.
- *
- * The MCP server's citeSessionHandler already calls appendCitation() directly
- * when the model invokes cite_session. The Stop hook must NOT detect the same
- * cite_session tool_use and write a second log entry (double-count). The A1
- * sub-case in detectCitations now skips cite_session calls entirely.
- *
- * Implicit citations via other NLM tools (get_session, recall_sessions, etc.)
- * still fire through the A2 path as before.
- */
-
-import { describe, expect, it } from "vitest";
-import { detectCitations } from "../../../../src/core/hook/citation-detect.js";
-
-describe("detectCitations — cite_session skipped to prevent double-count", () => {
-  it("does not detect cite_session as a citation (MCP handler already logged it)", () => {
-    const result = detectCitations({
-      responseText: "Based on that session, here is my answer.",
-      toolUses: [
-        {
-          name: "mcp__nlm-memory__cite_session",
-          input: { id: "cc_sub_a139f4ab7ca5aa909" },
-        },
-      ],
-      surfacedIds: ["cc_sub_a139f4ab7ca5aa909"],
-    });
-    expect(result).toEqual([]);
-  });
-
-  it("does not detect cite_session even for a surfaced ID", () => {
-    const result = detectCitations({
-      responseText: "",
-      toolUses: [
-        {
-          name: "mcp__nlm-memory__cite_session",
-          input: { id: "cc_sub_a139f4ab7ca5aa909" },
-        },
-      ],
-      surfacedIds: ["cc_sub_a139f4ab7ca5aa909"],
-    });
-    expect(result).toEqual([]);
-  });
-
-  it("falls back to prose detection when cite_session is skipped and ID appears in text", () => {
-    const result = detectCitations({
-      responseText: "Per cc_sub_a139f4ab7ca5aa909, the decision was FTS5.",
-      toolUses: [
-        {
-          name: "mcp__nlm-memory__cite_session",
-          input: { id: "cc_sub_a139f4ab7ca5aa909" },
-        },
-      ],
-      surfacedIds: ["cc_sub_a139f4ab7ca5aa909"],
-    });
-    expect(result).toHaveLength(1);
-    expect(result[0]).toEqual({ id: "cc_sub_a139f4ab7ca5aa909", kind: "prose" });
-  });
-
-  it("returns empty when multiple cite_session calls are skipped and no prose match", () => {
-    const result = detectCitations({
-      responseText: "",
-      toolUses: [
-        {
-          name: "mcp__nlm-memory__cite_session",
-          input: { id: "cc_sub_a139f4ab7ca5aa909" },
-        },
-        {
-          name: "mcp__nlm-memory__cite_session",
-          input: { id: "hm_20260427_6ff562" },
-        },
-      ],
-      surfacedIds: ["cc_sub_a139f4ab7ca5aa909", "hm_20260427_6ff562"],
-    });
-    expect(result).toEqual([]);
-  });
-
-  it("A2 path (get_session) still fires while cite_session is skipped for the same turn", () => {
-    const result = detectCitations({
-      responseText: "",
-      toolUses: [
-        {
-          name: "mcp__nlm-memory__cite_session",
-          input: { id: "cc_sub_a139f4ab7ca5aa909" },
-        },
-        {
-          name: "mcp__nlm-memory__get_session",
-          input: { id: "hm_20260427_6ff562" },
-        },
-      ],
-      surfacedIds: ["cc_sub_a139f4ab7ca5aa909", "hm_20260427_6ff562"],
-    });
-    expect(result).toHaveLength(1);
-    expect(result[0]).toMatchObject({ id: "hm_20260427_6ff562", kind: "tool_use" });
-  });
-});

package/tests/unit/core/hook/citation-detect.test.ts

@@ -1,124 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  detectCitations,
-  detectCitedIds,
-} from "../../../../src/core/hook/citation-detect.js";
-
-describe("detectCitedIds (back-compat prose-only)", () => {
-  it("returns IDs that appear as substrings in the response", () => {
-    const surfaced = new Set([
-      "cc_sub_a139f4ab7ca5aa909",
-      "hm_20260427_6ff562",
-    ]);
-    const text = "Per cc_sub_a139f4ab7ca5aa909 and hm_20260427_6ff562 we chose FTS5.";
-    expect(detectCitedIds(text, surfaced).sort()).toEqual(
-      ["cc_sub_a139f4ab7ca5aa909", "hm_20260427_6ff562"].sort(),
-    );
-  });
-
-  it("returns empty when no surfaced IDs appear", () => {
-    expect(detectCitedIds("unrelated", new Set(["cc_sub_abc123def456"]))).toEqual([]);
-  });
-
-  it("ignores IDs shorter than the minimum length", () => {
-    expect(detectCitedIds("a ab abc abcdef", new Set(["a", "ab", "abc"]))).toEqual([]);
-  });
-});
-
-describe("detectCitations (combined tool_use + prose)", () => {
-  it("emits a tool_use citation when an NLM MCP tool input references a surfaced ID", () => {
-    const result = detectCitations({
-      responseText: "Let me look at that.",
-      toolUses: [
-        {
-          name: "mcp__nlm-memory__get_session",
-          input: { id: "cc_sub_a139f4ab7ca5aa909" },
-        },
-      ],
-      surfacedIds: ["cc_sub_a139f4ab7ca5aa909", "hm_20260427_6ff562"],
-    });
-    expect(result).toEqual([
-      { id: "cc_sub_a139f4ab7ca5aa909", kind: "tool_use" },
-    ]);
-  });
-
-  it("emits a prose citation when only the response text mentions the ID", () => {
-    const result = detectCitations({
-      responseText: "We decided on FTS5 per cc_sub_a139f4ab7ca5aa909.",
-      toolUses: [],
-      surfacedIds: ["cc_sub_a139f4ab7ca5aa909"],
-    });
-    expect(result).toEqual([
-      { id: "cc_sub_a139f4ab7ca5aa909", kind: "prose" },
-    ]);
-  });
-
-  it("prefers tool_use over prose when both fire on the same ID", () => {
-    const result = detectCitations({
-      responseText: "Per cc_sub_a139f4ab7ca5aa909, here is the answer.",
-      toolUses: [
-        {
-          name: "mcp__nlm-memory__get_session",
-          input: { id: "cc_sub_a139f4ab7ca5aa909" },
-        },
-      ],
-      surfacedIds: ["cc_sub_a139f4ab7ca5aa909"],
-    });
-    expect(result).toEqual([
-      { id: "cc_sub_a139f4ab7ca5aa909", kind: "tool_use" },
-    ]);
-  });
-
-  it("ignores non-NLM tool_use blocks even when they happen to contain the ID", () => {
-    const result = detectCitations({
-      responseText: "",
-      toolUses: [
-        {
-          name: "Bash",
-          input: { command: "grep cc_sub_a139f4ab7ca5aa909 /tmp/log" },
-        },
-      ],
-      surfacedIds: ["cc_sub_a139f4ab7ca5aa909"],
-    });
-    expect(result).toEqual([]);
-  });
-
-  it("handles multiple NLM tool calls in one turn", () => {
-    const result = detectCitations({
-      responseText: "",
-      toolUses: [
-        {
-          name: "mcp__nlm-memory__get_session",
-          input: { id: "cc_sub_a139f4ab7ca5aa909" },
-        },
-        {
-          name: "mcp__nlm-memory__get_session",
-          input: { id: "hm_20260427_6ff562" },
-        },
-      ],
-      surfacedIds: [
-        "cc_sub_a139f4ab7ca5aa909",
-        "hm_20260427_6ff562",
-        "cc_unused_id_xyz",
-      ],
-    });
-    expect(result.map((c) => c.id).sort()).toEqual(
-      ["cc_sub_a139f4ab7ca5aa909", "hm_20260427_6ff562"].sort(),
-    );
-    expect(result.every((c) => c.kind === "tool_use")).toBe(true);
-  });
-
-  it("recognizes recall_sessions tool calls with query+limit (no direct id) — does not emit when no ID present in input", () => {
-    const result = detectCitations({
-      responseText: "",
-      toolUses: [
-        {
-          name: "mcp__nlm-memory__recall_sessions",
-          input: { query: "FTS5 vs pgvector", limit: 5 },
-        },
-      ],
-      surfacedIds: ["cc_sub_a139f4ab7ca5aa909"],
-    });
-    expect(result).toEqual([]);
-  });
-});

package/tests/unit/core/hook/gate.test.ts

@@ -1,29 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { classifyPrompt } from "../../../../src/core/hook/gate.js";
-
-describe("classifyPrompt", () => {
-  it("classifies obvious generative openers as generative", () => {
-    expect(classifyPrompt("draft a LinkedIn post about FTS5")).toBe("generative");
-    expect(classifyPrompt("write the migration")).toBe("generative");
-    expect(classifyPrompt("brainstorm names for the feature")).toBe("generative");
-    expect(classifyPrompt("Create a test file")).toBe("generative");
-  });
-
-  it("classifies retrospective prompts as evaluate", () => {
-    expect(classifyPrompt("what did we decide about pgvector")).toBe("evaluate");
-    expect(classifyPrompt("have I worked with this client before")).toBe("evaluate");
-    expect(classifyPrompt("why is the recall backend returning zero results")).toBe("evaluate");
-  });
-
-  it("strips leading filler before checking the opener", () => {
-    expect(classifyPrompt("can you write a script")).toBe("generative");
-    expect(classifyPrompt("please draft the email")).toBe("generative");
-    expect(classifyPrompt("could you tell me what we decided")).toBe("evaluate");
-  });
-
-  it("defaults to evaluate for empty or ambiguous prompts", () => {
-    expect(classifyPrompt("")).toBe("evaluate");
-    expect(classifyPrompt("the FTS5 work")).toBe("evaluate");
-    expect(classifyPrompt("fix the failing test")).toBe("evaluate");
-  });
-});

package/tests/unit/core/hook/pointer-block.test.ts

@@ -1,22 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { formatPointerBlock } from "../../../../src/core/hook/pointer-block.js";
-
-describe("formatPointerBlock", () => {
-  it("returns an empty string for no hits", () => {
-    expect(formatPointerBlock([])).toBe("");
-  });
-
-  it("renders a header, one line per hit, and the tool footer", () => {
-    const block = formatPointerBlock([
-      { id: "sess_a", label: "FTS5 vs pgvector decision", startedAt: "2026-05-15T10:00:00.000Z" },
-      { id: "sess_b", label: "Semantic recall via sqlite-vec", startedAt: "2026-05-17T09:30:00.000Z" },
-    ]);
-    expect(block).toContain("## Possibly-relevant prior sessions (nlm-memory)");
-    expect(block).toContain("- sess_a · FTS5 vs pgvector decision (2026-05-15)");
-    expect(block).toContain("- sess_b · Semantic recall via sqlite-vec (2026-05-17)");
-    expect(block).toContain("recall_sessions");
-    expect(block).toContain("get_session");
-    expect(block).toContain("recall_facts");
-    expect(block).toContain("get_fact_history");
-  });
-});