cozo-memory 1.0.9 → 1.1.1

package/dist/index.js

@@ -88,6 +88,8 @@ class MemoryServer {
     }
     async janitorCleanup(args) {
         await this.initPromise;
+        console.error(`[Janitor] Starting cleanup (auto-compressing sessions first)...`);
+        await this.compressSessions({ model: args.model });
         const olderThanDays = Math.max(1, Math.floor(args.older_than_days ?? 30));
         const maxObservations = Math.max(1, Math.floor(args.max_observations ?? 20));
         const minEntityDegree = Math.max(0, Math.floor(args.min_entity_degree ?? 2));
@@ -333,6 +335,69 @@ class MemoryServer {
             results,
         };
     }
+    async compressSessions(args) {
+        const model = args.model ?? "demyagent-4b-i1:Q6_K";
+        const inactiveThreshold = Date.now() - 30 * 60 * 1000; // 30 minutes
+        try {
+            // 1. Find inactive open sessions
+            const inactiveRes = await this.db.run(`?[session_id, last_active, metadata] := *session_state{session_id, last_active, status, metadata}, status == 'open', last_active < $threshold`, { threshold: inactiveThreshold });
+            if (inactiveRes.rows.length === 0) {
+                console.error(`[Janitor] No inactive sessions found for compression.`);
+                return;
+            }
+            console.error(`[Janitor] Found ${inactiveRes.rows.length} inactive sessions to compress.`);
+            for (const row of inactiveRes.rows) {
+                const sessionId = row[0];
+                const lastActive = row[1];
+                const metadata = row[2];
+                // 2. Fetch observations for this session
+                const obsRes = await this.db.run(`?[text] := *observation{session_id: $session_id, text, @ "NOW"}`, { session_id: sessionId });
+                if (obsRes.rows.length > 0) {
+                    const sessionLogs = obsRes.rows.map((r) => r[0]);
+                    // 3. Summarize using LLM
+                    const systemPrompt = "You are a memory consolidation service. Summarize the following session logs into exactly 2-3 concise bullet points for long-term storage. Respond ONLY with the bullet points.";
+                    const userPrompt = `Session Logs for ${sessionId}:\n\n` + sessionLogs.join('\n');
+                    let summaryText;
+                    try {
+                        const ollamaMod = await import("ollama");
+                        const ollamaClient = ollamaMod?.default ?? ollamaMod;
+                        const response = await ollamaClient.chat({
+                            model,
+                            messages: [
+                                { role: "system", content: systemPrompt },
+                                { role: "user", content: userPrompt },
+                            ],
+                        });
+                        summaryText = response?.message?.content?.trim?.() ?? "";
+                    }
+                    catch (e) {
+                        console.warn(`[Janitor] LLM failed for session ${sessionId}: ${e.message}. Using basic concatenation.`);
+                        summaryText = sessionLogs.join('\n').slice(0, 500);
+                    }
+                    if (summaryText) {
+                        // 4. Write compression summary to global user profile
+                        await this.addObservation({
+                            entity_id: "global_user_profile",
+                            text: `Session Summary (${sessionId}):\n${summaryText}`,
+                            metadata: {
+                                kind: "session_compression",
+                                original_session_id: sessionId,
+                                summarized_at: new Date().toISOString()
+                            }
+                        });
+                    }
+                }
+                // 5. Mark session as compressed
+                await this.db.run(`?[session_id, last_active, status, metadata] <- $data
+           :put session_state {session_id, last_active, status, metadata}`, {
+                    data: [[sessionId, lastActive, "compressed", metadata]]
+                });
+            }
+        }
+        catch (e) {
+            console.error(`[Janitor] Session compression error:`, e.message);
+        }
+    }
     async advancedSearch(args) {
         await this.initPromise;
         return this.hybridSearch.advancedSearch(args);
@@ -699,7 +764,7 @@ class MemoryServer {
             // Observation Table
             if (!relations.includes("observation")) {
                 try {
-                    await this.db.run(`{:create observation {id: String, created_at: Validity => entity_id: String, text: String, embedding: <F32; ${EMBEDDING_DIM}>, metadata: Json}}`);
+                    await this.db.run(`{:create observation {id: String, created_at: Validity => entity_id: String, session_id: String, task_id: String, text: String, embedding: <F32; ${EMBEDDING_DIM}>, metadata: Json}}`);
                     console.error("[Schema] Observation table created.");
                 }
                 catch (e) {
@@ -707,8 +772,11 @@ class MemoryServer {
                 }
             }
             else {
+                const columnsRes = await this.db.run(`::columns observation`);
+                const columns = columnsRes.rows.map((r) => r[0]);
                 const timeTravelReady = await this.isTimeTravelReady("observation");
-                if (!timeTravelReady) {
+                if (!columns.includes("session_id") || !columns.includes("task_id") || !timeTravelReady) {
+                    console.error("[Schema] Migrating observation table for Session/Task support...");
                     // Drop indices before migration
                     try {
                         await this.db.run("::hnsw drop observation:semantic");
@@ -722,13 +790,26 @@ class MemoryServer {
                         await this.db.run("::lsh drop observation:lsh");
                     }
                     catch (e) { }
-                    await this.db.run(`
-            ?[id, created_at, entity_id, text, embedding, metadata] :=
-              *observation{id, entity_id, text, embedding, metadata, created_at: created_at_raw},
-              created_at = [created_at_raw, true]
-            :replace observation {id: String, created_at: Validity => entity_id: String, text: String, embedding: <F32; ${EMBEDDING_DIM}>, metadata: Json}
-          `);
-                    console.error("[Schema] Observation table migrated (Validity).");
+                    if (!timeTravelReady) {
+                        await this.db.run(`
+              ?[id, created_at, entity_id, session_id, task_id, text, embedding, metadata] :=
+                *observation{id, entity_id, text, embedding, metadata, created_at: created_at_raw},
+                created_at = [created_at_raw, true],
+                session_id = "",
+                task_id = ""
+              :replace observation {id: String, created_at: Validity => entity_id: String, session_id: String, task_id: String, text: String, embedding: <F32; ${EMBEDDING_DIM}>, metadata: Json}
+            `);
+                    }
+                    else {
+                        await this.db.run(`
+              ?[id, created_at, entity_id, session_id, task_id, text, embedding, metadata] :=
+                *observation{id, entity_id, text, embedding, metadata, created_at},
+                session_id = "",
+                task_id = ""
+              :replace observation {id: String, created_at: Validity => entity_id: String, session_id: String, task_id: String, text: String, embedding: <F32; ${EMBEDDING_DIM}>, metadata: Json}
+            `);
+                    }
+                    console.error("[Schema] Observation table migrated (Session/Task/Validity).");
                 }
             }
             try {
@@ -867,6 +948,26 @@ class MemoryServer {
                     console.error("[Schema] Snapshot table error:", e.message);
                 }
             }
+            // Session State Table
+            if (!relations.includes("session_state")) {
+                try {
+                    await this.db.run('{:create session_state {session_id: String => last_active: Int, status: String, metadata: Json}}');
+                    console.error("[Schema] Session State table created.");
+                }
+                catch (e) {
+                    console.error("[Schema] Session State table error:", e.message);
+                }
+            }
+            // Task State Table
+            if (!relations.includes("task_state")) {
+                try {
+                    await this.db.run('{:create task_state {task_id: String => status: String, session_id: String, metadata: Json}}');
+                    console.error("[Schema] Task State table created.");
+                }
+                catch (e) {
+                    console.error("[Schema] Task State table error:", e.message);
+                }
+            }
             if (!relations.includes("inference_rule")) {
                 try {
                     await this.db.run('{:create inference_rule {id: String => name: String, datalog: String, created_at: Int}}');
@@ -1302,11 +1403,37 @@ class MemoryServer {
                 }
             }
             const now = Date.now() * 1000;
+            const session_id = args.session_id ?? "";
+            const task_id = args.task_id ?? "";
             await this.db.run(`
-        ?[id, created_at, entity_id, text, embedding, metadata] <- [
-          [$id, [${now}, true], $entity_id, $text, $embedding, $metadata]
-        ] :insert observation {id, created_at => entity_id, text, embedding, metadata}
-      `, { id, entity_id: entityId, text: args.text, embedding, metadata: args.metadata || {} });
+        ?[id, created_at, entity_id, session_id, task_id, text, embedding, metadata] <- [
+          [$id, [${now}, true], $entity_id, $session, $task, $text, $embedding, $metadata]
+        ] :insert observation {id, created_at => entity_id, session_id, task_id, text, embedding, metadata}
+      `, {
+                id,
+                entity_id: entityId,
+                session: session_id,
+                task: task_id,
+                text: args.text,
+                embedding,
+                metadata: args.metadata || {}
+            });
+            // Update session activity if session_id is provided
+            if (session_id) {
+                try {
+                    await this.db.run(`
+            ?[id, last_active, status, metadata] :=
+              *session_state{id, metadata},
+              id = $id,
+              last_active = $now,
+              status = "active"
+            :update session_state {id => last_active, status, metadata}
+          `, { id: session_id, now: Math.floor(now / 1000000) });
+                }
+                catch (e) {
+                    console.warn(`[AddObservation] Session activity update failed for ${session_id}:`, e.message);
+                }
+            }
             // Optional: Automatic inference after new observation (in background)
             const suggestionsRaw = await this.inferenceEngine.inferRelations(entityId);
             const suggestions = await this.formatInferredRelationsForContext(suggestionsRaw);
@@ -1314,6 +1441,8 @@ class MemoryServer {
             return {
                 id,
                 entity_id: entityId,
+                session_id,
+                task_id,
                 created_at: now,
                 created_at_iso,
                 status: "Observation saved",
@@ -1324,6 +1453,61 @@ class MemoryServer {
             return { error: error.message || "Unknown error" };
         }
     }
+    async startSession(args) {
+        await this.initPromise;
+        const id = (0, uuid_1.v4)();
+        const now = Math.floor(Date.now() / 1000);
+        const name = args.name || `Session ${new Date().toISOString()}`;
+        // Create a Session entity first
+        await this.createEntity({
+            name,
+            type: "Session",
+            metadata: { session_id: id, ...args.metadata }
+        });
+        await this.db.run(`
+      ?[session_id, last_active, status, metadata] <- [[$id, $now, "active", $metadata]]
+      :insert session_state {session_id => last_active, status, metadata}
+    `, { id, now, metadata: args.metadata || {} });
+        return { id, name, status: "Session started" };
+    }
+    async stopSession(args) {
+        await this.initPromise;
+        await this.db.run(`
+      ?[session_id, last_active, status, metadata] :=
+        *session_state{session_id, last_active, metadata},
+        session_id = $id,
+        status = "closed"
+      :update session_state {session_id => last_active, status, metadata}
+    `, { id: args.id });
+        return { id: args.id, status: "Session closed" };
+    }
+    async startTask(args) {
+        await this.initPromise;
+        const id = (0, uuid_1.v4)();
+        const sessionId = args.session_id || "";
+        // Create a Task entity
+        await this.createEntity({
+            name: args.name,
+            type: "Task",
+            metadata: { task_id: id, session_id: sessionId, ...args.metadata }
+        });
+        await this.db.run(`
+      ?[task_id, status, session_id, metadata] <- [[$id, "active", $session, $metadata]]
+      :insert task_state {task_id => status, session_id, metadata}
+    `, { id, session: sessionId, metadata: args.metadata || {} });
+        return { id, name: args.name, session_id: sessionId, status: "Task started" };
+    }
+    async stopTask(args) {
+        await this.initPromise;
+        await this.db.run(`
+      ?[task_id, status, session_id, metadata] :=
+        *task_state{task_id, session_id, metadata},
+        task_id = $id,
+        status = "completed"
+      :update task_state {task_id => status, session_id, metadata}
+    `, { id: args.id });
+        return { id: args.id, status: "Task stopped" };
+    }
     async createRelation(args) {
         if (args.from_id === args.to_id) {
             return { error: "Self-references in relationships are not allowed" };
@@ -2162,14 +2346,16 @@ ids[id] <- $ids
                         const now = Date.now() * 1000;
                         allParams[`obs_id${suffix}`] = id;
                         allParams[`obs_entity_id${suffix}`] = entity_id;
+                        allParams[`obs_session_id${suffix}`] = params.session_id || "";
+                        allParams[`obs_task_id${suffix}`] = params.task_id || "";
                         allParams[`obs_text${suffix}`] = text || "";
                         allParams[`obs_embedding${suffix}`] = embedding;
                         allParams[`obs_metadata${suffix}`] = metadata || {};
                         statements.push(`
               {
-                ?[id, created_at, entity_id, text, embedding, metadata] <- [
-                  [$obs_id${suffix}, [${now}, true], $obs_entity_id${suffix}, $obs_text${suffix}, $obs_embedding${suffix}, $obs_metadata${suffix}]
-                ] :insert observation {id, created_at => entity_id, text, embedding, metadata}
+                ?[id, created_at, entity_id, session_id, task_id, text, embedding, metadata] <- [
+                  [$obs_id${suffix}, [${now}, true], $obs_entity_id${suffix}, $obs_session_id${suffix}, $obs_task_id${suffix}, $obs_text${suffix}, $obs_embedding${suffix}, $obs_metadata${suffix}]
+                ] :insert observation {id, created_at => entity_id, session_id, task_id, text, embedding, metadata}
               }
             `);
                         results.push({ action: "add_observation", id, entity_id });
@@ -2445,6 +2631,8 @@ ids[id] <- $ids
                 text: zod_1.z.string().describe("The fact or observation"),
                 metadata: MetadataSchema.optional().describe("Additional metadata"),
                 deduplicate: zod_1.z.boolean().optional().default(true).describe("Skip exact duplicates"),
+                session_id: zod_1.z.string().optional().describe("Associated session ID"),
+                task_id: zod_1.z.string().optional().describe("Associated task ID"),
             }).passthrough().refine((v) => Boolean(v.entity_id) || Boolean(v.entity_name), {
                 message: "entity_id or entity_name is required",
                 path: ["entity_id"],
@@ -2536,10 +2724,29 @@ ids[id] <- $ids
                 message: "file_path or content is required for ingest_file",
                 path: ["file_path"],
             }),
+            zod_1.z.object({
+                action: zod_1.z.literal("start_session"),
+                name: zod_1.z.string().optional().describe("Optional name for the session"),
+                metadata: MetadataSchema.optional().describe("Additional metadata"),
+            }).passthrough(),
+            zod_1.z.object({
+                action: zod_1.z.literal("stop_session"),
+                id: zod_1.z.string().describe("ID of the session to stop"),
+            }).passthrough(),
+            zod_1.z.object({
+                action: zod_1.z.literal("start_task"),
+                name: zod_1.z.string().describe("Name of the task"),
+                session_id: zod_1.z.string().optional().describe("Optional session ID this task belongs to"),
+                metadata: MetadataSchema.optional().describe("Additional metadata"),
+            }).passthrough(),
+            zod_1.z.object({
+                action: zod_1.z.literal("stop_task"),
+                id: zod_1.z.string().describe("ID of the task to stop"),
+            }).passthrough(),
         ]);
         const MutateMemoryParameters = zod_1.z.object({
             action: zod_1.z
-                .enum(["create_entity", "update_entity", "delete_entity", "add_observation", "create_relation", "run_transaction", "add_inference_rule", "ingest_file"])
+                .enum(["create_entity", "update_entity", "delete_entity", "add_observation", "create_relation", "run_transaction", "add_inference_rule", "ingest_file", "start_session", "stop_session", "start_task", "stop_task"])
                 .describe("Action (determines which fields are required)"),
             name: zod_1.z.string().optional().describe("For create_entity (required) or add_inference_rule (required)"),
             type: zod_1.z.string().optional().describe("For create_entity (required)"),
@@ -2587,6 +2794,10 @@ Supported actions:
   Example (Manager Transitivity):
   '?[from_id, to_id, relation_type, confidence, reason] := *relationship{from_id: $id, to_id: mid, relation_type: "manager_of", @ "NOW"}, *relationship{from_id: mid, to_id: target, relation_type: "manager_of", @ "NOW"}, from_id = $id, to_id = target, relation_type = "ober_manager_von", confidence = 0.6, reason = "Transitive Manager Path"'
 - 'ingest_file': Bulk import of documents (Markdown/JSON). Supports chunking (paragraphs) and automatic entity creation. Params: { entity_id | entity_name (required), format, content, ... }. Ideal for quickly populating memory from existing notes.
+- 'start_session': Initializes a new session for context tracking. Params: { name?: string, metadata?: object }.
+- 'stop_session': Closes a session. Params: { id: string }.
+- 'start_task': Initializes a new task within a session. Params: { name: string, session_id?: string, metadata?: object }.
+- 'stop_task': Marks a task as completed. Params: { id: string }.
 
 Validation: Invalid syntax or missing columns in inference rules will result in errors.`,
             parameters: MutateMemoryParameters,
@@ -2620,6 +2831,14 @@ Validation: Invalid syntax or missing columns in inference rules will result in
                     return JSON.stringify(await this.addInferenceRule(rest));
                 if (action === "ingest_file")
                     return JSON.stringify(await this.ingestFile(rest));
+                if (action === "start_session")
+                    return JSON.stringify(await this.startSession(rest));
+                if (action === "stop_session")
+                    return JSON.stringify(await this.stopSession(rest));
+                if (action === "start_task")
+                    return JSON.stringify(await this.startTask(rest));
+                if (action === "stop_task")
+                    return JSON.stringify(await this.stopTask(rest));
                 return JSON.stringify({ error: "Unknown action" });
             },
         });
@@ -2631,6 +2850,9 @@ Validation: Invalid syntax or missing columns in inference rules will result in
                 entity_types: zod_1.z.array(zod_1.z.string()).optional().describe("Filter by entity types"),
                 include_entities: zod_1.z.boolean().optional().default(true).describe("Include entities in search"),
                 include_observations: zod_1.z.boolean().optional().default(true).describe("Include observations in search"),
+                rerank: zod_1.z.boolean().optional().default(false).describe("Use Cross-Encoder reranking for higher precision"),
+                session_id: zod_1.z.string().optional().describe("Prioritize results from this session"),
+                task_id: zod_1.z.string().optional().describe("Prioritize results from this task"),
             }),
             zod_1.z.object({
                 action: zod_1.z.literal("advancedSearch"),
@@ -2658,6 +2880,9 @@ Validation: Invalid syntax or missing columns in inference rules will result in
                 vectorParams: zod_1.z.object({
                     efSearch: zod_1.z.number().optional().describe("HNSW search precision"),
                 }).optional().describe("Vector parameters"),
+                rerank: zod_1.z.boolean().optional().default(false).describe("Use Cross-Encoder reranking for higher precision"),
+                session_id: zod_1.z.string().optional().describe("Prioritize results from this session"),
+                task_id: zod_1.z.string().optional().describe("Prioritize results from this task"),
             }),
             zod_1.z.object({
                 action: zod_1.z.literal("context"),
@@ -2679,6 +2904,7 @@ Validation: Invalid syntax or missing columns in inference rules will result in
                 query: zod_1.z.string().describe("Search query for initial vector seeds"),
                 max_depth: zod_1.z.number().min(1).max(3).optional().default(2).describe("Maximum depth of graph expansion (Default: 2)"),
                 limit: zod_1.z.number().optional().default(10).describe("Number of initial vector seeds"),
+                rerank: zod_1.z.boolean().optional().default(false).describe("Use Cross-Encoder reranking for higher precision"),
             }),
             zod_1.z.object({
                 action: zod_1.z.literal("graph_walking"),
@@ -2691,6 +2917,9 @@ Validation: Invalid syntax or missing columns in inference rules will result in
                 action: zod_1.z.literal("agentic_search"),
                 query: zod_1.z.string().describe("Context query for agentic routing"),
                 limit: zod_1.z.number().optional().default(10).describe("Maximum number of results"),
+                rerank: zod_1.z.boolean().optional().default(false).describe("Use Cross-Encoder reranking for higher precision"),
+                session_id: zod_1.z.string().optional().describe("Prioritize results from this session"),
+                task_id: zod_1.z.string().optional().describe("Prioritize results from this task"),
             }),
         ]);
         const QueryMemoryParameters = zod_1.z.object({
@@ -2699,6 +2928,8 @@ Validation: Invalid syntax or missing columns in inference rules will result in
                 .describe("Action (determines which fields are required)"),
             query: zod_1.z.string().optional().describe("Required for search/advancedSearch/context/graph_rag/graph_walking/agentic_search"),
             limit: zod_1.z.number().optional().describe("Only for search/advancedSearch/graph_rag/graph_walking"),
+            session_id: zod_1.z.string().optional().describe("Optional session ID for context boosting"),
+            task_id: zod_1.z.string().optional().describe("Optional task ID for context boosting"),
             filters: zod_1.z.any().optional().describe("Only for advancedSearch"),
             graphConstraints: zod_1.z.any().optional().describe("Only for advancedSearch"),
             vectorOptions: zod_1.z.any().optional().describe("Only for advancedSearch"),
@@ -2711,6 +2942,7 @@ Validation: Invalid syntax or missing columns in inference rules will result in
             as_of: zod_1.z.string().optional().describe("Only for entity_details: ISO string or 'NOW'"),
             max_depth: zod_1.z.number().optional().describe("Only for graph_rag/graph_walking: Maximum expansion depth"),
             start_entity_id: zod_1.z.string().optional().describe("Only for graph_walking: Start entity"),
+            rerank: zod_1.z.boolean().optional().describe("Only for search/advancedSearch/agentic_search: Enable Cross-Encoder reranking"),
         });
         this.mcp.addTool({
             name: "query_memory",
@@ -2745,6 +2977,9 @@ Notes: 'agentic_search' is the most powerful and adaptable, 'context' is ideal f
                         entityTypes: input.entity_types,
                         includeEntities: input.include_entities,
                         includeObservations: input.include_observations,
+                        rerank: input.rerank,
+                        session_id: input.session_id,
+                        task_id: input.task_id,
                     });
                     const conflictEntityIds = Array.from(new Set(results
                         .map((r) => (r.name ? r.id : r.entity_id))
@@ -2776,6 +3011,9 @@ Notes: 'agentic_search' is the most powerful and adaptable, 'context' is ideal f
                         filters: input.filters,
                         graphConstraints: input.graphConstraints,
                         vectorParams: input.vectorParams,
+                        rerank: input.rerank,
+                        session_id: input.session_id,
+                        task_id: input.task_id,
                     });
                     const conflictEntityIds = Array.from(new Set(results
                         .map((r) => (r.name ? r.id : r.entity_id))
@@ -2888,6 +3126,7 @@ Notes: 'agentic_search' is the most powerful and adaptable, 'context' is ideal f
                     const results = await this.hybridSearch.agenticRetrieve({
                         query: input.query,
                         limit: input.limit,
+                        rerank: input.rerank,
                     });
                     return JSON.stringify(results);
                 }
@@ -2900,7 +3139,8 @@ Notes: 'agentic_search' is the most powerful and adaptable, 'context' is ideal f
                         limit: input.limit,
                         graphConstraints: {
                             maxDepth: input.max_depth
-                        }
+                        },
+                        rerank: input.rerank,
                     });
                     return JSON.stringify(results);
                 }
