Close final review gaps

Author: Coding-Dev-Tools

engraphis/core/engine.py

@@ -1078,7 +1078,16 @@ def _relatedness(self, query: str, flt: SearchFilter, *,
             sem[mid] = float(np.dot(qn, vec))
         q_tokens = tokenize(query)
         out: list[tuple[float, MemoryRecord]] = []
-        for rec in self.store.list_memories(flt, include_invalid=include_invalid, limit=500):
+        records = self.store.list_memories(flt, include_invalid=include_invalid, limit=500)
+        if include_invalid and flt.known_at is not None:
+            # History must retain closed valid-time intervals, but cannot expose a
+            # record that was not known at the requested system-time snapshot.
+            records = [
+                rec for rec in records
+                if (rec.ingested_at is None or rec.ingested_at <= flt.known_at)
+                and (rec.expired_at is None or flt.known_at < rec.expired_at)
+            ]
+        for rec in records:
             lex = jaccard(q_tokens, tokenize(f"{rec.title} {rec.content}"))
             score = max(sem.get(rec.id, 0.0), lex)
             if score > 0.05:

engraphis/routes/v2_api.py

@@ -977,8 +977,34 @@ def recall(q: str = Query(...), workspace: Optional[str] = None, k: int = 8,
         mems = _keyword_search(
             ws, q, k, as_of=as_of, valid_at=valid_at, known_at=known_at,
         )
+        if response_mode == "compact":
+            # Preserve the public compact-response contract even when semantic recall
+            # degrades to the keyword path during an embedding migration.
+            mems = [
+                {
+                    key: memory.get(key)
+                    for key in (
+                        "id", "document_id", "title", "memory_type", "scope", "pinned",
+                        "importance", "valid_from", "valid_to", "valid_to_recorded_at",
+                        "ingested_at", "expired_at", "subject_key", "claim_kind", "provenance",
+                    )
+                }
+                for memory in mems
+            ]
+        historical = valid_at is not None or known_at is not None or as_of is not None
+        effective_budget = (
+            token_budget if token_budget is not None else service().engine.recall_engine.token_budget
+        )
         return {"query": q, "workspace": ws, "count": len(mems), "context": "",
-                "memories": mems, "mode": "keyword",
+                "memories": mems, "mode": "keyword", "response_mode": response_mode,
+                "retrieval_profile": retrieval_profile,
+                "valid_at": valid_at if valid_at is not None else as_of,
+                "known_at": known_at, "historical": historical,
+                "packed_sources": [],
+                "usage": {"budget_tokens": effective_budget, "context_tokens": 0,
+                          "source_tokens": 0, "saved_tokens": 0, "savings_ratio": 0.0,
+                          "packed_count": 0, "omitted_count": len(mems),
+                          "token_counter": "engraphis.regex.v1"},
                 "note": "Keyword match — install sentence-transformers for semantic search."}
     payload = dict(out)
     payload.update({

tests/test_dashboard_v2.py

@@ -400,6 +400,21 @@ def incompatible_embedder(*_args, **_kwargs):
         assert fallback.json()["mode"] == "keyword"
         assert [item["id"] for item in fallback.json()["memories"]] == [old["id"]]
 
+        compact_fallback = client.get(
+            "/api/recall",
+            params={
+                "workspace": "demo", "q": "fallback retention", "response_mode": "compact",
+                "token_budget": 0,
+            },
+        )
+        payload = compact_fallback.json()
+        assert compact_fallback.status_code == 200
+        assert payload["mode"] == "keyword"
+        assert payload["response_mode"] == "compact"
+        assert payload["usage"]["budget_tokens"] == 0
+        assert payload["usage"]["context_tokens"] == 0
+        assert payload["memories"] and "content" not in payload["memories"][0]
+
 
 def test_http_memory_api_rejects_backdated_supersession_without_partial_write(
     monkeypatch, tmp_path

tests/test_engine.py

@@ -466,6 +466,44 @@ def test_timeline_orders_history_chronologically():
     assert hist[0].valid_from < hist[1].valid_from
 
 
+def test_why_and_timeline_history_respect_known_time_but_keep_closed_records():
+    eng = MemoryEngine.create(":memory:")
+    wid = eng.store.get_or_create_workspace("w")
+    rid = eng.store.get_or_create_repo(wid, "r")
+    records = (
+        MemoryRecord(
+            id="", workspace_id=wid, repo_id=rid, scope=Scope.REPO,
+            content="Launch history current policy", valid_from=1.0, ingested_at=1.0,
+        ),
+        MemoryRecord(
+            id="", workspace_id=wid, repo_id=rid, scope=Scope.REPO,
+            content="Launch history closed policy", valid_from=2.0, valid_to=3.0,
+            ingested_at=2.0,
+        ),
+        MemoryRecord(
+            id="", workspace_id=wid, repo_id=rid, scope=Scope.REPO,
+            content="Launch history learned later", valid_from=4.0, valid_to=5.0,
+            ingested_at=200.0,
+        ),
+    )
+    for record in records:
+        eng.store.add_memory(record)
+
+    timeline = eng.timeline(
+        "launch history", workspace_id=wid, repo_id=rid, known_at=100.0,
+    )
+    why = eng.why(
+        "launch history", workspace_id=wid, repo_id=rid, known_at=100.0,
+    )
+
+    assert {record.content for record in timeline} == {
+        "Launch history current policy", "Launch history closed policy",
+    }
+    assert [record.content for record in why["supersedes"]] == [
+        "Launch history closed policy",
+    ]
+
+
 def test_temporal_supersession_closes_at_effective_time_and_keeps_vectors():
     eng = MemoryEngine.create(":memory:")
     wid = eng.store.get_or_create_workspace("w")