fixes

Author: nicoloboschi

hindsight-api/hindsight_api/engine/memory_engine.py

@@ -4159,10 +4159,10 @@ async def _invalidate_facts_from_mental_models(
         fact_ids: list[str],
     ) -> int:
         """
-        Remove fact IDs from mental model observations when memories are deleted.
+        Remove fact IDs from mental model source_memory_ids when memories are deleted.
 
-        Uses JSONB path operations to find and update mental models that reference
-        the deleted fact IDs in their observations.
+        Mental models are now stored in memory_units with fact_type='mental_model'
+        and have a source_memory_ids column (UUID[]) tracking their source memories.
 
         Args:
             conn: Database connection
@@ -4175,45 +4175,29 @@ async def _invalidate_facts_from_mental_models(
         if not fact_ids:
             return 0
 
-        # Convert fact_ids to a jsonb array for efficient comparison
-        import json
+        # Convert string IDs to UUIDs for the array comparison
+        import uuid as uuid_module
 
-        fact_ids_json = json.dumps(fact_ids)
+        fact_uuids = [uuid_module.UUID(fid) for fid in fact_ids]
 
-        # Update mental models by removing the deleted fact IDs from all observations
-        # This uses jsonb_set to update each observation's fact_ids array
+        # Update mental models (memory_units with fact_type='mental_model')
+        # by removing the deleted fact IDs from source_memory_ids
+        # Use array subtraction: source_memory_ids - deleted_ids
         result = await conn.execute(
             f"""
