@teammates/recall 0.5.0 → 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/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/search.d.ts

@@ -33,6 +33,10 @@ export interface SearchResult {
     /** Content type: "typed_memory", "weekly", "monthly", or "other" */
     contentType?: string;
 }
+/**
+ * Classify a URI into a content type for priority scoring.
+ */
+export declare function classifyUri(uri: string): string;
 /**
  * Search teammate memories using multi-pass retrieval.
  *

package/dist/search.js

@@ -6,7 +6,7 @@ import { Indexer } from "./indexer.js";
 /**
  * Classify a URI into a content type for priority scoring.
  */
-function classifyUri(uri) {
+export function classifyUri(uri) {
     if (uri.includes("/memory/weekly/"))
         return "weekly";
     if (uri.includes("/memory/monthly/"))

package/dist/search.test.js

@@ -1,23 +1,46 @@
-import { describe, expect, it } from "vitest";
-// classifyUri is not exported, so we test it indirectly via a re-implementation
-// or we can import the module and test the search function behavior.
-// Since classifyUri is a pure function, let's extract and test its logic.
-describe("classifyUri", () => {
-    // Re-implement the classification logic for unit testing
-    function classifyUri(uri) {
-        if (uri.includes("/memory/weekly/"))
-            return "weekly";
-        if (uri.includes("/memory/monthly/"))
-            return "monthly";
-        const memoryMatch = uri.match(/\/memory\/([^/]+)\.md$/);
-        if (memoryMatch) {
-            const stem = memoryMatch[1];
-            if (/^\d{4}-\d{2}-\d{2}$/.test(stem))
-                return "daily";
-            return "typed_memory";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { Indexer } from "./indexer.js";
+import { classifyUri, multiSearch, search } from "./search.js";
+// Deterministic stub embeddings based on text content
+function stubCreateEmbeddings(inputs) {
+    const texts = Array.isArray(inputs) ? inputs : [inputs];
+    return {
+        status: "success",
+        output: texts.map((t) => {
+            const vec = new Array(384).fill(0);
+            for (let i = 0; i < t.length; i++) {
+                vec[i % 384] += t.charCodeAt(i) / 1000;
+            }
+            return vec;
+        }),
+    };
+}
+// Mock LocalEmbeddings so search() uses stubs instead of real model
+vi.mock("./embeddings.js", () => ({
+    LocalEmbeddings: class {
+        maxTokens = 256;
+        async createEmbeddings(inputs) {
+            return stubCreateEmbeddings(inputs);
         }
-        return "other";
-    }
+    },
+}));
+function createIndexer(teammatesDir) {
+    const indexer = new Indexer({ teammatesDir });
+    // Indexer also creates LocalEmbeddings internally — already mocked above
+    return indexer;
+}
+let testDir;
+beforeEach(async () => {
+    testDir = join(tmpdir(), `recall-search-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    await mkdir(testDir, { recursive: true });
+});
+afterEach(async () => {
+    await rm(testDir, { recursive: true, force: true });
+});
+describe("classifyUri", () => {
     it("classifies weekly summaries", () => {
         expect(classifyUri("beacon/memory/weekly/2026-W10.md")).toBe("weekly");
     });
@@ -40,3 +63,224 @@ describe("classifyUri", () => {
         expect(classifyUri("beacon/notes/todo.md")).toBe("other");
     });
 });
+describe("search", () => {
+    it("returns results from an indexed teammate", async () => {
+        const beacon = join(testDir, "beacon");
+        const memDir = join(beacon, "memory");
+        await mkdir(memDir, { recursive: true });
+        await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+        await writeFile(join(beacon, "WISDOM.md"), "# Beacon wisdom about coding");
+        await writeFile(join(memDir, "feedback_testing.md"), "# Testing feedback\nAlways run tests before committing.");
+        // Pre-build the index with stub embeddings
+        const indexer = createIndexer(testDir);
+        await indexer.indexTeammate("beacon");
+        // Patch search to use stub embeddings by searching with skipSync
+        const results = await search("testing feedback", {
+            teammatesDir: testDir,
+            teammate: "beacon",
+            skipSync: true,
+            model: "stub", // won't matter since we mock at the index level
+        });
+        expect(results.length).toBeGreaterThan(0);
+        expect(results[0].teammate).toBe("beacon");
+        expect(results[0].score).toBeGreaterThan(0);
+    });
+    it("returns empty results when no index exists", async () => {
+        const beacon = join(testDir, "beacon");
+        await mkdir(beacon, { recursive: true });
+        await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+        const results = await search("anything", {
+            teammatesDir: testDir,
+            teammate: "beacon",
+            skipSync: true,
+        });
+        expect(results).toEqual([]);
+    });
+    it("includes recent weekly summaries via recency pass", async () => {
+        const beacon = join(testDir, "beacon");
+        const weeklyDir = join(beacon, "memory", "weekly");
+        await mkdir(weeklyDir, { recursive: true });
+        await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+        await writeFile(join(weeklyDir, "2026-W10.md"), "# Week 10\nWorked on search.");
+        await writeFile(join(weeklyDir, "2026-W11.md"), "# Week 11\nWorked on indexer.");
+        await writeFile(join(weeklyDir, "2026-W09.md"), "# Week 9\nOld stuff.");
+        const results = await search("anything", {
+            teammatesDir: testDir,
+            teammate: "beacon",
+            skipSync: true,
+            recencyDepth: 2,
+        });
+        const uris = results.map((r) => r.uri);
+        // Should include the 2 most recent weeks (W11 and W10), not W09
+        expect(uris).toContain("beacon/memory/weekly/2026-W11.md");
+        expect(uris).toContain("beacon/memory/weekly/2026-W10.md");
+        expect(uris).not.toContain("beacon/memory/weekly/2026-W09.md");
+    });
+    it("respects recencyDepth: 0 (no weekly summaries)", async () => {
+        const beacon = join(testDir, "beacon");
+        const weeklyDir = join(beacon, "memory", "weekly");
+        await mkdir(weeklyDir, { recursive: true });
+        await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+        await writeFile(join(weeklyDir, "2026-W11.md"), "# Week 11\nContent here.");
+        const results = await search("anything", {
+            teammatesDir: testDir,
+            teammate: "beacon",
+            skipSync: true,
+            recencyDepth: 0,
+        });
+        const uris = results.map((r) => r.uri);
+        expect(uris).not.toContain("beacon/memory/weekly/2026-W11.md");
+    });
+    it("searches all teammates when no teammate specified", async () => {
+        const beacon = join(testDir, "beacon");
+        const scribe = join(testDir, "scribe");
+        await mkdir(join(beacon, "memory"), { recursive: true });
+        await mkdir(join(scribe, "memory"), { recursive: true });
+        await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+        await writeFile(join(scribe, "SOUL.md"), "# Scribe");
+        await writeFile(join(beacon, "WISDOM.md"), "# Beacon wisdom");
+        await writeFile(join(scribe, "WISDOM.md"), "# Scribe wisdom");
+        // Build indexes
+        const indexer = createIndexer(testDir);
+        await indexer.indexTeammate("beacon");
+        await indexer.indexTeammate("scribe");
+        const results = await search("wisdom", {
+            teammatesDir: testDir,
+            skipSync: true,
+        });
+        const teammates = new Set(results.map((r) => r.teammate));
+        expect(teammates.size).toBeGreaterThanOrEqual(1);
+    });
+    it("deduplicates recency results with semantic results", async () => {
+        const beacon = join(testDir, "beacon");
+        const weeklyDir = join(beacon, "memory", "weekly");
+        await mkdir(weeklyDir, { recursive: true });
+        await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+        await writeFile(join(weeklyDir, "2026-W11.md"), "# Week 11\nSearch implementation details.");
+        // Build index that includes the weekly file
+        const indexer = createIndexer(testDir);
+        await indexer.indexTeammate("beacon");
+        const results = await search("search implementation", {
+            teammatesDir: testDir,
+            teammate: "beacon",
+            skipSync: true,
+            recencyDepth: 2,
+        });
+        // The weekly file should appear only once despite being picked up by both passes
+        const weeklyUris = results.filter((r) => r.uri === "beacon/memory/weekly/2026-W11.md");
+        expect(weeklyUris).toHaveLength(1);
+    });
+    it("applies typed memory boost", async () => {
+        const beacon = join(testDir, "beacon");
+        const memDir = join(beacon, "memory");
+        await mkdir(memDir, { recursive: true });
+        await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+        await writeFile(join(beacon, "WISDOM.md"), "# Some wisdom about testing");
+        await writeFile(join(memDir, "feedback_testing.md"), "# Testing feedback\nAlways verify test output carefully.");
+        const indexer = createIndexer(testDir);
+        await indexer.indexTeammate("beacon");
+        const results = await search("testing", {
+            teammatesDir: testDir,
+            teammate: "beacon",
+            skipSync: true,
+            typedMemoryBoost: 1.5,
+        });
+        // Find typed memory results — they should have boosted scores
+        const typedResults = results.filter((r) => r.contentType === "typed_memory");
+        if (typedResults.length > 0) {
+            // Just verify the contentType was set correctly
+            expect(typedResults[0].contentType).toBe("typed_memory");
+        }
+    });
+});
+describe("multiSearch", () => {
+    it("merges results from primary and additional queries", async () => {
+        const beacon = join(testDir, "beacon");
+        const memDir = join(beacon, "memory");
+        await mkdir(memDir, { recursive: true });
+        await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+        await writeFile(join(beacon, "WISDOM.md"), "# Wisdom about architecture");
+        await writeFile(join(memDir, "feedback_code_review.md"), "# Code review feedback\nAlways review pull requests thoroughly.");
+        const indexer = createIndexer(testDir);
+        await indexer.indexTeammate("beacon");
+        const results = await multiSearch("architecture", {
+            teammatesDir: testDir,
+            teammate: "beacon",
+            skipSync: true,
+            additionalQueries: ["code review"],
+        });
+        expect(results.length).toBeGreaterThan(0);
+    });
+    it("deduplicates by URI — highest score wins", async () => {
+        const beacon = join(testDir, "beacon");
+        await mkdir(beacon, { recursive: true });
+        await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+        await writeFile(join(beacon, "WISDOM.md"), "# Wisdom about testing and code quality");
+        const indexer = createIndexer(testDir);
+        await indexer.indexTeammate("beacon");
+        const results = await multiSearch("testing", {
+            teammatesDir: testDir,
+            teammate: "beacon",
+            skipSync: true,
+            additionalQueries: ["testing code quality"],
+        });
+        // Check no duplicate URIs
+        const uris = results.map((r) => r.uri);
+        const uniqueUris = new Set(uris);
+        expect(uris.length).toBe(uniqueUris.size);
+    });
+    it("merges catalog matches into results", async () => {
+        const beacon = join(testDir, "beacon");
+        await mkdir(beacon, { recursive: true });
+        await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+        await writeFile(join(beacon, "WISDOM.md"), "# Wisdom");
+        const indexer = createIndexer(testDir);
+        await indexer.indexTeammate("beacon");
+        const catalogMatches = [
+            {
+                teammate: "beacon",
+                uri: "beacon/memory/project_goals.md",
+                text: "# Project Goals\nBuild the best recall system.",
+                score: 0.92,
+                contentType: "typed_memory",
+            },
+        ];
+        const results = await multiSearch("goals", {
+            teammatesDir: testDir,
+            teammate: "beacon",
+            skipSync: true,
+            catalogMatches,
+        });
+        const goalResult = results.find((r) => r.uri === "beacon/memory/project_goals.md");
+        expect(goalResult).toBeDefined();
+        expect(goalResult.score).toBe(0.92);
+    });
+    it("additional queries skip recency pass (recencyDepth: 0)", async () => {
+        const beacon = join(testDir, "beacon");
+        const weeklyDir = join(beacon, "memory", "weekly");
+        await mkdir(weeklyDir, { recursive: true });
+        await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+        await writeFile(join(weeklyDir, "2026-W11.md"), "# Week 11\nDid some work.");
+        const results = await multiSearch("work", {
+            teammatesDir: testDir,
+            teammate: "beacon",
+            skipSync: true,
+            recencyDepth: 2,
+            additionalQueries: ["more work"],
+        });
+        // Weekly should appear at most once (from primary, not duplicated from additional)
+        const weeklyResults = results.filter((r) => r.uri === "beacon/memory/weekly/2026-W11.md");
+        expect(weeklyResults.length).toBeLessThanOrEqual(1);
+    });
+    it("returns empty when no index and no catalog matches", async () => {
+        const beacon = join(testDir, "beacon");
+        await mkdir(beacon, { recursive: true });
+        await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+        const results = await multiSearch("anything", {
+            teammatesDir: testDir,
+            teammate: "beacon",
+            skipSync: true,
+        });
+        expect(results).toEqual([]);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teammates/recall",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "Local semantic memory search for teammates. Indexes WISDOM.md and memory files using Vectra + transformers.js.",
   "type": "module",
   "main": "dist/index.js",

package/src/embeddings.test.ts

@@ -0,0 +1,106 @@
+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: string[], _opts: any) => ({
+      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 as any).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 as any).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 as any).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/src/indexer.test.ts

@@ -107,9 +107,11 @@ describe("Indexer", () => {
       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");
@@ -118,8 +120,9 @@ describe("Indexer", () => {
       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");
     });
 
@@ -230,6 +233,78 @@ describe("Indexer", () => {
     });
   });
 
+  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/src/indexer.ts

@@ -74,15 +74,19 @@ export class Indexer {
       // 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)) continue;
+        // 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}`,
           absolutePath: path.join(memoryDir, entry),
@@ -222,6 +226,25 @@ 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: string, uri: string): Promise<void> {
+    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/src/search.test.ts

@@ -1,49 +1,386 @@
-import { describe, expect, it } from "vitest";
-
-// classifyUri is not exported, so we test it indirectly via a re-implementation
-// or we can import the module and test the search function behavior.
-// Since classifyUri is a pure function, let's extract and test its logic.
-
-describe("classifyUri", () => {
-  // Re-implement the classification logic for unit testing
-  function classifyUri(uri: string): string {
-    if (uri.includes("/memory/weekly/")) return "weekly";
-    if (uri.includes("/memory/monthly/")) return "monthly";
-    const memoryMatch = uri.match(/\/memory\/([^/]+)\.md$/);
-    if (memoryMatch) {
-      const stem = memoryMatch[1];
-      if (/^\d{4}-\d{2}-\d{2}$/.test(stem)) return "daily";
-      return "typed_memory";
-    }
-    return "other";
-  }
-
-  it("classifies weekly summaries", () => {
-    expect(classifyUri("beacon/memory/weekly/2026-W10.md")).toBe("weekly");
-  });
-
-  it("classifies monthly summaries", () => {
-    expect(classifyUri("beacon/memory/monthly/2025-12.md")).toBe("monthly");
-  });
-
-  it("classifies typed memories", () => {
-    expect(classifyUri("beacon/memory/feedback_testing.md")).toBe(
-      "typed_memory",
-    );
-    expect(classifyUri("beacon/memory/project_goals.md")).toBe("typed_memory");
-  });
-
-  it("classifies daily logs", () => {
-    expect(classifyUri("beacon/memory/2026-03-14.md")).toBe("daily");
-    expect(classifyUri("beacon/memory/2026-01-01.md")).toBe("daily");
-  });
-
-  it("classifies WISDOM.md as other", () => {
-    expect(classifyUri("beacon/WISDOM.md")).toBe("other");
-  });
-
-  it("classifies non-memory paths as other", () => {
-    expect(classifyUri("beacon/SOUL.md")).toBe("other");
-    expect(classifyUri("beacon/notes/todo.md")).toBe("other");
-  });
-});
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { Indexer } from "./indexer.js";
+import { classifyUri, multiSearch, search } from "./search.js";
+import type { SearchResult } from "./search.js";
+
+// Deterministic stub embeddings based on text content
+function stubCreateEmbeddings(inputs: string | string[]) {
+  const texts = Array.isArray(inputs) ? inputs : [inputs];
+  return {
+    status: "success" as const,
+    output: texts.map((t) => {
+      const vec = new Array(384).fill(0);
+      for (let i = 0; i < t.length; i++) {
+        vec[i % 384] += t.charCodeAt(i) / 1000;
+      }
+      return vec;
+    }),
+  };
+}
+
+// Mock LocalEmbeddings so search() uses stubs instead of real model
+vi.mock("./embeddings.js", () => ({
+  LocalEmbeddings: class {
+    readonly maxTokens = 256;
+    async createEmbeddings(inputs: string | string[]) {
+      return stubCreateEmbeddings(inputs);
+    }
+  },
+}));
+
+function createIndexer(teammatesDir: string): Indexer {
+  const indexer = new Indexer({ teammatesDir });
+  // Indexer also creates LocalEmbeddings internally — already mocked above
+  return indexer;
+}
+
+let testDir: string;
+
+beforeEach(async () => {
+  testDir = join(
+    tmpdir(),
+    `recall-search-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  await mkdir(testDir, { recursive: true });
+});
+
+afterEach(async () => {
+  await rm(testDir, { recursive: true, force: true });
+});
+
+describe("classifyUri", () => {
+  it("classifies weekly summaries", () => {
+    expect(classifyUri("beacon/memory/weekly/2026-W10.md")).toBe("weekly");
+  });
+
+  it("classifies monthly summaries", () => {
+    expect(classifyUri("beacon/memory/monthly/2025-12.md")).toBe("monthly");
+  });
+
+  it("classifies typed memories", () => {
+    expect(classifyUri("beacon/memory/feedback_testing.md")).toBe(
+      "typed_memory",
+    );
+    expect(classifyUri("beacon/memory/project_goals.md")).toBe("typed_memory");
+  });
+
+  it("classifies daily logs", () => {
+    expect(classifyUri("beacon/memory/2026-03-14.md")).toBe("daily");
+    expect(classifyUri("beacon/memory/2026-01-01.md")).toBe("daily");
+  });
+
+  it("classifies WISDOM.md as other", () => {
+    expect(classifyUri("beacon/WISDOM.md")).toBe("other");
+  });
+
+  it("classifies non-memory paths as other", () => {
+    expect(classifyUri("beacon/SOUL.md")).toBe("other");
+    expect(classifyUri("beacon/notes/todo.md")).toBe("other");
+  });
+});
+
+describe("search", () => {
+  it("returns results from an indexed teammate", async () => {
+    const beacon = join(testDir, "beacon");
+    const memDir = join(beacon, "memory");
+    await mkdir(memDir, { recursive: true });
+    await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+    await writeFile(join(beacon, "WISDOM.md"), "# Beacon wisdom about coding");
+    await writeFile(
+      join(memDir, "feedback_testing.md"),
+      "# Testing feedback\nAlways run tests before committing.",
+    );
+
+    // Pre-build the index with stub embeddings
+    const indexer = createIndexer(testDir);
+    await indexer.indexTeammate("beacon");
+
+    // Patch search to use stub embeddings by searching with skipSync
+    const results = await search("testing feedback", {
+      teammatesDir: testDir,
+      teammate: "beacon",
+      skipSync: true,
+      model: "stub", // won't matter since we mock at the index level
+    });
+
+    expect(results.length).toBeGreaterThan(0);
+    expect(results[0].teammate).toBe("beacon");
+    expect(results[0].score).toBeGreaterThan(0);
+  });
+
+  it("returns empty results when no index exists", async () => {
+    const beacon = join(testDir, "beacon");
+    await mkdir(beacon, { recursive: true });
+    await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+
+    const results = await search("anything", {
+      teammatesDir: testDir,
+      teammate: "beacon",
+      skipSync: true,
+    });
+
+    expect(results).toEqual([]);
+  });
+
+  it("includes recent weekly summaries via recency pass", async () => {
+    const beacon = join(testDir, "beacon");
+    const weeklyDir = join(beacon, "memory", "weekly");
+    await mkdir(weeklyDir, { recursive: true });
+    await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+    await writeFile(
+      join(weeklyDir, "2026-W10.md"),
+      "# Week 10\nWorked on search.",
+    );
+    await writeFile(
+      join(weeklyDir, "2026-W11.md"),
+      "# Week 11\nWorked on indexer.",
+    );
+    await writeFile(
+      join(weeklyDir, "2026-W09.md"),
+      "# Week 9\nOld stuff.",
+    );
+
+    const results = await search("anything", {
+      teammatesDir: testDir,
+      teammate: "beacon",
+      skipSync: true,
+      recencyDepth: 2,
+    });
+
+    const uris = results.map((r) => r.uri);
+    // Should include the 2 most recent weeks (W11 and W10), not W09
+    expect(uris).toContain("beacon/memory/weekly/2026-W11.md");
+    expect(uris).toContain("beacon/memory/weekly/2026-W10.md");
+    expect(uris).not.toContain("beacon/memory/weekly/2026-W09.md");
+  });
+
+  it("respects recencyDepth: 0 (no weekly summaries)", async () => {
+    const beacon = join(testDir, "beacon");
+    const weeklyDir = join(beacon, "memory", "weekly");
+    await mkdir(weeklyDir, { recursive: true });
+    await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+    await writeFile(
+      join(weeklyDir, "2026-W11.md"),
+      "# Week 11\nContent here.",
+    );
+
+    const results = await search("anything", {
+      teammatesDir: testDir,
+      teammate: "beacon",
+      skipSync: true,
+      recencyDepth: 0,
+    });
+
+    const uris = results.map((r) => r.uri);
+    expect(uris).not.toContain("beacon/memory/weekly/2026-W11.md");
+  });
+
+  it("searches all teammates when no teammate specified", async () => {
+    const beacon = join(testDir, "beacon");
+    const scribe = join(testDir, "scribe");
+    await mkdir(join(beacon, "memory"), { recursive: true });
+    await mkdir(join(scribe, "memory"), { recursive: true });
+    await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+    await writeFile(join(scribe, "SOUL.md"), "# Scribe");
+    await writeFile(join(beacon, "WISDOM.md"), "# Beacon wisdom");
+    await writeFile(join(scribe, "WISDOM.md"), "# Scribe wisdom");
+
+    // Build indexes
+    const indexer = createIndexer(testDir);
+    await indexer.indexTeammate("beacon");
+    await indexer.indexTeammate("scribe");
+
+    const results = await search("wisdom", {
+      teammatesDir: testDir,
+      skipSync: true,
+    });
+
+    const teammates = new Set(results.map((r) => r.teammate));
+    expect(teammates.size).toBeGreaterThanOrEqual(1);
+  });
+
+  it("deduplicates recency results with semantic results", async () => {
+    const beacon = join(testDir, "beacon");
+    const weeklyDir = join(beacon, "memory", "weekly");
+    await mkdir(weeklyDir, { recursive: true });
+    await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+    await writeFile(
+      join(weeklyDir, "2026-W11.md"),
+      "# Week 11\nSearch implementation details.",
+    );
+
+    // Build index that includes the weekly file
+    const indexer = createIndexer(testDir);
+    await indexer.indexTeammate("beacon");
+
+    const results = await search("search implementation", {
+      teammatesDir: testDir,
+      teammate: "beacon",
+      skipSync: true,
+      recencyDepth: 2,
+    });
+
+    // The weekly file should appear only once despite being picked up by both passes
+    const weeklyUris = results.filter(
+      (r) => r.uri === "beacon/memory/weekly/2026-W11.md",
+    );
+    expect(weeklyUris).toHaveLength(1);
+  });
+
+  it("applies typed memory boost", async () => {
+    const beacon = join(testDir, "beacon");
+    const memDir = join(beacon, "memory");
+    await mkdir(memDir, { recursive: true });
+    await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+    await writeFile(join(beacon, "WISDOM.md"), "# Some wisdom about testing");
+    await writeFile(
+      join(memDir, "feedback_testing.md"),
+      "# Testing feedback\nAlways verify test output carefully.",
+    );
+
+    const indexer = createIndexer(testDir);
+    await indexer.indexTeammate("beacon");
+
+    const results = await search("testing", {
+      teammatesDir: testDir,
+      teammate: "beacon",
+      skipSync: true,
+      typedMemoryBoost: 1.5,
+    });
+
+    // Find typed memory results — they should have boosted scores
+    const typedResults = results.filter(
+      (r) => r.contentType === "typed_memory",
+    );
+    if (typedResults.length > 0) {
+      // Just verify the contentType was set correctly
+      expect(typedResults[0].contentType).toBe("typed_memory");
+    }
+  });
+});
+
+describe("multiSearch", () => {
+  it("merges results from primary and additional queries", async () => {
+    const beacon = join(testDir, "beacon");
+    const memDir = join(beacon, "memory");
+    await mkdir(memDir, { recursive: true });
+    await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+    await writeFile(join(beacon, "WISDOM.md"), "# Wisdom about architecture");
+    await writeFile(
+      join(memDir, "feedback_code_review.md"),
+      "# Code review feedback\nAlways review pull requests thoroughly.",
+    );
+
+    const indexer = createIndexer(testDir);
+    await indexer.indexTeammate("beacon");
+
+    const results = await multiSearch("architecture", {
+      teammatesDir: testDir,
+      teammate: "beacon",
+      skipSync: true,
+      additionalQueries: ["code review"],
+    });
+
+    expect(results.length).toBeGreaterThan(0);
+  });
+
+  it("deduplicates by URI — highest score wins", async () => {
+    const beacon = join(testDir, "beacon");
+    await mkdir(beacon, { recursive: true });
+    await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+    await writeFile(
+      join(beacon, "WISDOM.md"),
+      "# Wisdom about testing and code quality",
+    );
+
+    const indexer = createIndexer(testDir);
+    await indexer.indexTeammate("beacon");
+
+    const results = await multiSearch("testing", {
+      teammatesDir: testDir,
+      teammate: "beacon",
+      skipSync: true,
+      additionalQueries: ["testing code quality"],
+    });
+
+    // Check no duplicate URIs
+    const uris = results.map((r) => r.uri);
+    const uniqueUris = new Set(uris);
+    expect(uris.length).toBe(uniqueUris.size);
+  });
+
+  it("merges catalog matches into results", async () => {
+    const beacon = join(testDir, "beacon");
+    await mkdir(beacon, { recursive: true });
+    await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+    await writeFile(join(beacon, "WISDOM.md"), "# Wisdom");
+
+    const indexer = createIndexer(testDir);
+    await indexer.indexTeammate("beacon");
+
+    const catalogMatches: SearchResult[] = [
+      {
+        teammate: "beacon",
+        uri: "beacon/memory/project_goals.md",
+        text: "# Project Goals\nBuild the best recall system.",
+        score: 0.92,
+        contentType: "typed_memory",
+      },
+    ];
+
+    const results = await multiSearch("goals", {
+      teammatesDir: testDir,
+      teammate: "beacon",
+      skipSync: true,
+      catalogMatches,
+    });
+
+    const goalResult = results.find(
+      (r) => r.uri === "beacon/memory/project_goals.md",
+    );
+    expect(goalResult).toBeDefined();
+    expect(goalResult!.score).toBe(0.92);
+  });
+
+  it("additional queries skip recency pass (recencyDepth: 0)", async () => {
+    const beacon = join(testDir, "beacon");
+    const weeklyDir = join(beacon, "memory", "weekly");
+    await mkdir(weeklyDir, { recursive: true });
+    await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+    await writeFile(
+      join(weeklyDir, "2026-W11.md"),
+      "# Week 11\nDid some work.",
+    );
+
+    const results = await multiSearch("work", {
+      teammatesDir: testDir,
+      teammate: "beacon",
+      skipSync: true,
+      recencyDepth: 2,
+      additionalQueries: ["more work"],
+    });
+
+    // Weekly should appear at most once (from primary, not duplicated from additional)
+    const weeklyResults = results.filter(
+      (r) => r.uri === "beacon/memory/weekly/2026-W11.md",
+    );
+    expect(weeklyResults.length).toBeLessThanOrEqual(1);
+  });
+
+  it("returns empty when no index and no catalog matches", async () => {
+    const beacon = join(testDir, "beacon");
+    await mkdir(beacon, { recursive: true });
+    await writeFile(join(beacon, "SOUL.md"), "# Beacon");
+
+    const results = await multiSearch("anything", {
+      teammatesDir: testDir,
+      teammate: "beacon",
+      skipSync: true,
+    });
+
+    expect(results).toEqual([]);
+  });
+});

package/src/search.ts

@@ -45,7 +45,7 @@ export interface SearchResult {
 /**
  * Classify a URI into a content type for priority scoring.
  */
-function classifyUri(uri: string): string {
+export function classifyUri(uri: string): string {
   if (uri.includes("/memory/weekly/")) return "weekly";
   if (uri.includes("/memory/monthly/")) return "monthly";
   // Typed memories are in memory/ but not daily logs (YYYY-MM-DD) and not in subdirs