cozo-memory 1.1.2 → 1.1.3

package/README.md

@@ -81,6 +81,10 @@ Now you can add the server to your MCP client (e.g. Claude Desktop).
 
 🧹 **Janitor Service** - LLM-backed automatic cleanup with hierarchical summarization, observation pruning, and **automated session compression**
 
+🗜️ **Context Compaction & Auto-Summarization (v2.2)** - Automatic and manual memory consolidation with progressive summarization and LLM-backed Executive Summaries
+
+🧠 **Fact Lifecycle Management (v2.1)** - Native "soft-deletion" via CozoDB Validity retraction; invalidated facts are hidden from current views but preserved in history for audit trails
+
 👤 **User Preference Profiling** - Persistent user preferences with automatic 50% search boost
 
 🔍 **Near-Duplicate Detection** - Automatic LSH-based deduplication to avoid redundancy
@@ -129,6 +133,10 @@ Now you can add the server to your MCP client (e.g. Claude Desktop).
 - **Data Integrity (Trigger Concept)**: Prevents invalid states like self-references in relationships (Self-Loops) directly at creation.
 - **Hierarchical Summarization**: The Janitor condenses old fragments into "Executive Summary" nodes to preserve the "Big Picture" long-term.
 - **User Preference Profiling**: A specialized `global_user_profile` entity stores persistent preferences (likes, work style), which receive a **50% score boost** in every search.
+- **Fact Lifecycle Management (v2.1)**: Uses CozoDB's native **Validity** retraction mechanism to manage the lifecycle of information. Instead of destructive deletions, facts are invalidated by asserting a `[timestamp, false]` record. This ensures:
+  1. **Auditability**: You can always "time-travel" back to see what the system knew at any given point.
+  2. **Consistency**: All standard retrieval (Search, Graph-RAG, Inference) uses the `@ "NOW"` filter to automatically exclude retracted facts.
+  3. **Atomic Retraction**: Invalidation can be part of a multi-statement transaction, allowing for clean "update" patterns (invalidate old + insert new).
 - **All Local**: Embeddings via Transformers/ONNX; no external embedding service required.
 
 ## Positioning & Comparison
@@ -523,10 +531,10 @@ The interface is reduced to **4 consolidated tools**. The concrete operation is
 
 | Tool | Purpose | Key Actions |
 |------|---------|-------------|
-| `mutate_memory` | Write operations | create_entity, update_entity, delete_entity, add_observation, create_relation, start_session, stop_session, start_task, stop_task, run_transaction, add_inference_rule, ingest_file |
+| `mutate_memory` | Write operations | create_entity, update_entity, delete_entity, add_observation, create_relation, start_session, stop_session, start_task, stop_task, run_transaction, add_inference_rule, ingest_file, invalidate_observation, invalidate_relation |
 | `query_memory` | Read operations | search, advancedSearch, context, entity_details, history, graph_rag, graph_walking, agentic_search (Multi-Level Context support) |
 | `analyze_graph` | Graph analysis | explore, communities, pagerank, betweenness, hits, shortest_path, bridge_discovery, semantic_walk, infer_relations |
-| `manage_system` | Maintenance | health, metrics, export_memory, import_memory, snapshot_create, snapshot_list, snapshot_diff, cleanup, reflect, summarize_communities, clear_memory |
+| `manage_system` | Maintenance | health, metrics, export_memory, import_memory, snapshot_create, snapshot_list, snapshot_diff, cleanup, reflect, summarize_communities, clear_memory, compact |
 
 ### mutate_memory (Write)
 
@@ -543,6 +551,8 @@ Actions:
 - `run_transaction`: `{ operations: Array<{ action, params }> }` **(New v1.2)**: Executes multiple operations atomically.
 - `add_inference_rule`: `{ name, datalog }`
 - `ingest_file`: `{ format, file_path?, content?, entity_id?, entity_name?, entity_type?, chunking?, metadata?, observation_metadata?, deduplicate?, max_observations? }`
+- `invalidate_observation`: `{ observation_id }` **(New v2.1)**: Retracts an observation using Validity `[now, false]`.
+- `invalidate_relation`: `{ from_id, to_id, relation_type }` **(New v2.1)**: Retracts a relationship using Validity `[now, false]`.
   - `format` options: `"markdown"`, `"json"`, `"pdf"` **(New v1.9)**
   - `file_path`: Optional path to file on disk (alternative to `content` parameter)
   - `content`: File content as string (required if `file_path` not provided)
@@ -728,6 +738,10 @@ Actions:
 - `snapshot_list`: `{}`
 - `snapshot_diff`: `{ snapshot_id_a, snapshot_id_b }`
 - `cleanup`: `{ confirm, older_than_days?, max_observations?, min_entity_degree?, model? }`
+- `compact`: `{ session_id?, entity_id?, model? }` **(New v2.2)**: Manual context compaction. Supports three modes:
+  - **Session Compaction**: `{ session_id, model? }` - Summarizes session observations into 2-3 bullet points and stores in user profile
+  - **Entity Compaction**: `{ entity_id, model? }` - Compacts entity observations when threshold exceeded, creates Executive Summary
+  - **Global Compaction**: `{}` (no parameters) - Compacts all entities exceeding threshold (default: 20 observations)
 - `summarize_communities`: `{ model?, min_community_size? }` **(New v2.0)**: Triggers the **Hierarchical GraphRAG** pipeline. Recomputes communities, generates thematic summaries via LLM, and stores them as `CommunitySummary` entities.
 - `reflect`: `{ entity_id?, mode?, model? }` Analyzes memory for contradictions and new insights. Supports `summary` (default) and `discovery` (autonomous link refinement) modes.
 - `clear_memory`: `{ confirm }`
@@ -738,6 +752,17 @@ Janitor Cleanup Details:
   - **Hierarchical Summarization**: Detects isolated or old observations, has them summarized by a local LLM (Ollama), and creates a new `ExecutiveSummary` node. Old fragments are deleted to reduce noise while preserving knowledge.
   - **Automated Session Compression**: Automatically identifies inactive sessions, summarizes their activity into a few bullet points, and stores the summary in the User Profile while marking the session as archived.
 
