@teammates/recall 0.4.1 → 0.5.1

package/dist/embeddings.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/embeddings.test.js

@@ -0,0 +1,81 @@
+import { describe, expect, it, vi } from "vitest";
+import { LocalEmbeddings } from "./embeddings.js";
+// Mock @huggingface/transformers to avoid loading the real model
+vi.mock("@huggingface/transformers", () => ({
+    pipeline: vi.fn(async () => {
+        // Return a fake extractor function
+        return async (texts, _opts) => ({
+            tolist: () => texts.map(() => new Array(384).fill(0.1)),
+        });
+    }),
+}));
+describe("LocalEmbeddings", () => {
+    it("has maxTokens set to 256", () => {
+        const emb = new LocalEmbeddings();
+        expect(emb.maxTokens).toBe(256);
+    });
+    describe("createEmbeddings", () => {
+        it("returns embeddings for a single string input", async () => {
+            const emb = new LocalEmbeddings();
+            const result = await emb.createEmbeddings("hello world");
+            expect(result.status).toBe("success");
+            expect(result.output).toHaveLength(1);
+            expect(result.output[0]).toHaveLength(384);
+        });
+        it("returns embeddings for an array of strings", async () => {
+            const emb = new LocalEmbeddings();
+            const result = await emb.createEmbeddings(["hello", "world"]);
+            expect(result.status).toBe("success");
+            expect(result.output).toHaveLength(2);
+            expect(result.output[0]).toHaveLength(384);
+            expect(result.output[1]).toHaveLength(384);
+        });
+        it("returns empty output for empty string input", async () => {
+            const emb = new LocalEmbeddings();
+            const result = await emb.createEmbeddings("");
+            expect(result.status).toBe("success");
+            expect(result.output).toHaveLength(0);
+        });
+        it("returns empty output for whitespace-only input", async () => {
+            const emb = new LocalEmbeddings();
+            const result = await emb.createEmbeddings("   ");
+            expect(result.status).toBe("success");
+            expect(result.output).toHaveLength(0);
+        });
+        it("filters out empty strings from array input", async () => {
+            const emb = new LocalEmbeddings();
+            const result = await emb.createEmbeddings(["hello", "", "  ", "world"]);
+            expect(result.status).toBe("success");
+            expect(result.output).toHaveLength(2);
+        });
+        it("returns error status when extractor throws", async () => {
+            const { pipeline } = await import("@huggingface/transformers");
+            // Override mock to throw
+            pipeline.mockImplementationOnce(async () => {
+                return async () => {
+                    throw new Error("Model load failed");
+                };
+            });
+            const emb = new LocalEmbeddings("bad-model");
+            const result = await emb.createEmbeddings("test");
+            expect(result.status).toBe("error");
+            expect(result.message).toBe("Model load failed");
+        });
+        it("reuses the extractor on subsequent calls (lazy init)", async () => {
+            const { pipeline } = await import("@huggingface/transformers");
+            pipeline.mockClear();
+            const emb = new LocalEmbeddings();
+            await emb.createEmbeddings("first");
+            await emb.createEmbeddings("second");
+            // pipeline() should only be called once (lazy singleton)
+            expect(pipeline).toHaveBeenCalledTimes(1);
+        });
+        it("accepts a custom model name", async () => {
+            const { pipeline } = await import("@huggingface/transformers");
+            pipeline.mockClear();
+            const emb = new LocalEmbeddings("custom/model-name");
+            await emb.createEmbeddings("test");
+            expect(pipeline).toHaveBeenCalledWith("feature-extraction", "custom/model-name", expect.objectContaining({ dtype: "fp32" }));
+        });
+    });
+});

package/dist/index.d.ts

@@ -1,3 +1,5 @@
 export { LocalEmbeddings } from "./embeddings.js";
 export { Indexer, type IndexerConfig } from "./indexer.js";
-export { type SearchOptions, type SearchResult, search } from "./search.js";
+export { matchMemoryCatalog, scanMemoryCatalog } from "./memory-index.js";
+export { buildQueryVariations, extractKeywords } from "./query-expansion.js";
+export { type MultiSearchOptions, type SearchOptions, type SearchResult, multiSearch, search, } from "./search.js";

package/dist/index.js

@@ -1,3 +1,5 @@
 export { LocalEmbeddings } from "./embeddings.js";
 export { Indexer } from "./indexer.js";