-            UPDATE {fq_table("mental_models")}
-            SET observations = jsonb_set(
-                observations,
-                '{{observations}}',
-                (
-                    SELECT COALESCE(jsonb_agg(
-                        jsonb_set(
-                            observation,
-                            '{{fact_ids}}',
-                            (
-                                SELECT COALESCE(jsonb_agg(fid), '[]'::jsonb)
-                                FROM jsonb_array_elements_text(observation->'fact_ids') AS fid
-                                WHERE NOT (fid::text = ANY($2::text[]))
-                            )
-                        )
-                    ), '[]'::jsonb)
-                    FROM jsonb_array_elements(observations->'observations') AS observation
-                )
+            UPDATE {fq_table("memory_units")}
+            SET source_memory_ids = (
+                SELECT COALESCE(array_agg(elem), ARRAY[]::uuid[])
+                FROM unnest(source_memory_ids) AS elem
+                WHERE elem != ALL($2::uuid[])
             ),
-            last_updated = NOW()
+                updated_at = NOW()
             WHERE bank_id = $1
-            AND EXISTS (
-                SELECT 1
-                FROM jsonb_array_elements(observations->'observations') AS observation,
-                     jsonb_array_elements_text(observation->'fact_ids') AS fid
-                WHERE fid::text = ANY($2::text[])
-            )
+            AND fact_type = 'mental_model'
+            AND source_memory_ids && $2::uuid[]
             """,
             bank_id,
-            fact_ids,
+            fact_uuids,
         )
 
         # Parse the result to get number of updated rows

hindsight-api/hindsight_api/engine/reflect/prompts.py

@@ -16,33 +16,42 @@ def _extract_directive_rules(directives: list[dict[str, Any]]) -> list[str]:
     Extract directive rules as a list of strings.
 
     Args:
-        directives: List of directive mental models with observations
+        directives: List of directives with name and content
 
     Returns:
         List of directive rule strings
     """
     rules = []
     for directive in directives:
         directive_name = directive.get("name", "")
-        observations = directive.get("observations", [])
-        if observations:
-            for obs in observations:
-                # Support both Pydantic Observation objects and dicts
-                if hasattr(obs, "title"):
-                    title = obs.title
-                    content = obs.content
-                else:
-                    title = obs.get("title", "")
-                    content = obs.get("content", "")
-                if title and content:
-                    rules.append(f"**{title}**: {content}")
-                elif content:
-                    rules.append(content)
-        elif directive_name:
-            # Fallback to description if no observations
-            desc = directive.get("description", "")
-            if desc:
-                rules.append(f"**{directive_name}**: {desc}")
+        # New format: directives have direct content field
+        content = directive.get("content", "")
+        if content:
+            if directive_name:
+                rules.append(f"**{directive_name}**: {content}")
+            else:
+                rules.append(content)
+        else:
+            # Legacy format: check for observations
+            observations = directive.get("observations", [])
+            if observations:
+                for obs in observations:
+                    # Support both Pydantic Observation objects and dicts
+                    if hasattr(obs, "title"):
+                        title = obs.title
+                        obs_content = obs.content
+                    else:
+                        title = obs.get("title", "")
+                        obs_content = obs.get("content", "")
+                    if title and obs_content:
+                        rules.append(f"**{title}**: {obs_content}")
+                    elif obs_content:
+                        rules.append(obs_content)
+            elif directive_name:
+                # Fallback to description
+                desc = directive.get("description", "")
+                if desc:
+                    rules.append(f"**{directive_name}**: {desc}")
     return rules
 
 

hindsight-api/tests/test_consolidation.py

@@ -5,6 +5,7 @@
 """
 
 import uuid
+from unittest.mock import patch
 
 import pytest
 
@@ -17,6 +18,18 @@
 )
 
 
+@pytest.fixture(autouse=True)
+def enable_consolidation():
+    """Enable consolidation for all tests in this module."""
+    from hindsight_api.config import get_config
+
+    config = get_config()
+    original_value = config.enable_consolidation
+    config.enable_consolidation = True
+    yield
+    config.enable_consolidation = original_value
+
+
 class TestConsolidationIntegration:
     """Integration tests for consolidation with real database.
 

hindsight-api/tests/test_llm_tools.py

@@ -241,24 +241,27 @@ def test_get_reflect_tools_default(self):
         tools = get_reflect_tools()
 
         tool_names = [t["function"]["name"] for t in tools]
-        assert "list_mental_models" in tool_names
-        assert "get_mental_model" in tool_names
+        assert "search_reflections" in tool_names
+        assert "search_mental_models" in tool_names
         assert "recall" in tool_names
-        assert "learn" in tool_names
         assert "expand" in tool_names
         assert "done" in tool_names
 
-    def test_get_reflect_tools_without_learn(self):
-        """Test getting reflect tools without learn."""
+    def test_get_reflect_tools_with_directives(self):
+        """Test getting reflect tools with directive rules."""
         from hindsight_api.engine.reflect.tools_schema import get_reflect_tools
 
-        tools = get_reflect_tools(enable_learn=False)
+        tools = get_reflect_tools(directive_rules=["Always respond in French"])
 
         tool_names = [t["function"]["name"] for t in tools]
-        assert "learn" not in tool_names
         assert "recall" in tool_names
         assert "done" in tool_names
 
+        # Done tool should have directive_compliance field when directives are present
+        done_tool = next(t for t in tools if t["function"]["name"] == "done")
+        params = done_tool["function"]["parameters"]["properties"]
+        assert "directive_compliance" in params
+
     def test_get_reflect_tools_answer_mode(self):
         """Test getting reflect tools with answer output mode."""
         from hindsight_api.engine.reflect.tools_schema import get_reflect_tools
@@ -270,7 +273,8 @@ def test_get_reflect_tools_answer_mode(self):
 
         assert "answer" in params
         assert "memory_ids" in params
-        assert "model_ids" in params
+        assert "mental_model_ids" in params
+        assert "reflection_ids" in params
 
 
 class TestLLMToolCallResult:

hindsight-api/tests/test_main_module.py

@@ -363,7 +363,6 @@ def capture_uvicorn_run(**kwargs):
     RetainContext,
     RecallContext,
     ReflectContext,
-    RefreshMentalModelContext,
 )
 
 
@@ -395,6 +394,3 @@ async def validate_recall(self, ctx: RecallContext) -> ValidationResult:
 
     async def validate_reflect(self, ctx: ReflectContext) -> ValidationResult:
         return ValidationResult.accept()
-
-    async def validate_refresh_mental_model(self, ctx: RefreshMentalModelContext) -> ValidationResult:
-        return ValidationResult.accept()