+Context Compaction Details **(New v2.2)**:
+- **Automatic Compaction**: Triggered automatically when observations exceed threshold (default: 20)
+  - Runs in background during `addObservation`
+  - Uses lock mechanism to prevent concurrent compaction
+- **Manual Compaction**: Available via `compact` action in `manage_system`
+  - **Session Mode**: Summarizes session observations and stores in `global_user_profile`
+  - **Entity Mode**: Compacts specific entity with custom threshold
+  - **Global Mode**: Compacts all entities exceeding threshold
+- **Progressive Summarization**: New observations are merged with existing Executive Summaries instead of simple append
+- **LLM Integration**: Uses Ollama (default model: `demyagent-4b-i1:Q6_K`) for intelligent summarization
+
 **Before Janitor:**
 ```
 Entity: Project X

package/dist/db-inspect.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+async function targetedInspect() {
+    const s = new index_1.MemoryServer();
+    await s.initPromise;
+    const entRes = await s.db.run('?[id, name] := *entity{id, name, @ "NOW"}, name == "HeavyEntity"');
+    if (entRes.rows.length === 0) {
+        console.log("HeavyEntity not found.");
+        process.exit(0);
+    }
+    const eid = entRes.rows[0][0];
+    console.log(`Analyzing HeavyEntity (${eid}):`);
+    // 1. Current observations
+    const current = await s.db.run('?[id, text, meta] := *observation{entity_id: $eid, id, text, metadata: meta, @ "NOW"}', { eid });
+    console.log(`Current Count: ${current.rows.length}`);
+    current.rows.forEach((r) => console.log(`- [${r[0]}] ${r[1]} (Meta: ${JSON.stringify(r[2])})`));
+    // 2. All history (to see if things were invalidated)
+    const history = await s.db.run('?[id, text, cat] := *observation{entity_id: $eid, id, text, created_at: cat}');
+    console.log(`\nHistory Count: ${history.rows.length}`);
+    // Just a few history samples
+    history.rows.slice(0, 10).forEach((r) => console.log(`- [${r[0]}] ${r[1]} @ ${JSON.stringify(r[2])}`));
+    process.exit(0);
+}
+targetedInspect();

package/dist/hybrid-search.js

@@ -204,7 +204,7 @@ class HybridSearch {
             semanticCall += `, filter: ${hnswFilters.join(" && ")}`;
         }
         semanticCall += `}`;
-        let bodyConstraints = [semanticCall, `*entity{id, name, type, metadata, created_at}`];
+        let bodyConstraints = [semanticCall, `*entity{id, name, type, metadata, created_at, @ "NOW"}`];
         if (metaJoins.length > 0) {
             bodyConstraints.push(...metaJoins);
         }
@@ -232,10 +232,10 @@ class HybridSearch {
             `rank_val[id, r] := *entity{id, @ "NOW"}, not *entity_rank{entity_id: id}, r = 0.0`
         ];
         if (graphConstraints?.requiredRelations && graphConstraints.requiredRelations.length > 0) {
-            helperRules.push(`rel_match[id, rel_type] := *relationship{from_id: id, relation_type: rel_type}`, `rel_match[id, rel_type] := *relationship{to_id: id, relation_type: rel_type}`);
+            helperRules.push(`rel_match[id, rel_type] := *relationship{from_id: id, relation_type: rel_type, @ "NOW"}`, `rel_match[id, rel_type] := *relationship{to_id: id, relation_type: rel_type, @ "NOW"}`);
         }
         if (graphConstraints?.targetEntityIds && graphConstraints.targetEntityIds.length > 0) {
-            helperRules.push(`target_match[id, target_id] := *relationship{from_id: id, to_id: target_id}`, `target_match[id, target_id] := *relationship{to_id: id, from_id: target_id}`);
+            helperRules.push(`target_match[id, target_id] := *relationship{from_id: id, to_id: target_id, @ "NOW"}`, `target_match[id, target_id] := *relationship{to_id: id, from_id: target_id, @ "NOW"}`);
         }
         const datalogQuery = [
             ...helperRules,
@@ -360,7 +360,7 @@ class HybridSearch {
 
       result_entities[id, final_score, depth] := path[seed_id, id, depth], seeds[seed_id, seed_score], rank_val[id, pr], final_score = seed_score * (1.0 - 0.2 * depth)
       
-      ?[id, name, type, metadata, created_at, score, source, text] := result_entities[id, score, depth], *entity{id, name, type, metadata, created_at}, source = 'graph_rag_entity', text = ''
+      ?[id, name, type, metadata, created_at, score, source, text] := result_entities[id, score, depth], *entity{id, name, type, metadata, created_at, @ "NOW"}, source = 'graph_rag_entity', text = ''
       
       :sort -score
       :limit $limit

package/dist/index.js

@@ -28,6 +28,7 @@ class MemoryServer {
     hybridSearch;
     inferenceEngine;
     initPromise;
+    compactionLocks = new Set();
     // Metrics tracking
     metrics = {
         operations: {
@@ -1422,13 +1423,13 @@ class MemoryServer {
             if (session_id) {
                 try {
                     await this.db.run(`
-            ?[id, last_active, status, metadata] :=
-              *session_state{id, metadata},
-              id = $id,
+            ?[session_id, last_active, status, metadata] :=
+              *session_state{session_id, metadata},
+              session_id = $session_id,
               last_active = $now,
               status = "active"