@@ -3698,6 +3938,7 @@ Note: Use 'mutate_memory' with action='add_observation' and entity_id='global_us
         });
     }
     async start() {
+        await this.initPromise;
         await this.mcp.start({ transportType: "stdio" });
         console.error("Cozo Memory MCP Server running on stdio");
     }

package/dist/reranker-service.js

@@ -0,0 +1,125 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RerankerService = void 0;
+const transformers_1 = require("@xenova/transformers");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+// Robust path to project root
+const PROJECT_ROOT = path.resolve(__dirname, '..');
+const CACHE_DIR = path.resolve(PROJECT_ROOT, '.cache');
+transformers_1.env.cacheDir = CACHE_DIR;
+transformers_1.env.allowLocalModels = true;
+class RerankerService {
+    pipe = null;
+    modelId;
+    initialized = false;
+    constructor() {
+        // Using a tiny but effective cross-encoder
+        this.modelId = process.env.RERANKER_MODEL || "Xenova/ms-marco-MiniLM-L-6-v2";
+        console.error(`[RerankerService] Using model: ${this.modelId}`);
+    }
+    async init() {
+        if (this.initialized)
+            return;
+        try {
+            // Check if model exists locally in cache
+            const parts = this.modelId.split('/');
+            const namespace = parts[0];
+            const modelName = parts[1];
+            const modelDir = path.join(CACHE_DIR, namespace, modelName);
+            if (!fs.existsSync(modelDir)) {
+                console.log(`[RerankerService] Model not found, downloading ${this.modelId}...`);
+            }
+            // We use the sequence-classification task for cross-encoders
+            this.pipe = await (0, transformers_1.pipeline)('sequence-classification', this.modelId, {
+                quantized: true,
+                // @ts-ignore
+                progress_callback: (info) => {
+                    if (info.status === 'done') {
+                        console.error(`[RerankerService] Loaded shard: ${info.file}`);
+                    }
+                }
+            });
+            this.initialized = true;
+            console.error(`[RerankerService] Initialization complete.`);
+        }
+        catch (error) {
+            console.error(`[RerankerService] Initialization failed:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Reranks a list of documents based on a query.
+     * @param query The search query
+     * @param documents Array of document strings to rank
+     * @returns Array of { index, score } sorted by score descending
+     */
+    async rerank(query, documents) {
+        if (documents.length === 0)
+            return [];
+        await this.init();
+        try {
+            const results = [];
+            // Cross-encoders take pairs of [query, document]
+            // We can process them in a single batch
+            const inputs = documents.map(doc => [query, doc]);
+            // @ts-ignore
+            const outputs = await this.pipe(inputs, {
+                topk: 1 // We want the score for the "relevant" class (usually index 1 or the only output)
+            });
+            // Handle both array of results and single result (if only 1 doc)
+            const outputArray = Array.isArray(outputs) ? outputs : [outputs];
+            for (let i = 0; i < outputArray.length; i++) {
+                // Cross-encoders for ms-marco typically output a single logit/score or a 2-class distribution
+                // transformers.js sequence-classification returns { label: string, score: number }[]
+                // For ms-marco, label 'LABEL_1' is usually the relevance score
+                const out = outputArray[i];
+                results.push({
+                    index: i,
+                    score: out.score || 0
+                });
+            }
+            // Sort by score descending
+            return results.sort((a, b) => b.score - a.score);
+        }
+        catch (error) {
+            console.error(`[RerankerService] Reranking failed:`, error);
+            // Fallback: return original order with neutral scores
+            return documents.map((_, i) => ({ index: i, score: 0 }));
+        }
+    }
+}
+exports.RerankerService = RerankerService;

package/dist/test-multi-level-memory.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+async function testMultiLevelMemory() {
+    console.log("=== Testing Multi-Level Memory (v2.0) ===\n");
+    const server = new index_1.MemoryServer();
+    await server.start();
+    try {
+        // 1. Session Management
+        console.log("--- 1. Testing Session Management ---");
+        const sessionRes = await server.startSession({ name: "Research Session", metadata: { user: "test_user" } });
+        const sessionId = sessionRes.id;
+        console.log(`Started session: ${sessionId}`);
+        // 2. Task Management
+        console.log("\n--- 2. Testing Task Management ---");
+        const taskRes = await server.startTask({ name: "Analyze Multi-Level Memory", session_id: sessionId });
+        const taskId = taskRes.id;
+        console.log(`Started task: ${taskId}`);
+        // 3. Observations with Context
+        console.log("\n--- 3. Adding observations with session and task IDs ---");
+        await server.addObservation({
+            entity_name: "Multi-Level Memory",
+            entity_type: "Concept",
+            text: "Multi-Level Memory is implemented in v2.0.",
+            session_id: sessionId,
+            task_id: taskId,
+            metadata: { importance: "high" }
+        });
+        console.log("Added observation for Multi-Level Memory with session and task context.");
+        await server.addObservation({
+            entity_name: "Janitor",
+            entity_type: "Service",
+            text: "Janitor now handles session compression.",
+            session_id: sessionId,
+            metadata: { importance: "medium" }
+        });
+        console.log("Added observation for Janitor with session context.");
+        // 4. Search with Context Boost
+        console.log("\n--- 4. Testing Context-Aware Search (Boosting) ---");
+        console.log("Case A: Search with session and task boost");
+        const searchResA = await server.advancedSearch({
+            query: "Multi-Level Memory",
+            session_id: sessionId,
+            task_id: taskId,
+            limit: 5
+        });
+        console.log("Search results (A):");
+        searchResA.forEach((r, i) => {
+            console.log(`  [${i + 1}] Score: ${r.score.toFixed(4)}, Text: ${r.text || r.name}, Explanation: ${r.explanation}`);
+        });
+        // 5. Session Compression
+        console.log("\n--- 5. Testing Session Compression (Janitor) ---");
+        console.log("Stopping session to prepare for compression...");
+        await server.stopSession({ id: sessionId });
+        console.log("Manually aging session activity in session_state table...");
+        const oldTs = Date.now() - 40 * 60 * 1000; // 40 minutes ago
+        await server['db'].run(`?[session_id, last_active, status, metadata] <- [[$id, $ts, 'open', $meta]]
+       :put session_state {session_id, last_active, status, metadata}`, { id: sessionId, ts: oldTs, meta: { user: "test_user" } });
+        console.log("Running Janitor cleanup with confirm=true...");
+        const janitorRes = await server.janitorCleanup({ confirm: true });
+        console.log("Janitor result:", JSON.stringify(janitorRes, null, 2));
+        // 6. Verify Compression Result
+        console.log("\n--- 6. Verifying compression summary in User Profile ---");
+        const profileRes = await server.advancedSearch({ query: "Session Summary", entityTypes: ["Observation"] });
+        console.log("Profile search results:");
+        profileRes.forEach((r, i) => {
+            if (r.text?.includes(sessionId)) {
+                console.log(`  [MATCH] ${r.text}`);
+            }
+        });
+        console.log("\n=== Multi-Level Memory Test completed successfully ===");
+    }
+    catch (error) {
+        console.error("Test failed:", error);
+    }
+    finally {
+        process.exit(0);
+    }
+}
+testMultiLevelMemory();