-export { search } from "./search.js";
+export { matchMemoryCatalog, scanMemoryCatalog } from "./memory-index.js";
+export { buildQueryVariations, extractKeywords } from "./query-expansion.js";
+export { multiSearch, search, } from "./search.js";

package/dist/indexer.d.ts

@@ -47,6 +47,11 @@ export declare class Indexer {
      * Upserts new/changed files without a full rebuild.
      */
     syncTeammate(teammate: string): Promise<number>;
+    /**
+     * Delete a document from a teammate's index by URI.
+     * Used to purge stale daily logs after they age out on disk.
+     */
+    deleteDocument(teammate: string, uri: string): Promise<void>;
     /**
      * Sync indexes for all teammates.
      */

package/dist/indexer.js

@@ -54,16 +54,20 @@ export class Indexer {
         catch {
             // No WISDOM.md
         }
-        // memory/*.md — typed memories only (skip raw daily logs, they're in prompt context)
+        // memory/*.md — typed memories + daily logs (day 2+)
+        // Today's daily log is excluded (still being written). Older dailies are
+        // indexed so recall can surface high-resolution episodic context beyond
+        // the 7-day prompt window. Dailies older than 30 days are purged elsewhere.
         const memoryDir = path.join(teammateDir, "memory");
+        const today = new Date().toISOString().slice(0, 10);
         try {
             const memoryEntries = await fs.readdir(memoryDir);
             for (const entry of memoryEntries) {
                 if (!entry.endsWith(".md"))
                     continue;
                 const stem = path.basename(entry, ".md");
-                // Skip daily logs (YYYY-MM-DD) — they're already in prompt context
-                if (/^\d{4}-\d{2}-\d{2}$/.test(stem))
+                // Skip today's daily log — it's still being written and already in prompt context
+                if (stem === today)
                     continue;
                 files.push({
                     uri: `${teammate}/memory/${entry}`,
@@ -194,6 +198,23 @@ export class Indexer {
         }
         return count;
     }
+    /**
+     * Delete a document from a teammate's index by URI.
+     * Used to purge stale daily logs after they age out on disk.
+     */
+    async deleteDocument(teammate, uri) {
+        const indexPath = this.indexPath(teammate);
+        const index = new LocalDocumentIndex({
+            folderPath: indexPath,
+            embeddings: this._embeddings,
+        });
+        if (!(await index.isIndexCreated()))
+            return;
+        const docId = await index.getDocumentId(uri);
+        if (docId) {
+            await index.deleteDocument(uri);
+        }
+    }
     /**
      * Sync indexes for all teammates.
      */

package/dist/indexer.test.js

@@ -83,17 +83,20 @@ describe("Indexer", () => {
             expect(uris).toContain("beacon/memory/feedback_testing.md");
             expect(uris).toContain("beacon/memory/project_goals.md");
         });
-        it("skips daily logs (YYYY-MM-DD.md pattern)", async () => {
+        it("includes older daily logs but skips today's", async () => {
             const memDir = join(testDir, "beacon", "memory");
             await mkdir(memDir, { recursive: true });
+            const today = new Date().toISOString().slice(0, 10);
+            await writeFile(join(memDir, `${today}.md`), "# Today");
             await writeFile(join(memDir, "2026-03-14.md"), "# Day 1");
             await writeFile(join(memDir, "2026-03-15.md"), "# Day 2");
             await writeFile(join(memDir, "feedback_testing.md"), "# Feedback");
             const indexer = createIndexer(testDir);
             const { files } = await indexer.collectFiles("beacon");
             const uris = files.map((f) => f.uri);
-            expect(uris).not.toContain("beacon/memory/2026-03-14.md");
-            expect(uris).not.toContain("beacon/memory/2026-03-15.md");
+            expect(uris).not.toContain(`beacon/memory/${today}.md`);
+            expect(uris).toContain("beacon/memory/2026-03-14.md");
+            expect(uris).toContain("beacon/memory/2026-03-15.md");
             expect(uris).toContain("beacon/memory/feedback_testing.md");
         });
         it("collects weekly summaries from memory/weekly/", async () => {
@@ -181,6 +184,65 @@ describe("Indexer", () => {
             expect(results.get("scribe")).toBe(0); // no indexable files
         });
     });
+    describe("upsertFile", () => {
+        it("upserts a single file into a new index", async () => {
+            const beacon = join(testDir, "beacon");
+            await mkdir(beacon, { recursive: true });
+            const filePath = join(beacon, "WISDOM.md");
+            await writeFile(filePath, "# Upsert test wisdom");
+            const indexer = createIndexer(testDir);
+            await indexer.upsertFile("beacon", filePath);
+            // Verify index was created by syncing (which reads the index)
+            const count = await indexer.syncTeammate("beacon");
+            expect(count).toBeGreaterThanOrEqual(1);
+        });
+        it("upserts into an existing index without rebuilding", async () => {
+            const beacon = join(testDir, "beacon");
+            const memDir = join(beacon, "memory");
+            await mkdir(memDir, { recursive: true });
+            await writeFile(join(beacon, "WISDOM.md"), "# Wisdom");
+            const indexer = createIndexer(testDir);
+            // Build initial index
+            await indexer.indexTeammate("beacon");
+            // Upsert a new file
+            const newFile = join(memDir, "feedback_test.md");
+            await writeFile(newFile, "# New feedback content");
+            await indexer.upsertFile("beacon", newFile);
+            // Sync should see both files
+            const count = await indexer.syncTeammate("beacon");
+            expect(count).toBe(2);
+        });
+        it("skips empty files", async () => {
+            const beacon = join(testDir, "beacon");
+            await mkdir(beacon, { recursive: true });
+            const filePath = join(beacon, "WISDOM.md");
+            await writeFile(filePath, "   "); // whitespace only
+            const indexer = createIndexer(testDir);
+            // Should not throw, just skip
+            await indexer.upsertFile("beacon", filePath);
+        });
+    });
+    describe("syncAll", () => {
+        it("syncs all discovered teammates", async () => {
+            const beacon = join(testDir, "beacon");
+            const scribe = join(testDir, "scribe");
+            await mkdir(beacon, { recursive: true });
+            await mkdir(scribe, { recursive: true });
+            await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+            await writeFile(join(beacon, "WISDOM.md"), "# Beacon wisdom");
+            await writeFile(join(scribe, "SOUL.md"), "# Scribe");
+            await writeFile(join(scribe, "WISDOM.md"), "# Scribe wisdom");
+            const indexer = createIndexer(testDir);
+            const results = await indexer.syncAll();
+            expect(results.get("beacon")).toBe(1);
+            expect(results.get("scribe")).toBe(1);
+        });
+        it("returns empty map when no teammates exist", async () => {
+            const indexer = createIndexer(testDir);
+            const results = await indexer.syncAll();
+            expect(results.size).toBe(0);
+        });
+    });
     describe("syncTeammate", () => {
         it("falls back to full index when no index exists", async () => {
             const beacon = join(testDir, "beacon");

package/dist/memory-index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Memory frontmatter scanning for Pass 1 recall queries.
+ *
+ * Reads the teammate's memory file catalog (name + description from frontmatter)
+ * and does fast text matching against the task prompt. This is a lightweight,
+ * no-embedding relevance signal — "here's a menu of what I might know about."
+ */
+import type { SearchResult } from "./search.js";
+interface MemoryEntry {
+    /** Relative URI (e.g. "beacon/memory/project_goals.md") */
+    uri: string;
+    /** Absolute file path */
+    absolutePath: string;
+    /** Frontmatter name field */
+    name: string;
+    /** Frontmatter description field */
+    description: string;
+}
+/**
+ * Scan a teammate's memory directory and build a catalog of memory entries
+ * with their frontmatter metadata.
+ */
+export declare function scanMemoryCatalog(teammatesDir: string, teammate: string): Promise<MemoryEntry[]>;
+/**
+ * Match task prompt text against memory catalog entries.
+ * Returns memory files whose name or description has significant word overlap
+ * with the task prompt. Each match is returned as a SearchResult with the
+ * file's full content.
+ *
+ * Matching is case-insensitive. A match requires at least one word from the
+ * task prompt appearing in the name or description.
+ */
+export declare function matchMemoryCatalog(teammatesDir: string, teammate: string, taskPrompt: string, maxTokens?: number): Promise<SearchResult[]>;
+export {};

package/dist/memory-index.js

@@ -0,0 +1,118 @@
+/**
+ * Memory frontmatter scanning for Pass 1 recall queries.
+ *
+ * Reads the teammate's memory file catalog (name + description from frontmatter)
+ * and does fast text matching against the task prompt. This is a lightweight,
+ * no-embedding relevance signal — "here's a menu of what I might know about."
+ */
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+/**
+ * Parse YAML-ish frontmatter from a markdown file's content.
+ * Returns name and description fields, or null if no frontmatter found.
+ */
+function parseFrontmatter(content) {
+    const match = content.match(/^---\s*\n([\s\S]*?)\n---/);
+    if (!match)
+        return null;
+    const fm = match[1];
+    const nameMatch = fm.match(/^name:\s*(.+)$/m);
+    const descMatch = fm.match(/^description:\s*(.+)$/m);
+    if (!nameMatch)
+        return null;
+    return {
+        name: nameMatch[1].trim(),
+        description: descMatch?.[1]?.trim() ?? "",
+    };
+}
+/**
+ * Scan a teammate's memory directory and build a catalog of memory entries
+ * with their frontmatter metadata.
+ */
+export async function scanMemoryCatalog(teammatesDir, teammate) {
+    const memoryDir = path.join(teammatesDir, teammate, "memory");
+    const entries = [];
+    try {
+        const files = await fs.readdir(memoryDir);
+        for (const file of files) {
+            if (!file.endsWith(".md"))
+                continue;
+            // Skip daily logs (YYYY-MM-DD.md)
+            const stem = path.basename(file, ".md");
+            if (/^\d{4}-\d{2}-\d{2}$/.test(stem))
+                continue;
+            const absolutePath = path.join(memoryDir, file);
+            const content = await fs.readFile(absolutePath, "utf-8");
+            const fm = parseFrontmatter(content);
+            if (!fm)
+                continue;
+            entries.push({
+                uri: `${teammate}/memory/${file}`,
+                absolutePath,
+                name: fm.name,
+                description: fm.description,
+            });
+        }
+    }
+    catch {
+        // No memory/ directory
+    }
+    return entries;
+}
+/**
+ * Match task prompt text against memory catalog entries.
+ * Returns memory files whose name or description has significant word overlap
+ * with the task prompt. Each match is returned as a SearchResult with the
+ * file's full content.
+ *
+ * Matching is case-insensitive. A match requires at least one word from the
+ * task prompt appearing in the name or description.
+ */
+export async function matchMemoryCatalog(teammatesDir, teammate, taskPrompt, maxTokens = 500) {
+    const catalog = await scanMemoryCatalog(teammatesDir, teammate);
+    if (catalog.length === 0)
+        return [];
+    // Tokenize the task prompt into lowercase words (3+ chars)
+    const promptWords = new Set(taskPrompt
+        .toLowerCase()
+        .replace(/[^\w\s@/-]/g, " ")
+        .split(/\s+/)
+        .filter((w) => w.length > 2));
+    const results = [];
+    for (const entry of catalog) {
+        const catalogText = `${entry.name} ${entry.description}`.toLowerCase();
+        const catalogWords = catalogText
+            .replace(/[^\w\s@/_-]/g, " ")
+            .split(/\s+/)
+            .filter((w) => w.length > 2);
+        // Count overlapping words
+        let overlap = 0;
+        for (const w of catalogWords) {
+            if (promptWords.has(w))
+                overlap++;
+        }
+        // Also check if prompt words appear as substrings in the catalog text
+        // (e.g., "goal" matches "project_goals")
+        for (const pw of promptWords) {
+            if (catalogText.includes(pw) && !catalogWords.includes(pw)) {
+                overlap += 0.5;
+            }
+        }
+        if (overlap >= 1) {
+            // Read full file content for matched entries
+            const content = await fs.readFile(entry.absolutePath, "utf-8");
+            // Strip frontmatter from the content
+            const body = content.replace(/^---\s*\n[\s\S]*?\n---\s*\n?/, "").trim();
+            results.push({
+                teammate,
+                uri: entry.uri,
+                text: body.slice(0, maxTokens * 4), // rough token limit
+                score: 0.85 + Math.min(overlap * 0.02, 0.1), // 0.85-0.95 range
+                contentType: "typed_memory",
+            });
+        }
+    }
+    // Sort by score descending
+    results.sort((a, b) => b.score - a.score);
+    return results;
+}

package/dist/memory-index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/memory-index.test.js

@@ -0,0 +1,96 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { matchMemoryCatalog, scanMemoryCatalog } from "./memory-index.js";
+const TEST_DIR = path.join(process.cwd(), ".test-memory-index");
+const TEAMMATE = "testmate";
+beforeAll(async () => {
+    const memoryDir = path.join(TEST_DIR, TEAMMATE, "memory");
+    await fs.mkdir(memoryDir, { recursive: true });
+    // Create typed memory files with frontmatter
+    await fs.writeFile(path.join(memoryDir, "project_goals.md"), `---
+name: project_goals
+description: Stack-ranked feature goals for the teammates project
+type: project
+---
+
+## Goals
+
+1. Recall query architecture
+2. CLI improvements
+`);
+    await fs.writeFile(path.join(memoryDir, "feedback_testing.md"), `---
+name: feedback_testing
+description: Integration tests must hit a real database, not mocks
+type: feedback
+---
+
+Use real databases in tests. Mocks hide migration bugs.
+`);
+    // Create a file without frontmatter (should be skipped)
+    await fs.writeFile(path.join(memoryDir, "notes.md"), "Just some notes without frontmatter.\n");
+    // Create a daily log (should be skipped)
+    await fs.writeFile(path.join(memoryDir, "2026-03-21.md"), "# 2026-03-21\nDaily log content.\n");
+});
+afterAll(async () => {
+    await fs.rm(TEST_DIR, { recursive: true, force: true });
+});
+describe("scanMemoryCatalog", () => {
+    it("returns entries with frontmatter", async () => {
+        const entries = await scanMemoryCatalog(TEST_DIR, TEAMMATE);
+        expect(entries.length).toBe(2);
+        const names = entries.map((e) => e.name);
+        expect(names).toContain("project_goals");
+        expect(names).toContain("feedback_testing");
+    });
+    it("skips files without frontmatter", async () => {
+        const entries = await scanMemoryCatalog(TEST_DIR, TEAMMATE);
+        const uris = entries.map((e) => e.uri);
+        expect(uris).not.toContain(`${TEAMMATE}/memory/notes.md`);
+    });
+    it("skips daily logs", async () => {
+        const entries = await scanMemoryCatalog(TEST_DIR, TEAMMATE);
+        const uris = entries.map((e) => e.uri);
+        expect(uris).not.toContain(`${TEAMMATE}/memory/2026-03-21.md`);
+    });
+    it("returns empty array for nonexistent teammate", async () => {
+        const entries = await scanMemoryCatalog(TEST_DIR, "nobody");
+        expect(entries).toEqual([]);
+    });
+});
+describe("matchMemoryCatalog", () => {
+    it("matches files whose frontmatter overlaps with the query", async () => {
+        const results = await matchMemoryCatalog(TEST_DIR, TEAMMATE, "what are our project goals and features?");
+        expect(results.length).toBeGreaterThanOrEqual(1);
+        expect(results[0].uri).toContain("project_goals");
+    });
+    it("matches on description keywords", async () => {
+        const results = await matchMemoryCatalog(TEST_DIR, TEAMMATE, "database testing integration");
+        expect(results.length).toBeGreaterThanOrEqual(1);
+        const uris = results.map((r) => r.uri);
+        expect(uris).toContain(`${TEAMMATE}/memory/feedback_testing.md`);
+    });
+    it("returns empty for unrelated queries", async () => {
+        const results = await matchMemoryCatalog(TEST_DIR, TEAMMATE, "quantum physics dark matter");
+        expect(results.length).toBe(0);
+    });
+    it("strips frontmatter from result text", async () => {
+        const results = await matchMemoryCatalog(TEST_DIR, TEAMMATE, "project goals features");
+        expect(results.length).toBeGreaterThanOrEqual(1);
+        expect(results[0].text).not.toContain("---");
+        expect(results[0].text).toContain("Goals");
+    });
+    it("assigns scores in the 0.85-0.95 range", async () => {
+        const results = await matchMemoryCatalog(TEST_DIR, TEAMMATE, "project goals features teammates");
+        for (const r of results) {
+            expect(r.score).toBeGreaterThanOrEqual(0.85);
+            expect(r.score).toBeLessThanOrEqual(0.95);
+        }
+    });
+    it("sets contentType to typed_memory", async () => {
+        const results = await matchMemoryCatalog(TEST_DIR, TEAMMATE, "project goals");
+        for (const r of results) {
+            expect(r.contentType).toBe("typed_memory");
+        }
+    });
+});

package/dist/query-expansion.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Lightweight query expansion for Pass 1 recall queries.
+ *
+ * No LLM needed — uses stopword removal and basic text analysis
+ * to generate multiple query variations from a task prompt.
+ */
+/**
+ * Extract meaningful keywords from text by removing stopwords and short tokens.
+ * Returns lowercase keywords in order of appearance.
+ */
+export declare function extractKeywords(text: string): string[];
+/**
+ * Build multiple query variations from a task prompt and optional conversation context.
+ *
+ * Returns 1-3 queries:
+ * 1. The original task prompt (always)
+ * 2. A focused keyword query (if keywords differ meaningfully from the original)
+ * 3. A conversation-derived query (if recent conversation context is provided)
+ */
+export declare function buildQueryVariations(taskPrompt: string, conversationContext?: string): string[];

package/dist/query-expansion.js

@@ -0,0 +1,92 @@
+/**
+ * Lightweight query expansion for Pass 1 recall queries.
+ *
+ * No LLM needed — uses stopword removal and basic text analysis
+ * to generate multiple query variations from a task prompt.
+ */
+/** Common English stopwords to filter from queries. */
+const STOPWORDS = new Set([
+    "a", "an", "the", "and", "or", "but", "in", "on", "at", "to", "for",
+    "of", "with", "by", "from", "is", "are", "was", "were", "be", "been",
+    "being", "have", "has", "had", "do", "does", "did", "will", "would",
+    "could", "should", "may", "might", "shall", "can", "need", "must",
+    "it", "its", "this", "that", "these", "those", "i", "you", "he", "she",
+    "we", "they", "me", "him", "her", "us", "them", "my", "your", "his",
+    "our", "their", "what", "which", "who", "whom", "where", "when", "how",
+    "why", "if", "then", "so", "not", "no", "just", "also", "very", "too",
+    "some", "any", "all", "each", "every", "both", "few", "more", "most",
+    "other", "into", "over", "after", "before", "between", "through",
+    "about", "up", "out", "off", "down", "here", "there", "again", "once",
+    "let", "lets", "let's", "get", "got", "go", "going", "make", "made",
+    "take", "took", "come", "came", "see", "saw", "know", "knew", "think",
+    "thought", "say", "said", "tell", "told", "ask", "asked", "want",
+    "wanted", "like", "look", "use", "used", "find", "give", "work",
+]);
+/**
+ * Extract meaningful keywords from text by removing stopwords and short tokens.
+ * Returns lowercase keywords in order of appearance.
+ */
+export function extractKeywords(text) {
+    const words = text
+        .toLowerCase()
+        .replace(/[^\w\s@/-]/g, " ")
+        .split(/\s+/)
+        .filter((w) => w.length > 2 && !STOPWORDS.has(w));
+    // Deduplicate while preserving order
+    const seen = new Set();
+    const result = [];
+    for (const w of words) {
+        if (!seen.has(w)) {
+            seen.add(w);
+            result.push(w);
+        }
+    }
+    return result;
+}
+/**
+ * Build multiple query variations from a task prompt and optional conversation context.
+ *
+ * Returns 1-3 queries:
+ * 1. The original task prompt (always)
+ * 2. A focused keyword query (if keywords differ meaningfully from the original)
+ * 3. A conversation-derived query (if recent conversation context is provided)
+ */
+export function buildQueryVariations(taskPrompt, conversationContext) {
+    const queries = [taskPrompt];
+    // Query 2: Focused keywords from the task prompt
+    const keywords = extractKeywords(taskPrompt);
+    if (keywords.length >= 2 && keywords.length <= 20) {
+        const keywordQuery = keywords.slice(0, 8).join(" ");
+        // Only add if meaningfully different from original
+        if (keywordQuery.length < taskPrompt.length * 0.7) {
+            queries.push(keywordQuery);
+        }
+    }
+    // Query 3: Recent conversation topic
+    if (conversationContext) {
+        const recentTopic = extractRecentTopic(conversationContext);
+        if (recentTopic) {
+            queries.push(recentTopic);
+        }
+    }
+    return queries;
+}
+/**
+ * Extract the most recent topic/theme from conversation context.
+ * Takes the last 1-2 meaningful entries and extracts keywords.
+ */
+function extractRecentTopic(conversationContext) {
+    // Split on common conversation entry patterns
+    const entries = conversationContext
+        .split(/\n\*\*\w+:\*\*\s*/g)
+        .filter((e) => e.trim().length > 10);
+    if (entries.length === 0)
+        return null;
+    // Take the last 1-2 entries (most recent conversation)
+    const recent = entries.slice(-2).join(" ");
+    const keywords = extractKeywords(recent);
+    if (keywords.length < 2)
+        return null;
+    // Build a focused query from the recent conversation keywords
+    return keywords.slice(0, 6).join(" ");
+}

package/dist/query-expansion.test.d.ts

@@ -0,0 +1 @@
+export {};