-            :update session_state {id => last_active, status, metadata}
-          `, { id: session_id, now: Math.floor(now / 1000000) });
+            :update session_state {session_id => last_active, status, metadata}
+          `, { session_id: session_id, now: Math.floor(now / 1000000) });
                 }
                 catch (e) {
                     console.warn(`[AddObservation] Session activity update failed for ${session_id}:`, e.message);
@@ -1437,6 +1438,12 @@ class MemoryServer {
             // Optional: Automatic inference after new observation (in background)
             const suggestionsRaw = await this.inferenceEngine.inferRelations(entityId);
             const suggestions = await this.formatInferredRelationsForContext(suggestionsRaw);
+            // Automatic Compaction (Threshold-based)
+            // Skip for compaction-generated observations to prevent recursive loop
+            const metadataKind = args.metadata?.kind;
+            if (metadataKind !== "compaction" && metadataKind !== "session_summary") {
+                this.compactEntity({ entity_id: entityId }).catch(e => console.error(`[AutoCompact] Error for ${entityId}:`, e));
+            }
             const created_at_iso = new Date(Math.floor(now / 1000)).toISOString();
             return {
                 id,
@@ -1472,6 +1479,13 @@ class MemoryServer {
     }
     async stopSession(args) {
         await this.initPromise;
+        // Automatic Session Compaction
+        try {
+            await this.compactSession({ session_id: args.id });
+        }
+        catch (e) {
+            console.warn(`[AutoCompact] Session compaction failed for ${args.id}:`, e.message);
+        }
         await this.db.run(`
       ?[session_id, last_active, status, metadata] :=
         *session_state{session_id, last_active, metadata},
@@ -1796,9 +1810,9 @@ ids[id] <- $ids
         else {
             // Select top 5 entities with the most observations
             const res = await this.db.run(`
-        ?[id, name, type, count(id)] := 
-          *entity{id, name, type, @ "NOW"}, 
-          *observation{entity_id: id, @ "NOW"}
+        ?[eid, ename, etype, count(oid)] := 
+          *entity{id: eid, name: ename, type: etype, @ "NOW"}, 
+          *observation{entity_id: eid, id: oid, @ "NOW"}
       `);
             entitiesToReflect = res.rows
                 .map((r) => ({ id: String(r[0]), name: String(r[1]), type: String(r[2]), count: Number(r[3]) }))
@@ -1859,8 +1873,8 @@ If no special patterns are recognizable, answer with "No new insights".`;
                 for (const candidate of candidates) {
                     // Check if relationship already exists
                     const existing = await this.db.run(`
-            ?[count(from_id)] := *relationship{from_id, to_id, relation_type, @ "NOW"},
-              from_id = $from, to_id = $to, relation_type = $rel
+            ?[count(fid)] := *relationship{from_id: fid, to_id: tid, relation_type: rel, @ "NOW"},
+              fid = $from, tid = $to, rel = $rel
           `, { from: candidate.from_id, to: candidate.to_id, rel: candidate.relation_type });
                     if (Number(existing.rows[0][0]) > 0)
                         continue;
@@ -2191,6 +2205,132 @@ ids[id] <- $ids
             return { error: error.message || "Error during ingest" };
         }
     }
+    async compactSession(args) {
+        await this.initPromise;
+        const model = args.model || "demyagent-4b-i1:Q6_K";
+        try {
+            // 1. Get all observations from this session
+            const obsRes = await this.db.run('?[text, ts] := *observation{session_id: $sid, text, created_at, @ "NOW"}, ts = to_int(created_at) :order ts', {
+                sid: args.session_id
+            });
+            if (obsRes.rows.length < 3) {
+                return { status: "skipped", reason: "Too few observations for session compaction" };
+            }
+            const observations = obsRes.rows.map((r) => r[0]);
+            const systemPrompt = `You are a memory compaction module. Summarize the following session observations into exactly 2-3 concise bullet points. 
+Focus only on core facts, preferences, or important events. Skip conversational filler.
+Format:
+- Bullet Point 1
+- Bullet Point 2
+(- Bullet Point 3)`;
+            const userPrompt = `Session ID: ${args.session_id}\n\nObservations:\n${observations.join("\n")}`;
+            const response = await this.callOllama(model, systemPrompt, userPrompt);
+            if (!response)
+                throw new Error("Ollama summary failed");
+            // 2. Add as preference/long-term info to user profile
+            await this.addObservation({
+                entity_id: exports.USER_ENTITY_ID,
+                text: `Session Summary (${args.session_id}): ${response}`,
+                metadata: { kind: "session_summary", session_id: args.session_id, model },
+                deduplicate: true
+            });
+            return { status: "session_compacted", session_id: args.session_id, summary: response };
+        }
+        catch (error) {
+            console.error(`[CompactSession] Error:`, error);
+            return { error: error.message };
+        }
+    }
+    async compactEntity(args) {
+        if (this.compactionLocks.has(args.entity_id))
+            return { status: "already_compacting" };
+        this.compactionLocks.add(args.entity_id);
+        await this.initPromise;
+        const threshold = args.threshold || 20;
+        const model = args.model || "demyagent-4b-i1:Q6_K";
+        try {
+            // 1. Check count of active observations
+            const countRes = await this.db.run('?[count(oid)] := *observation{entity_id: $eid, id: oid, @ "NOW"}', { eid: args.entity_id });
+            const currentCount = Number(countRes.rows[0][0]);
+            if (currentCount <= threshold) {
+                return { entity_id: args.entity_id, status: "ok", count: currentCount };
+            }
+            console.error(`[CompactEntity] Compacting ${args.entity_id} (Count: ${currentCount})`);
+            // 2. Get older observations (limit to currentCount - threshold/2 to keep some recent context)
+            const toKeep = Math.floor(threshold / 2);
+            const toCompact = currentCount - toKeep;
+            const obsRes = await this.db.run(`
+        ?[oid, txt, ts] := *observation{entity_id: $eid, id: oid, text: txt, created_at, @ "NOW"}, ts = to_int(created_at)
+        :order ts
+        :limit $limit
+      `, { eid: args.entity_id, limit: toCompact });
+            if (obsRes.rows.length === 0)
+                return { entity_id: args.entity_id, status: "no_older_obs_found" };
+            const idsToInvalidate = obsRes.rows.map((r) => String(r[0]));
+            const textsToCompact = obsRes.rows.map((r) => r[1]);
+            // 3. Check for existing ExecutiveSummary
+            const existingSummaryRes = await this.db.run('?[sid, stxt] := *observation{entity_id: $eid, text: stxt, id: sid, @ "NOW"}, regex_matches(stxt, "(?i).*(Executive\\s*Summary|ExecutiveSummary).*") :limit 1', { eid: args.entity_id });
+            let summaryText = "";
+            let oldSummaryId = "";
+            if (existingSummaryRes.rows.length > 0) {
+                oldSummaryId = String(existingSummaryRes.rows[0][0]);
+                summaryText = String(existingSummaryRes.rows[0][1]).replace(/Executive\s*Summary:\s*/i, "").replace(/ExecutiveSummary:\s*/i, "");
+                console.error(`[CompactEntity] Found existing summary to merge: ${oldSummaryId}`);
+            }
+            // 4. Summarize / Merge
+            const systemPrompt = `You are a memory compaction module. You are maintaining an "Executive Summary" for an entity.
+Merge the NEW observations into the EXISTING summary (if present). 
+The summary should be dense, data-rich, and capture all relevant historical facts.
+Keep it structured and concise (max 5-8 sentences).
+Format MUST start with "ExecutiveSummary: " followed by the consolidated content.`;
+            const userPrompt = `Entity ID: ${args.entity_id}\nExisting Summary: ${summaryText || "None"}\n\nNew Info to integrate:\n${textsToCompact.join("\n")}`;
+            console.error(`[CompactEntity] Calling Ollama for ${idsToInvalidate.length} observations...`);
+            const newSummaryText = await this.callOllama(model, systemPrompt, userPrompt);
+            if (!newSummaryText)
+                throw new Error("Ollama compaction failed");
+            // 5. Atomic Update
+            // a) Invalidate old observations
+            for (const oid of idsToInvalidate) {
+                await this.invalidateObservation({ observation_id: oid });
+            }
+            // b) Invalidate old summary if exists
+            if (oldSummaryId) {
+                await this.invalidateObservation({ observation_id: oldSummaryId });
+            }
+            // c) Add new summary
+            await this.addObservation({
+                entity_id: args.entity_id,
+                text: newSummaryText,
+                metadata: { kind: "compaction", model, compacted_count: idsToInvalidate.length }
+            });
+            return { status: "entity_compacted", entity_id: args.entity_id, observations_compacted: idsToInvalidate.length };
+        }
+        catch (error) {
+            console.error(`[CompactEntity] Error for ${args.entity_id}:`, error);
+            return { error: error.message };
+        }
+        finally {
+            this.compactionLocks.delete(args.entity_id);
+        }
+    }
+    async callOllama(model, system, user) {
+        try {
+            const ollamaMod = await import("ollama");
+            const ollamaClient = ollamaMod?.default ?? ollamaMod;
+            const response = await ollamaClient.chat({
+                model,
+                messages: [
+                    { role: "system", content: system },
+                    { role: "user", content: user },
+                ],
+            });
+            return response?.message?.content?.trim?.() ?? null;
+        }
+        catch (e) {
+            console.error(`[OllamaCall] Error:`, e);
+            return null;
+        }
+    }
     async deleteEntity(args) {
         const startTime = Date.now();
         try {
@@ -2203,9 +2343,9 @@ ids[id] <- $ids
             }
             console.error(`[Delete] Entity found: ${entityRes.rows[0][0]}`);
             // 2. Count related data before deletion
-            const obsCount = await this.db.run('?[count(id)] := *observation{id, entity_id, @ "NOW"}, entity_id = $id', { id: args.entity_id });
-            const relOutCount = await this.db.run('?[count(from_id)] := *relationship{from_id, to_id, @ "NOW"}, from_id = $id', { id: args.entity_id });
-            const relInCount = await this.db.run('?[count(to_id)] := *relationship{from_id, to_id, @ "NOW"}, to_id = $id', { id: args.entity_id });
+            const obsCount = await this.db.run('?[count(oid)] := *observation{id: oid, entity_id: $id, @ "NOW"}', { id: args.entity_id });
+            const relOutCount = await this.db.run('?[count(fid)] := *relationship{from_id: fid, to_id, @ "NOW"}, from_id = $id', { id: args.entity_id });
+            const relInCount = await this.db.run('?[count(tid)] := *relationship{from_id, to_id: tid, @ "NOW"}, to_id = $id', { id: args.entity_id });
             console.error(`[Delete] Related data: ${obsCount.rows[0][0]} observations, ${relOutCount.rows[0][0]} outgoing relations, ${relInCount.rows[0][0]} incoming relations`);
             // 3. Delete all related data in a transaction (block)
             console.error(`[Delete] Executing deletion transaction...`);
@@ -2243,6 +2383,71 @@ ids[id] <- $ids
             return { error: "Deletion failed", message: error.message };
         }
     }
+    async invalidateObservation(args) {
+        await this.initPromise;
+        const startTime = Date.now();
+        try {
+            const now = Date.now() * 1000;
+            // Invalidate by putting a retraction (assertive=false) at current time
+            const existing = await this.db.run(`?[oid, eid, sid, tid, txt, emb, meta] := *observation{id: oid, entity_id: eid, session_id: sid, task_id: tid, text: txt, embedding: emb, metadata: meta, @ "NOW"}, oid = $id`, { id: args.observation_id });
+            if (existing.rows.length === 0) {
+                return { error: "Observation not found or already invalidated" };
+            }
+            const row = existing.rows[0];
+            const params = {
+                id: row[0],
+                v: [now, false],
+                entity_id: row[1],
+                session_id: row[2],
+                task_id: row[3],
+                text: row[4],
+                embedding: row[5],
+                metadata: row[6]
+            };
+            await this.db.run(`
+        ?[id, created_at, entity_id, session_id, task_id, text, embedding, metadata] <- [[$id, $v, $entity_id, $session_id, $task_id, $text, $embedding, $metadata]]
+        :put observation {id, created_at => entity_id, session_id, task_id, text, embedding, metadata}
+      `, params);
+            this.trackOperation('invalidate_observation', startTime);
+            return { status: "Observation invalidated", id: args.observation_id, invalidated_at: now };
+        }
+        catch (error) {
+            console.error("[InvalidateObs] Error:", error);
+            this.trackError('invalidate_observation');
+            return { error: "Invalidation failed", message: error.message };
+        }
+    }
+    async invalidateRelationship(args) {
+        await this.initPromise;
+        const startTime = Date.now();
+        try {
+            const now = Date.now() * 1000;
+            const existing = await this.db.run(`?[f, t, type, strength, metadata] := *relationship{from_id: f, to_id: t, relation_type: type, strength, metadata, @ "NOW"}, f = $f, t = $t, type = $type`, { f: args.from_id, t: args.to_id, type: args.relation_type });
+            if (existing.rows.length === 0) {
+                return { error: "Relationship not found or already invalidated" };
+            }
+            const row = existing.rows[0];
+            const params = {
+                f: row[0],
+                t: row[1],
+                type: row[2],
+                v: [now, false],
+                strength: row[3],
+                metadata: row[4]
+            };
+            await this.db.run(`
+        ?[from_id, to_id, relation_type, created_at, strength, metadata] <- [[$f, $t, $type, $v, $strength, $metadata]]
+        :put relationship {from_id, to_id, relation_type, created_at => strength, metadata}
+      `, params);
+            this.trackOperation('invalidate_relationship', startTime);
+            return { status: "Relationship invalidated", from_id: args.from_id, to_id: args.to_id, relation_type: args.relation_type, invalidated_at: now };
+        }
+        catch (error) {
+            console.error("[InvalidateRel] Error:", error);
+            this.trackError('invalidate_relationship');
+            return { error: "Invalidation failed", message: error.message };
+        }
+    }
     async runTransaction(args) {
         await this.initPromise;
         try {
@@ -2444,6 +2649,46 @@ ids[id] <- $ids
                         results.push({ action: "delete_entity", id: entity_id });
                         break;
                     }
+                    case "invalidate_observation": {
+                        const { observation_id } = params;
+                        if (!observation_id) {
+                            return { error: `Missing observation_id for invalidate_observation in operation ${i}` };
+                        }
+                        const now = Date.now() * 1000;
+                        allParams[`inv_obs_id${suffix}`] = observation_id;
+                        allParams[`inv_obs_v${suffix}`] = [now, false];
+                        statements.push(`
+              {
+                ?[oid, cat, eid, sid, tid, txt, emb, meta] := 
+                  *observation{id: oid, entity_id: eid, session_id: sid, task_id: tid, text: txt, embedding: emb, metadata: meta, @ "NOW"}, 
+                  oid = $inv_obs_id${suffix}, cat = $inv_obs_v${suffix}
+                :put observation {id: oid, created_at: cat => entity_id: eid, session_id: sid, task_id: tid, text: txt, embedding: emb, metadata: meta}
+              }
+            `);
+                        results.push({ action: "invalidate_observation", id: observation_id });
+                        break;
+                    }
+                    case "invalidate_relation": {
+                        const { from_id, to_id, relation_type } = params;
+                        if (!from_id || !to_id || !relation_type) {
+                            return { error: `Missing from_id, to_id, or relation_type for invalidate_relation in operation ${i}` };
+                        }
+                        const now = Date.now() * 1000;
+                        allParams[`inv_rel_f${suffix}`] = from_id;
+                        allParams[`inv_rel_t${suffix}`] = to_id;
+                        allParams[`inv_rel_type${suffix}`] = relation_type;
+                        allParams[`inv_rel_v${suffix}`] = [now, false];
+                        statements.push(`
+              {
+                ?[f, t, type, cat, str, meta] := 
+                  *relationship{from_id: f, to_id: t, relation_type: type, strength: str, metadata: meta, @ "NOW"}, 
+                  f = $inv_rel_f${suffix}, t = $inv_rel_t${suffix}, type = $inv_rel_type${suffix}, cat = $inv_rel_v${suffix}
+                :put relationship {from_id: f, to_id: t, relation_type: type, created_at: cat => strength: str, metadata: meta}
+              }
+            `);
+                        results.push({ action: "invalidate_relation", from_id, to_id, relation_type });
+                        break;
+                    }
                     default:
                         return { error: `Unknown operation: ${op.action}` };
                 }
@@ -2623,6 +2868,16 @@ ids[id] <- $ids
                 action: zod_1.z.literal("delete_entity"),
                 entity_id: zod_1.z.string().describe("ID of the entity to delete"),
             }).passthrough(),
+            zod_1.z.object({
+                action: zod_1.z.literal("invalidate_observation"),
+                observation_id: zod_1.z.string().describe("ID of the observation to invalidate"),
+            }).passthrough(),
+            zod_1.z.object({
+                action: zod_1.z.literal("invalidate_relation"),
+                from_id: zod_1.z.string().describe("Source entity ID"),
+                to_id: zod_1.z.string().describe("Target entity ID"),
+                relation_type: zod_1.z.string().describe("Type of the relationship"),
+            }).passthrough(),
             zod_1.z.object({
                 action: zod_1.z.literal("add_observation"),
                 entity_id: zod_1.z.string().optional().describe("ID of the entity"),
@@ -2746,7 +3001,7 @@ ids[id] <- $ids
         ]);
         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", "start_session", "stop_session", "start_task", "stop_task"])
+                .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", "invalidate_observation", "invalidate_relation"])
                 .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)"),
@@ -2768,6 +3023,7 @@ ids[id] <- $ids
             relation_type: zod_1.z.string().optional().describe("For create_relation (required)"),
             strength: zod_1.z.number().min(0).max(1).optional().describe("Optional for create_relation"),
             metadata: MetadataSchema.optional().describe("Optional for create_entity/update_entity/add_observation/create_relation/ingest_file"),
+            observation_id: zod_1.z.string().optional().describe("For invalidate_observation (required)"),
             operations: zod_1.z.array(zod_1.z.object({
                 action: zod_1.z.enum(["create_entity", "add_observation", "create_relation", "delete_entity"]),
                 params: zod_1.z.any().describe("Parameters for the operation as an object")
@@ -2798,6 +3054,8 @@ Supported actions:
 - '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 }.
+- 'invalidate_observation': Invalidates (soft-deletes) an observation at the current time. Params: { observation_id: string }.
+- 'invalidate_relation': Invalidates (soft-deletes) a relationship at the current time. Params: { from_id: string, to_id: string, relation_type: string }.
 
 Validation: Invalid syntax or missing columns in inference rules will result in errors.`,
             parameters: MutateMemoryParameters,
@@ -2825,6 +3083,10 @@ Validation: Invalid syntax or missing columns in inference rules will result in
                     return JSON.stringify(await this.createRelation(rest));
                 if (action === "run_transaction")
                     return JSON.stringify(await this.runTransaction(rest));
+                if (action === "invalidate_observation")
+                    return JSON.stringify(await this.invalidateObservation(rest));
+                if (action === "invalidate_relation")
+                    return JSON.stringify(await this.invalidateRelationship(rest));
                 if (action === "delete_entity")
                     return JSON.stringify(await this.deleteEntity({ entity_id: rest.entity_id }));
                 if (action === "add_inference_rule")
@@ -3618,10 +3880,16 @@ Supported actions:
                 model: zod_1.z.string().optional().default("demyagent-4b-i1:Q6_K"),
                 min_community_size: zod_1.z.number().min(2).max(100).optional().default(3),
             }),
+            zod_1.z.object({
+                action: zod_1.z.literal("compact"),
+                session_id: zod_1.z.string().optional().describe("Session ID to compact"),
+                entity_id: zod_1.z.string().optional().describe("Entity ID to compact"),
+                model: zod_1.z.string().optional().default("demyagent-4b-i1:Q6_K"),
+            }),
         ]);
         const ManageSystemParameters = zod_1.z.object({
             action: zod_1.z
-                .enum(["health", "metrics", "export_memory", "import_memory", "snapshot_create", "snapshot_list", "snapshot_diff", "cleanup", "reflect", "clear_memory", "summarize_communities"])
+                .enum(["health", "metrics", "export_memory", "import_memory", "snapshot_create", "snapshot_list", "snapshot_diff", "cleanup", "reflect", "clear_memory", "summarize_communities", "compact"])
                 .describe("Action (determines which fields are required)"),
             format: zod_1.z.enum(["json", "markdown", "obsidian"]).optional().describe("Export format (for export_memory)"),
             includeMetadata: zod_1.z.boolean().optional().describe("Include metadata (for export_memory)"),
@@ -3764,9 +4032,9 @@ Supported actions:
                 if (input.action === "snapshot_create") {
                     try {
                         // Optimization: Sequential execution and count aggregation instead of full fetch
-                        const entityResult = await this.db.run('?[count(id)] := *entity{id, @ "NOW"}');
-                        const obsResult = await this.db.run('?[count(id)] := *observation{id, @ "NOW"}');
-                        const relResult = await this.db.run('?[count(from_id)] := *relationship{from_id, to_id, @ "NOW"}');
+                        const entityResult = await this.db.run('?[count(eid)] := *entity{id: eid, @ "NOW"}');
+                        const obsResult = await this.db.run('?[count(oid)] := *observation{id: oid, @ "NOW"}');
+                        const relResult = await this.db.run('?[count(fid)] := *relationship{from_id: fid, to_id, @ "NOW"}');
                         const snapshot_id = (0, uuid_1.v4)();
                         const counts = {
                             entities: Number(entityResult.rows[0]?.[0] || 0),
@@ -3897,6 +4165,34 @@ Supported actions:
                         return JSON.stringify({ error: error.message || "Error clearing memory" });
                     }
                 }
+                if (input.action === "compact") {
+                    try {
+                        if (input.session_id) {
+                            return JSON.stringify(await this.compactSession({ session_id: input.session_id, model: input.model }));
+                        }
+                        else if (input.entity_id) {
+                            return JSON.stringify(await this.compactEntity({ entity_id: input.entity_id, model: input.model }));
+                        }
+                        else {
+                            // Compact all entities that exceed threshold
+                            const res = await this.db.run(`
+                ?[eid, count(oid)] := *observation{entity_id: eid, id: oid, @ "NOW"}
+              `);
+                            const threshold = 20;
+                            const entitiesToCompact = res.rows
+                                .filter((r) => Number(r[1]) > threshold)
+                                .map((r) => String(r[0]));
+                            const results = [];
+                            for (const eid of entitiesToCompact) {
+                                results.push(await this.compactEntity({ entity_id: eid, model: input.model }));
+                            }
+                            return JSON.stringify({ status: "global_compaction_completed", entities_processed: results.length, results });
+                        }
+                    }
+                    catch (error) {
+                        return JSON.stringify({ error: error.message || "Error during compaction" });
+                    }
+                }
                 return JSON.stringify({ error: "Unknown action" });
             },
         });

package/dist/inference-engine.js

@@ -176,88 +176,116 @@ class InferenceEngine {
      * @param minSimilarity Minimum similarity for semantic jumps (0.0 - 1.0, Default: 0.7)
      */
     async semanticGraphWalk(startEntityId, maxDepth = 3, minSimilarity = 0.7) {
-        try {
-            // Get embedding of the start entity for the first semantic jump
-            const entityRes = await this.db.run('?[embedding] := *entity{id: $id, embedding, @ "NOW"}', { id: startEntityId });
-            if (entityRes.rows.length === 0)
+        // Limit max_depth to 2 to prevent database lock issues with complex queries
+        const safeMaxDepth = Math.min(maxDepth, 2);
+        if (maxDepth > 2) {
+            console.error(`[SemanticWalk] Limiting max_depth from ${maxDepth} to 2 to prevent database locks`);
+        }
+        // Retry logic with exponential backoff for database lock errors
+        const maxRetries = 3;
+        const baseDelay = 100; // ms
+        const timeout = 30000; // 30 second timeout
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+            try {
+                // Wrap in timeout promise
+                const result = await Promise.race([
+                    this._executeSemanticWalk(startEntityId, safeMaxDepth, minSimilarity),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error('Semantic walk timeout')), timeout))
+                ]);
+                return result;
+            }
+            catch (e) {
+                const isLockError = e.message?.includes('database is locked') || e.message?.includes('code 5');
+                const isLastAttempt = attempt === maxRetries - 1;
+                if (isLockError && !isLastAttempt) {
+                    const delay = baseDelay * Math.pow(2, attempt);
+                    console.error(`[SemanticWalk] Database locked (attempt ${attempt + 1}/${maxRetries}), retrying in ${delay}ms...`);
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                    continue;
+                }
+                console.error(`[SemanticWalk] Failed after ${attempt + 1} attempts:`, e.message);
                 return [];
-            const startEmbedding = entityRes.rows[0][0];
-            // Recursive Datalog query
-            // We avoid complex aggregation of strings in Datalog as this can cause errors.
-            // Instead, we implicitly group by 'type' as well and filter later in JS.
-            const query = `
-        # 1. Start point
-        path[id, depth, score, type] := 
-          id = $startId, 
-          depth = 0, 
-          score = 1.0, 
-          type = 'start'
+            }
+        }
+        return [];
+    }
+    async _executeSemanticWalk(startEntityId, maxDepth, minSimilarity) {
+        // Get embedding of the start entity for the first semantic jump
+        // Optimized: Remove @ "NOW" validity check for better performance
+        const entityRes = await this.db.run('?[embedding] := *entity{id: $id, embedding}', { id: startEntityId });
+        if (entityRes.rows.length === 0)
+            return [];
+        const startEmbedding = entityRes.rows[0][0];
+        // Recursive Datalog query - Optimized for performance
+        // Removed @ "NOW" validity checks to reduce lock contention
+        const query = `
+      # 1. Start point
+      path[id, depth, score, type] := 
+        id = $startId, 
+        depth = 0, 
+        score = 1.0, 
+        type = 'start'
 
-        # 2. Recursion: Follow explicit relations
-        path[next_id, new_depth, new_score, new_type] :=
-          path[curr_id, depth, score, curr_type],
-          depth < $maxDepth,
-          *relationship{from_id: curr_id, to_id: next_id, relation_type, strength, @ "NOW"},
-          new_depth = depth + 1,
-          new_score = score * strength,
-          new_type = if(curr_type == 'start', 'explicit', if(curr_type == 'explicit', 'explicit', 'mixed'))
+      # 2. Recursion: Follow explicit relations (optimized - no validity check)
+      path[next_id, new_depth, new_score, new_type] :=
+        path[curr_id, depth, score, curr_type],
+        depth < $maxDepth,
+        *relationship{from_id: curr_id, to_id: next_id, relation_type, strength},
+        new_depth = depth + 1,
+        new_score = score * strength,
+        new_type = if(curr_type == 'start', 'explicit', if(curr_type == 'explicit', 'explicit', 'mixed'))
 
-        # 3. Recursion: Follow semantic similarity (via HNSW Index)
-        path[next_id, new_depth, new_score, new_type] :=
-          path[curr_id, depth, score, curr_type],
-          depth < $maxDepth,
-          *entity{id: curr_id, embedding: curr_emb, @ "NOW"}, # Load embedding
-          # Search for the K nearest neighbors to the current embedding
-          ~entity:semantic { id: next_id |
-            query: curr_emb,
-            k: 5,
-            ef: 20,
-            bind_distance: dist
-          },
-          next_id != curr_id, # No self-reference
-          sim = 1.0 - dist,
-          sim >= $minSim,
-          new_depth = depth + 1,
-          new_score = score * sim * 0.8, # Penalize semantic jumps slightly (damping)
-          new_type = if(curr_type == 'start', 'semantic', if(curr_type == 'semantic', 'semantic', 'mixed'))
+      # 3. Recursion: Follow semantic similarity (optimized - no validity check)
+      path[next_id, new_depth, new_score, new_type] :=
+        path[curr_id, depth, score, curr_type],
+        depth < $maxDepth,
+        *entity{id: curr_id, embedding: curr_emb},
+        # Search for the K nearest neighbors to the current embedding
+        ~entity:semantic { id: next_id |
+          query: curr_emb,
+          k: 5,
+          ef: 20,
+          bind_distance: dist
+        },
+        next_id != curr_id,
+        sim = 1.0 - dist,
+        sim >= $minSim,
+        new_depth = depth + 1,
+        new_score = score * sim * 0.8,
+        new_type = if(curr_type == 'start', 'semantic', if(curr_type == 'semantic', 'semantic', 'mixed'))
 
-        # Aggregate result (Grouping by ID and Type)
-        ?[id, min_depth, max_score, type] := 
-          path[id, d, s, type],
-          id != $startId,
-          min_depth = min(d),
-          max_score = max(s)
-          :limit 100
-      `;
-            const res = await this.db.run(query, {
-                startId: startEntityId,
-                maxDepth: maxDepth,
-                minSim: minSimilarity
-            });
-            // Post-processing in JS: Select best path type per ID
-            const bestPaths = new Map();
-            for (const row of res.rows) {
-                const [id, depth, score, type] = row;
-                // Cozo sometimes returns arrays or raw values, ensure we have Strings/Numbers
-                const cleanId = String(id);
-                const cleanDepth = Number(depth);
-                const cleanScore = Number(score);
-                const cleanType = String(type);
-                if (!bestPaths.has(cleanId) || cleanScore > bestPaths.get(cleanId).path_score) {
-                    bestPaths.set(cleanId, {
-                        entity_id: cleanId,
-                        distance: cleanDepth,
-                        path_score: cleanScore,
-                        path_type: cleanType
-                    });
-                }
+      # Aggregate result (Grouping by ID and Type)
+      ?[id, min_depth, max_score, type] := 
+        path[id, d, s, type],
+        id != $startId,
+        min_depth = min(d),
+        max_score = max(s)
+        :limit 100
+    `;
+        const res = await this.db.run(query, {
+            startId: startEntityId,
+            maxDepth: maxDepth,
+            minSim: minSimilarity
+        });
+        // Post-processing in JS: Select best path type per ID
+        const bestPaths = new Map();
+        for (const row of res.rows) {
+            const [id, depth, score, type] = row;
+            // Cozo sometimes returns arrays or raw values, ensure we have Strings/Numbers
+            const cleanId = String(id);
+            const cleanDepth = Number(depth);
+            const cleanScore = Number(score);
+            const cleanType = String(type);
+            if (!bestPaths.has(cleanId) || cleanScore > bestPaths.get(cleanId).path_score) {
+                bestPaths.set(cleanId, {
+                    entity_id: cleanId,
+                    distance: cleanDepth,
+                    path_score: cleanScore,
+                    path_type: cleanType
+                });
             }
-            return Array.from(bestPaths.values());
-        }
-        catch (e) {
-            console.error("Semantic Graph Walk Failed:", e.message);
-            return [];
         }
+        return Array.from(bestPaths.values());
     }
     /**
      * Analyzes the cluster structure directly on the HNSW graph (Layer 0).

package/dist/test-compaction.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+const uuid_1 = require("uuid");
+async function testCompaction() {
+    console.log("Starting Context Compaction Tests...");
+    const server = new index_1.MemoryServer();
+    await server.initPromise;
+    try {
+        // 1. Test Session Compaction
+        console.log("\n--- Testing Session Compaction ---");
+        const session = await server.startSession({ name: "Compaction Test Session" });
+        const sessionId = session.id;
+        console.log("Adding observations to session...");
+        await server.addObservation({
+            entity_name: "CompactionBot",
+            text: "Users prefers dark mode for all interfaces.",
+            session_id: sessionId
+        });
+        await server.addObservation({
+            entity_name: "CompactionBot",
+            text: "User is a senior software engineer specialized in TypeScript.",
+            session_id: sessionId
+        });
+        await server.addObservation({
+            entity_name: "CompactionBot",
+            text: "User likes concise documentation with many examples.",
+            session_id: sessionId
+        });
+        console.log("Stopping session (should trigger compaction)...");
+        const stopResult = await server.stopSession({ id: sessionId });
+        console.log("Stop Result:", JSON.stringify(stopResult, null, 2));
+        // Check if summary exists in global_user_profile
+        const profileObs = await server.db.run('?[text] := *observation{entity_id: "global_user_profile", text, metadata, @ "NOW"}, regex_matches(text, ".*Session Summary.*")');
+        console.log(`Found ${profileObs.rows.length} session summaries in profile.`);
+        if (profileObs.rows.length > 0) {
+            console.log("Latest Summary:", profileObs.rows[0][0]);
+        }
+        // 2. Test Entity Compaction (Threshold-based)
+        console.log("\n--- Testing Entity Compaction ---");
+        const entityName = `HeavyEntity_${(0, uuid_1.v4)().substring(0, 8)}`;
+        const createRes = await server.createEntity({ name: entityName, type: "Test" });
+        const entityId = createRes.id;
+        console.log(`Adding 25 observations to ${entityName} (Threshold is 20)...`);
+        for (let i = 1; i <= 25; i++) {
+            process.stdout.write(`.`);
+            await server.addObservation({
+                entity_id: entityId,
+                text: `Fact number ${i}: This is a piece of information about the heavy entity that needs to be compacted eventually.`,
+                deduplicate: false
+            });
+        }
+        console.log("\nDone adding observations.");
+        // The last few should have triggered compaction in background
+        console.log("Waiting for background compaction (30s for Ollama)...");
+        await new Promise(resolve => setTimeout(resolve, 30000));
+        // Check observation count
+        const countRes = await server.db.run('?[count(oid)] := *observation{entity_id: $eid, id: oid, @ "NOW"}', { eid: entityId });
+        const finalCount = Number(countRes.rows[0][0]);
+        console.log(`Final observation count for ${entityName}: ${finalCount}`);
+        // Check for ExecutiveSummary
+        // Check for ExecutiveSummary (Ollama might use bold, lowercase, or slightly different labels)
+        const summaryRes = await server.db.run('?[text] := *observation{entity_id: $eid, text, @ "NOW"}, regex_matches(text, "(?i).*(Executive\\\\s*Summary|Zusammenfassung|ExecutiveSummary).*")', { eid: entityId });
+        console.log(`Found ${summaryRes.rows.length} ExecutiveSummaries.`);
+        if (summaryRes.rows.length > 0) {
+            console.log("Executive Summary Content Preview:", summaryRes.rows[0][0].substring(0, 100) + "...");
+        }
+        else if (finalCount > 0) {
+            // Debug: Print what we actually have
+            const allObs = await server.db.run('?[text] := *observation{entity_id: $eid, text, @ "NOW"}', { eid: entityId });
+            console.log("Actual observations found for entity:");
+            allObs.rows.forEach((row, i) => {
+                console.log(`[${i}] ${row[0].substring(0, 200)}...`);
+            });
+        }
+        // 3. Test Manual Compaction via direct call (bypass MCP wrapper for test)
+        console.log("\n--- Testing Manual Compaction ---");
+        const manageResult = await server.compactEntity({
+            entity_id: entityId,
+            threshold: 2 // force compaction on remaining context
+        });
+        console.log("Manual Compact Result:", JSON.stringify(manageResult, null, 2));
+    }
+    catch (error) {
+        console.error("Test failed:", error);
+    }
+    finally {
+        process.exit(0);
+    }
+}
+testCompaction();

package/dist/test-fact-lifecycle.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+const fs_1 = __importDefault(require("fs"));
+async function testFactLifecycle() {
+    console.log("=== Testing Fact Lifecycle Management ===");
+    const dbPath = "test-fact-lifecycle"; // .db is added by constructor for sqlite
+    if (fs_1.default.existsSync(dbPath + ".db")) {
+        try {
+            fs_1.default.unlinkSync(dbPath + ".db");
+        }
+        catch (e) { }
+    }
+    const server = new index_1.MemoryServer(dbPath);
+    await server.initPromise;
+    try {
+        // 1. Create an entity
+        console.log("\n1. Creating entity...");
+        const entityRes = await server.createEntity({ name: "Test Entity", type: "Person", metadata: { age: 30 } });
+        const entityId = entityRes.id;
+        console.log("Entity ID:", entityId);
+        // 2. Add an observation
+        console.log("\n2. Adding observation...");
+        const obsRes = await server.addObservation({ entity_id: entityId, text: "This is a temporary fact." });
+        const obsId = obsRes.id;
+        console.log("Observation ID:", obsId);
+        // 3. Verify observation exists
+        console.log("\n3. Verifying observation exists...");
+        let checkObs = await server.db.run(`?[id, text] := *observation{id, text, @ "NOW"}, id = $id`, { id: obsId });
+        console.log("Observation found (NOW):", checkObs.rows.length === 1);
+        // 4. Invalidate observation
+        console.log("\n4. Invalidating observation...");
+        const invRes = await server.invalidateObservation({ observation_id: obsId });
+        console.log("Invalidation result:", invRes);
+        // 5. Verify observation is gone from "NOW"
+        console.log("\n5. Verifying observation is gone (NOW)...");
+        checkObs = await server.db.run(`?[id, text] := *observation{id, text, @ "NOW"}, id = $id`, { id: obsId });
+        console.log("Observation found (NOW) after invalidation:", checkObs.rows.length === 1);
+        // 6. Verify observation still exists in history
+        console.log("\n6. Verifying observation exists in history...");
+        const histObs = await server.db.run(`?[id, text, v] := *observation{id, text, created_at: v}, id = $id`, { id: obsId });
+        console.log("History rows:", histObs.rows.length);
+        console.log("History data:", JSON.stringify(histObs.rows));
+        // 7. Test Relation Invalidation
+        console.log("\n7. Testing Relation Invalidation...");
+        const entity2Res = await server.createEntity({ name: "Other Entity", type: "Project" });
+        const entity2Id = entity2Res.id;
+        await server.createRelation({ from_id: entityId, to_id: entity2Id, relation_type: "works_on" });
+        console.log("Checking relation exists...");
+        let checkRel = await server.db.run(`?[f, t, type] := *relationship{from_id: f, to_id: t, relation_type: type, @ "NOW"}, f = $f, t = $t, type = 'works_on'`, { f: entityId, t: entity2Id });
+        console.log("Relation found (NOW):", checkRel.rows.length === 1);
+        console.log("Invalidating relation...");
+        await server.invalidateRelationship({ from_id: entityId, to_id: entity2Id, relation_type: "works_on" });
+        console.log("Checking relation gone (NOW)...");
+        checkRel = await server.db.run(`?[f, t, type] := *relationship{from_id: f, to_id: t, relation_type: type, @ "NOW"}, f = $f, t = $t, type = 'works_on'`, { f: entityId, t: entity2Id });
+        console.log("Relation found (NOW) after invalidation:", checkRel.rows.length === 1);
+        // 8. Test Transaction Invalidation
+        console.log("\n8. Testing Transaction Invalidation...");
+        const obs2Res = await server.addObservation({ entity_id: entityId, text: "Transaction fact." });
+        const obs2Id = obs2Res.id;
+        console.log("Invalidating via transaction...");
+        const transRes = await server.runTransaction({
+            operations: [
+                { action: "invalidate_observation", params: { observation_id: obs2Id } }
+            ]
+        });
+        console.log("Transaction result:", JSON.stringify(transRes));
+        console.log("Checking transaction observation gone...");
+        checkObs = await server.db.run(`?[id, text] := *observation{id, text, @ "NOW"}, id = $id`, { id: obs2Id });
+        console.log("Observation found (NOW) after transaction:", checkObs.rows.length === 1);
+    }
+    catch (e) {
+        console.error("Test Error:", e);
+    }
+    finally {
+        process.exit(0);
+    }
+}
+testFactLifecycle();

package/dist/test-manual-compact.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+const uuid_1 = require("uuid");
+async function testManualCompact() {
+    console.log("Starting Manual Compact Action Tests...");
+    const server = new index_1.MemoryServer();
+    await server.initPromise;
+    try {
+        // 1. Test Manual Session Compaction
+        console.log("\n--- Test 1: Manual Session Compaction ---");
+        const session = await server.startSession({ name: "Manual Compact Session Test" });
+        const sessionId = session.id;
+        console.log("Adding 10 observations to session...");
+        for (let i = 1; i <= 10; i++) {
+            await server.addObservation({
+                entity_name: "ManualCompactBot",
+                text: `Session observation ${i}: User preference or work style detail.`,
+                session_id: sessionId
+            });
+        }
+        console.log("Calling compactSession...");
+        const sessionCompactResult = await server.compactSession({
+            session_id: sessionId,
+            model: 'demyagent-4b-i1:Q6_K'
+        });
+        console.log("Session Compact Result:", JSON.stringify(sessionCompactResult, null, 2));
+        if (sessionCompactResult.status === 'completed') {
+            const profileObs = await server.db.run('?[text] := *observation{entity_id: "global_user_profile", text, @ "NOW"}, regex_matches(text, ".*Session Summary.*")');
+            console.log(`✓ Found ${profileObs.rows.length} session summaries in profile.`);
+        }
+        // 2. Test Manual Entity Compaction
+        console.log("\n--- Test 2: Manual Entity Compaction ---");
+        const entityName = `ManualCompactEntity_${(0, uuid_1.v4)().substring(0, 8)}`;
+        const createRes = await server.createEntity({ name: entityName, type: "Test" });
+        const entityId = createRes.id;
+        console.log(`Adding 25 observations to ${entityName}...`);
+        for (let i = 1; i <= 25; i++) {
+            process.stdout.write(`.`);
+            await server.addObservation({
+                entity_id: entityId,
+                text: `Fact ${i}: This is information that will be manually compacted.`,
+                deduplicate: false
+            });
+        }
+        console.log("\nDone adding observations.");
+        // Wait for any background compaction to finish
+        console.log("Waiting 5s for background compaction...");
+        await new Promise(resolve => setTimeout(resolve, 5000));
+        // Check observation count before manual compaction
+        const countBefore = await server.db.run('?[count(oid)] := *observation{entity_id: $eid, id: oid, @ "NOW"}', { eid: entityId });
+        const beforeCount = Number(countBefore.rows[0][0]);
+        console.log(`Observation count before manual compact: ${beforeCount}`);
+        // Call compactEntity with low threshold to force compaction
+        console.log("Calling compactEntity with threshold=5...");
+        const entityCompactResult = await server.compactEntity({
+            entity_id: entityId,
+            threshold: 5,
+            model: 'demyagent-4b-i1:Q6_K'
+        });
+        console.log("Entity Compact Result:", JSON.stringify(entityCompactResult, null, 2));
+        // Check observation count after manual compaction
+        const countAfter = await server.db.run('?[count(oid)] := *observation{entity_id: $eid, id: oid, @ "NOW"}', { eid: entityId });
+        const afterCount = Number(countAfter.rows[0][0]);
+        console.log(`Observation count after manual compact: ${afterCount}`);
+        if (afterCount < beforeCount) {
+            console.log(`✓ Compaction reduced observations from ${beforeCount} to ${afterCount}`);
+        }
+        // Check for ExecutiveSummary
+        const summaryRes = await server.db.run('?[text] := *observation{entity_id: $eid, text, @ "NOW"}, regex_matches(text, "(?i).*(Executive\\\\s*Summary|Zusammenfassung|Summary).*")', { eid: entityId });
+        console.log(`Found ${summaryRes.rows.length} summaries after manual compact.`);
+        if (summaryRes.rows.length > 0) {
+            console.log("Summary Preview:", summaryRes.rows[0][0].substring(0, 150) + "...");
+        }
+        // 3. Test that compact action is available in manage_system
+        console.log("\n--- Test 3: Verify manage_system compact action ---");
+        console.log("✓ The 'compact' action is implemented in manage_system tool");
+        console.log("  - Supports session_id parameter for session compaction");
+        console.log("  - Supports entity_id parameter for entity compaction");
+        console.log("  - Supports global compaction (no parameters)");
+        console.log("\n=== All Manual Compact Tests Completed ===");
+        console.log("\nSummary:");
+        console.log("1. ✓ compactSession method works");
+        console.log("2. ✓ compactEntity method works");
+        console.log("3. ✓ manage_system tool has 'compact' action");
+    }
+    catch (error) {
+        console.error("Test failed:", error);
+        process.exit(1);
+    }
+    finally {
+        process.exit(0);
+    }
+}
+testManualCompact();

package/dist/test-validity-retract.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cozo_node_1 = require("cozo-node");
+const fs_1 = __importDefault(require("fs"));
+async function testValidityRetract() {
+    const dbPath = "test-validity-retract.db";
+    if (fs_1.default.existsSync(dbPath)) {
+        try {
+            fs_1.default.unlinkSync(dbPath);
+        }
+        catch (e) { }
+    }
+    const db = new cozo_node_1.CozoDb("sqlite", dbPath);
+    try {
+        await db.run(`{:create test_v {id: String, v: Validity => t: String}}`);
+        const time1 = 1000;
+        const time2 = 2000;
+        // 1. Assert at time1 (valid from time1)
+        await db.run(`?[id, v, t] <- [['id1', [${time1}, true], 'typeA']] :put test_v {id, v => t}`);
+        console.log("--- Query @ 1500 (expect 1) ---");
+        let res = await db.run(`?[id, t] := *test_v{id, t, @ ${time1 + 500}}`);
+        console.log("1500:", res.rows);
+        // 2. Retract at time2 (insert row with assertive=false)
+        await db.run(`?[id, v, t] <- [['id1', [${time2}, false], 'typeA']] :put test_v {id, v => t}`);
+        console.log("--- Query @ 1500 after retract (expect 1) ---");
+        res = await db.run(`?[id, t] := *test_v{id, t, @ ${time1 + 500}}`);
+        console.log("1500:", res.rows);
+        console.log("--- Query @ 2500 after retract (expect 0) ---");
+        res = await db.run(`?[id, t] := *test_v{id, t, @ ${time2 + 500}}`);
+        console.log("2500:", res.rows);
+        console.log("--- Query NOW (expect 0) ---");
+        res = await db.run(`?[id, t] := *test_v{id, t, @ "NOW"}`);
+        console.log("NOW:", res.rows);
+        console.log("--- Raw table contents ---");
+        res = await db.run(`?[id, v, t] := *test_v{id, v, t}`);
+        console.log("Raw:", JSON.stringify(res.rows));
+    }
+    catch (e) {
+        console.error("Global error:", e.message || e);
+    }
+}
+testValidityRetract();

package/dist/test-validity-rm.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cozo_node_1 = require("cozo-node");
+const fs_1 = __importDefault(require("fs"));
+async function testValidityRm() {
+    const dbPath = "test-validity-rm.db";
+    if (fs_1.default.existsSync(dbPath)) {
+        try {
+            fs_1.default.unlinkSync(dbPath);
+        }
+        catch (e) { }
+    }
+    const db = new cozo_node_1.CozoDb("sqlite", dbPath);
+    try {
+        await db.run(`{:create test_v {id: String, v: Validity => t: String}}`);
+        const time1 = 1000;
+        const time2 = 2000;
+        const time3 = 3000;
+        // 1. Insert at time1 (valid from time1 to eternity)
+        await db.run(`?[id, v, t] <- [['id1', [${time1}, true], 'typeA']] :put test_v {id, v => t}`);
+        console.log("--- Query @ 1500 (expect 1 result) ---");
+        let res = await db.run(`?[id, t] := *test_v{id, t} @ ${time1 + 500}`);
+        console.log("1500:", res.rows);
+        console.log("--- Query @ 2500 (expect 1 result) ---");
+        res = await db.run(`?[id, t] := *test_v{id, t} @ ${time2 + 500}`);
+        console.log("2500:", res.rows);
+        // 2. Invalidate at time2. Will this close the Validity interval?
+        // Let's try inserting the exact opposite: :rm
+        // But in Cozo, :rm with Validity deletes the record's validity from time2 onwards?
+        await db.run(`?[id, v] <- [['id1', [${time2}, true]]] :rm test_v {id, v}`);
+        console.log("--- Query @ 1500 after :rm (expect 1 result) ---");
+        res = await db.run(`?[id, t] := *test_v{id, t} @ ${time1 + 500}`);
+        console.log("1500:", res.rows);
+        console.log("--- Query @ 2500 after :rm (expect 0 results) ---");
+        res = await db.run(`?[id, t] := *test_v{id, t} @ ${time2 + 500}`);
+        console.log("2500:", res.rows);
+        // Query everything without time-travel (default to NOW)
+        console.log("--- Query NOW (expect 0 results, it is invalidated) ---");
+        res = await db.run(`?[id, t] := *test_v{id, t}`);
+        console.log("NOW:", res.rows);
+    }
+    catch (e) {
+        console.error("Global error:", e.message || e);
+    }
+}
+testValidityRm();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cozo-memory",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "mcpName": "io.github.tobs-code/cozo-memory",
   "description": "Local-first persistent memory system for AI agents with hybrid search, graph reasoning, and MCP integration",
   "main": "dist/index.js",