dhee 7.2.3__tar.gz → 7.2.5__tar.gz

{dhee-7.2.3/dhee.egg-info → dhee-7.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dhee
-Version: 7.2.3
+Version: 7.2.5
 Summary: Dhee - world memory layer and context compiler for AI agents
 Author: Sankhya AI Labs
 License-Expression: MIT

{dhee-7.2.3 → dhee-7.2.5}/dhee/__init__.py

@@ -50,7 +50,7 @@ from dhee.memory.admission import (
 # Default import remains model-free for backwards compatibility.
 Memory = CoreMemory
 
-__version__ = "7.2.3"
+__version__ = "7.2.5"
 __all__ = [
     # Memory classes
     "Engram",

{dhee-7.2.3 → dhee-7.2.5}/dhee/configs/base.py

@@ -1,4 +1,5 @@
 import os
+from pathlib import Path
 from typing import Any, Dict, List, Optional
 
 from pydantic import BaseModel, Field, field_validator
@@ -12,12 +13,17 @@ from dhee.provider_defaults import (
 )
 
 
+def resolve_dhee_data_dir(path: str | os.PathLike[str]) -> str:
+    """Return an absolute Dhee data directory with user markers expanded."""
+    return os.path.abspath(os.path.expanduser(os.fspath(path)))
+
+
 def _dhee_data_dir() -> str:
     """Resolve data directory: DHEE_DATA_DIR > ~/.dhee."""
     env = os.environ.get("DHEE_DATA_DIR")
     if env:
-        return env
-    return os.path.join(os.path.expanduser("~"), ".dhee")
+        return resolve_dhee_data_dir(env)
+    return resolve_dhee_data_dir(Path.home() / ".dhee")
 
 
 _VALID_VECTOR_PROVIDERS = {"memory", "sqlite_vec", "zvec"}
@@ -180,7 +186,7 @@ class SceneConfig(BaseModel):
     scene_topic_threshold: float = 0.55    # cosine sim below this = topic shift
     auto_close_inactive_minutes: int = 120
     max_scene_memories: int = 50
-    use_llm_summarization: bool = False
+    use_llm_summarization: bool = True
     summary_regenerate_threshold: int = 5
 
 

{dhee-7.2.3 → dhee-7.2.5}/dhee/contract_runtime.py

@@ -741,17 +741,14 @@ def guard_router_call(tool_name: str, arguments: Dict[str, Any]) -> Dict[str, An
             "repo": str(repo_root),
         })
         if mode == "deny":
-            # Even in deny mode a supervisor outage must leave a recovery
-            # path open: read-only tools cannot violate a contract, and the
-            # dhee CLI is how the agent repairs the runtime state.
             command = str(arguments.get("command") or "").strip()
-            recoverable = tool_name in _READ_TOOL_NAMES or tool_name in _GREP_TOOL_NAMES or (
-                tool_name in _BASH_TOOL_NAMES and command.startswith("dhee ")
+            recoverable = tool_name in {"Read", "Grep"} or (
+                tool_name == "Bash" and command.startswith("dhee ")
             )
             if recoverable:
                 warning = (
                     "Contract supervisor unavailable; deny mode allowed this "
-                    "read-only/remediation call."
+                    "native read-only/remediation call."
                 )
                 _record_enforcement_warning(
                     repo_root,

{dhee-7.2.3 → dhee-7.2.5}/dhee/core/engram_extractor.py

@@ -113,6 +113,7 @@ class EngramExtractor:
         user_profile: Optional[Dict[str, Any]] = None,
         existing_metadata: Optional[Dict[str, Any]] = None,
         user_id: str = "default",
+        strict_llm_failure: bool = False,
     ) -> UniversalEngram:
         """Extract structured engram with contextual anchoring.
 
@@ -129,6 +130,8 @@ class EngramExtractor:
             )
             if engram:
                 return engram
+            if strict_llm_failure:
+                raise RuntimeError("Engram LLM extraction produced no structured result")
 
         # Rule-based extraction
         return self._extract_rule_based(
@@ -330,13 +333,17 @@ class EngramExtractor:
             (r"(?:I|user)\s+(?:prefer|like|love|enjoy|use)\s+(.+?)(?:\.|$|,)", "prefers"),
             (r"(?:I|user)\s+(?:switched to|moved to|changed to)\s+(.+?)(?:\.|$|,)", "switched_to"),
             (r"(?:I|user)\s+(?:work at|work for|employed at)\s+(.+?)(?:\.|$|,)", "works_at"),
+            (r"(?:I|user|owner)\s+(?:live|lives|reside|resides)\s+in\s+(.+?)(?:\.|$|,)", "lives_in"),
+            (r"(?:my|user's|owner's)\s+(?:home|city|location)\s+is\s+(.+?)(?:\.|$|,)", "lives_in"),
+            (r"(?:my|user's|owner's)\s+(?:plan|goal)\s+is\s+to\s+(.+?)(?:\.|$|,)", "plans_to"),
+            (r"(?:I|user|owner)\s+(?:plan|plans|intend|intends)\s+to\s+(.+?)(?:\.|$|,)", "plans_to"),
             (r"(?:I|user)\s+(?:visited|went to|traveled to)\s+(.+?)(?:\.|$|,)", "visited"),
             (r"(?:I|user)\s+(?:bought|purchased)\s+(.+?)(?:\s+for\s+)?([\d,.]+)?\s*(\w+)?", "bought"),
         ]
         for pattern, predicate in preference_patterns:
             matches = re.finditer(pattern, content, re.IGNORECASE)
             for match in matches:
-                value = match.group(1).strip().rstrip(".")
+                value = self._clean_rule_value(match.group(1))
                 if len(value) > 100:
                     continue
                 fact = Fact(
@@ -360,6 +367,17 @@ class EngramExtractor:
 
         return facts
 
+    @staticmethod
+    def _clean_rule_value(value: str) -> str:
+        text = str(value or "").strip().rstrip(".")
+        text = re.split(
+            r"\s+(?:and|but|while)\s+(?=(?:I|user|owner|my|user's|owner's)\b)",
+            text,
+            maxsplit=1,
+            flags=re.IGNORECASE,
+        )[0]
+        return text.strip().rstrip(".")
+
     def _extract_entities_rules(self, content: str) -> List[EntityRef]:
         """Rule-based entity extraction."""
         entities = []

{dhee-7.2.3 → dhee-7.2.5}/dhee/core/scene.py

@@ -229,16 +229,10 @@ class SceneProcessor:
 
         # Generate summary (LLM when enabled, otherwise deterministic extractive fallback).
         memories = self.db.get_scene_memories(scene_id)
-        summary = None
-        if self.use_llm_summarization and self.llm:
-            summary = self._summarize_scene(scene, memories)
-        if not summary:
-            summary = self._extractive_scene_summary(memories)
+        summary = self._generate_scene_summary(scene, memories)
         if summary:
             updates["summary"] = summary
-            # Derive title from summary
-            title = summary.split(".")[0][:120]
-            updates["title"] = title
+            updates["title"] = self._title_from_summary(summary)
 
         if updates:
             self.db.update_scene(scene_id, updates)
@@ -270,6 +264,77 @@ class SceneProcessor:
     # Summarization
     # ------------------------------------------------------------------
 
+    def summarize_scene(self, scene_id: str, *, force: bool = False) -> Optional[str]:
+        """Generate and persist a summary for an existing scene."""
+        scene = self.db.get_scene(scene_id)
+        if not scene:
+            return None
+        existing = str(scene.get("summary") or "").strip()
+        if existing and not force:
+            return existing
+
+        memories = self.db.get_scene_memories(scene_id)
+        summary = self._generate_scene_summary(scene, memories)
+        if not summary:
+            return None
+        self.db.update_scene(
+            scene_id,
+            {
+                "summary": summary,
+                "title": self._title_from_summary(summary),
+            },
+        )
+        return summary
+
+    def summarize_unsummarized(
+        self,
+        *,
+        user_id: Optional[str] = None,
+        limit: int = 100,
+    ) -> Dict[str, Any]:
+        """Fill missing scene summaries for a bounded maintenance slice."""
+        bounded_limit = max(1, min(int(limit), 2_000))
+        scenes = self.db.get_scenes(user_id=user_id, limit=bounded_limit)
+        summarized: List[Dict[str, Any]] = []
+        skipped_existing = 0
+        skipped_empty = 0
+
+        for scene in scenes:
+            if str(scene.get("summary") or "").strip():
+                skipped_existing += 1
+                continue
+            summary = self.summarize_scene(str(scene["id"]), force=True)
+            if not summary:
+                skipped_empty += 1
+                continue
+            summarized.append(
+                {
+                    "id": scene.get("id"),
+                    "title": self._title_from_summary(summary),
+                }
+            )
+
+        return {
+            "scanned_count": len(scenes),
+            "summarized_count": len(summarized),
+            "skipped_existing": skipped_existing,
+            "skipped_empty": skipped_empty,
+            "summaries": summarized[:50],
+            "truncated_summaries": max(0, len(summarized) - 50),
+        }
+
+    def _generate_scene_summary(
+        self,
+        scene: Dict[str, Any],
+        memories: List[Dict[str, Any]],
+    ) -> Optional[str]:
+        summary = None
+        if self.use_llm_summarization and self.llm:
+            summary = self._summarize_scene(scene, memories)
+        if not summary:
+            summary = self._extractive_scene_summary(memories)
+        return summary
+
     def _summarize_scene(
         self, scene: Dict[str, Any], memories: List[Dict[str, Any]]
     ) -> Optional[str]:
@@ -319,6 +384,14 @@ class SceneProcessor:
             return None
         return " | ".join(snippets)
 
+    @staticmethod
+    def _title_from_summary(summary: str) -> str:
+        cleaned = " ".join(str(summary or "").split())
+        if not cleaned:
+            return "Untitled scene"
+        first_sentence = cleaned.split(".")[0].strip()
+        return (first_sentence or cleaned)[:120]
+
     # ------------------------------------------------------------------
     # Search
     # ------------------------------------------------------------------

{dhee-7.2.3 → dhee-7.2.5}/dhee/db/sqlite.py

@@ -2192,21 +2192,97 @@ class FullSQLiteManager(
             )
 
     def get_pending_enrichment(self, user_id: Optional[str] = None, limit: int = 50) -> List[Dict[str, Any]]:
-        """Return memories with enrichment_status='pending', ordered oldest first."""
+        """Return pending and retryable failed enrichment rows, oldest first."""
+        fetch_limit = max(1, int(limit)) * 4
         with self._get_connection() as conn:
             if user_id:
                 rows = conn.execute(
-                    "SELECT * FROM memories WHERE enrichment_status = 'pending' AND user_id = ? "
+                    "SELECT * FROM memories WHERE enrichment_status IN ('pending', 'failed') AND user_id = ? "
                     "AND tombstone = 0 ORDER BY created_at ASC LIMIT ?",
-                    (user_id, limit),
+                    (user_id, fetch_limit),
                 ).fetchall()
             else:
                 rows = conn.execute(
-                    "SELECT * FROM memories WHERE enrichment_status = 'pending' "
+                    "SELECT * FROM memories WHERE enrichment_status IN ('pending', 'failed') "
                     "AND tombstone = 0 ORDER BY created_at ASC LIMIT ?",
-                    (limit,),
+                    (fetch_limit,),
                 ).fetchall()
-            return [self._row_to_dict(row) for row in rows]
+            retryable: List[Dict[str, Any]] = []
+            for row in rows:
+                memory = self._row_to_dict(row)
+                status = str(memory.get("enrichment_status") or "").lower()
+                metadata = memory.get("metadata") if isinstance(memory.get("metadata"), dict) else {}
+                attempts_raw = metadata.get("enrichment_attempts", 0)
+                try:
+                    attempts = int(attempts_raw or 0)
+                except (TypeError, ValueError):
+                    attempts = 0
+                if status == "pending" or attempts < 3:
+                    retryable.append(memory)
+                if len(retryable) >= max(1, int(limit)):
+                    break
+            return retryable
+
+    def requeue_complete_without_engram_facts(
+        self,
+        user_id: Optional[str] = None,
+        limit: int = 100,
+    ) -> Dict[str, Any]:
+        """Reopen complete semantic memories that have no linked engram facts."""
+        try:
+            with self._get_connection() as conn:
+                conn.execute("SELECT 1 FROM engram_facts LIMIT 0")
+        except Exception:
+            return {"requeued_count": 0, "reason": "engram_facts_unavailable"}
+
+        params: List[Any] = []
+        query = (
+            "SELECT m.* FROM memories m "
+            "LEFT JOIN engram_facts f ON f.memory_id = m.id "
+            "WHERE m.tombstone = 0 "
+            "AND m.enrichment_status = 'complete' "
+            "AND COALESCE(m.memory_type, 'semantic') != 'operational_event' "
+            "GROUP BY m.id HAVING COUNT(f.id) = 0 "
+            "ORDER BY m.created_at ASC LIMIT ?"
+        )
+        if user_id:
+            query = (
+                "SELECT m.* FROM memories m "
+                "LEFT JOIN engram_facts f ON f.memory_id = m.id "
+                "WHERE m.tombstone = 0 "
+                "AND m.enrichment_status = 'complete' "
+                "AND COALESCE(m.memory_type, 'semantic') != 'operational_event' "
+                "AND m.user_id = ? "
+                "GROUP BY m.id HAVING COUNT(f.id) = 0 "
+                "ORDER BY m.created_at ASC LIMIT ?"
+            )
+            params.append(user_id)
+        params.append(max(1, int(limit)))
+
+        rows: List[Dict[str, Any]] = []
+        with self._get_connection() as conn:
+            for row in conn.execute(query, params).fetchall():
+                rows.append(self._row_to_dict(row))
+
+        updates: List[Dict[str, Any]] = []
+        for memory in rows:
+            metadata = memory.get("metadata") if isinstance(memory.get("metadata"), dict) else {}
+            metadata = dict(metadata)
+            metadata["enrichment_attempts"] = 0
+            metadata.pop("last_enrichment_error", None)
+            metadata["reextract_queued_at"] = _utcnow_iso()
+            updates.append(
+                {
+                    "id": memory["id"],
+                    "metadata": metadata,
+                    "enrichment_status": "pending",
+                }
+            )
+        self.update_enrichment_bulk(updates)
+        return {
+            "requeued_count": len(updates),
+            "memory_ids": [item["id"] for item in updates],
+        }
 
     def update_enrichment_status(self, memory_id: str, status: str) -> None:
         """Mark a memory's enrichment_status (e.g. 'complete')."""

{dhee-7.2.3 → dhee-7.2.5}/dhee/doctor.py

@@ -49,6 +49,7 @@ class DoctorReport:
     generated_at: float = 0.0
     core: dict[str, Any] = field(default_factory=dict)
     runtime: dict[str, Any] = field(default_factory=dict)
+    provider_health: dict[str, Any] = field(default_factory=dict)
     router: dict[str, Any] = field(default_factory=dict)
     context: dict[str, Any] = field(default_factory=dict)
     cognition: dict[str, Any] = field(default_factory=dict)
@@ -62,6 +63,7 @@ class DoctorReport:
             "generated_at": self.generated_at,
             "core": self.core,
             "runtime": self.runtime,
+            "provider_health": self.provider_health,
             "router": self.router,
             "context": self.context,
             "cognition": self.cognition,
@@ -123,6 +125,61 @@ def _runtime_section() -> dict[str, Any]:
         return {"error": f"{type(exc).__name__}: {exc}"}
 
 
+def _provider_health_section() -> dict[str, Any]:
+    try:
+        from dhee.cli_config import get_api_key, load_config
+        from dhee.provider_defaults import provider_defaults
+    except Exception as exc:
+        return {"ok": False, "status": "config_error", "error": f"{type(exc).__name__}: {exc}"}
+
+    config = load_config()
+    provider = str(config.get("provider") or "nvidia").strip().lower()
+    defaults = provider_defaults(provider)
+    model = str(config.get("llm_model") or defaults.get("llm_model") or "").strip()
+    if provider != "nvidia":
+        return {
+            "ok": None,
+            "status": "not_implemented",
+            "provider": provider,
+            "model": model,
+        }
+
+    api_key = get_api_key(provider)
+    if not api_key:
+        return {
+            "ok": False,
+            "status": "missing_api_key",
+            "provider": provider,
+            "model": model,
+            "required_env": defaults.get("env_var"),
+        }
+
+    try:
+        from dhee.llms.nvidia import NvidiaLLM
+
+        llm = NvidiaLLM(
+            {
+                "api_key": api_key,
+                "model": model,
+                "temperature": 0,
+                "max_tokens": 2,
+                "timeout": 8,
+                "max_retries": 0,
+                "app_retries": 1,
+            }
+        )
+        return llm.ping()
+    except Exception as exc:
+        return {
+            "ok": False,
+            "status": "unavailable",
+            "provider": provider,
+            "model": model,
+            "error_type": type(exc).__name__,
+            "error": str(exc),
+        }
+
+
 def _context_section() -> dict[str, Any]:
     out: dict[str, Any] = {}
     try:
@@ -597,6 +654,7 @@ def build_report() -> DoctorReport:
 
     core = _core_section()
     runtime = _runtime_section()
+    provider_health = _provider_health_section()
     router = _router_section()
     context = _context_section()
     cognition = _cognition_section()
@@ -609,6 +667,7 @@ def build_report() -> DoctorReport:
         generated_at=time.time(),
         core=core,
         runtime=runtime,
+        provider_health=provider_health,
         router=router,
         context=context,
         cognition=cognition,
@@ -627,6 +686,7 @@ def format_human(report: DoctorReport) -> str:
     lines: list[str] = []
     core = report.core
     runtime = report.runtime
+    provider_health = report.provider_health
     router = report.router
     context = report.context
     cog = report.cognition
@@ -674,6 +734,17 @@ def format_human(report: DoctorReport) -> str:
         lines.append(f"  runtime dir: {paths.get('runtime_dir')}")
     lines.append("")
 
+    # Provider health
+    lines.append("[ provider health ]")
+    lines.append(f"  provider:    {provider_health.get('provider', '?')}")
+    lines.append(f"  model:       {provider_health.get('model', '?')}")
+    lines.append(f"  status:      {provider_health.get('status', '?')}")
+    if provider_health.get("latency_ms") is not None:
+        lines.append(f"  latency:     {provider_health.get('latency_ms')} ms")
+    if provider_health.get("error_type"):
+        lines.append(f"  error:       {provider_health.get('error_type')}: {provider_health.get('error')}")
+    lines.append("")
+
     # Router
     lines.append("[ router ]")
     if "error" in router:

{dhee-7.2.3 → dhee-7.2.5}/dhee/hooks/claude_code/signal.py

@@ -111,6 +111,8 @@ def _write_signal(
         "tool": tool_name,
         "path": path,
         "success": success,
+        "memory_type": "operational_event",
+        "source_app": "claude_code",
     }
 
 
@@ -149,6 +151,8 @@ def _shell_signal(
         "kind": "failure",
         "tool": tool_name,
         "success": False,
+        "memory_type": "operational_event",
+        "source_app": "claude_code",
     }
 
 

{dhee-7.2.3 → dhee-7.2.5}/dhee/llms/nvidia.py

@@ -1,7 +1,7 @@
 import logging
 import os
 import time
-from typing import Optional
+from typing import Any, Dict, Optional
 
 from dhee.llms.base import BaseLLM
 from dhee.provider_defaults import DEFAULT_NVIDIA_LLM_MODEL
@@ -59,6 +59,40 @@ class NvidiaLLM(BaseLLM):
         self.top_p = self.config.get("top_p", 0.7)
         self.enable_thinking = self.config.get("enable_thinking", False)
 
+    def ping(self) -> Dict[str, Any]:
+        """Check that the configured NVIDIA model accepts a minimal chat call."""
+        started = time.perf_counter()
+        try:
+            response = self.client.chat.completions.create(
+                model=self.model,
+                messages=[{"role": "user", "content": "Reply with OK."}],
+                temperature=0,
+                top_p=1,
+                max_tokens=2,
+                stream=False,
+            )
+            content = ""
+            if getattr(response, "choices", None):
+                content = str(response.choices[0].message.content or "").strip()
+            return {
+                "ok": True,
+                "status": "ready",
+                "provider": "nvidia",
+                "model": self.model,
+                "latency_ms": round((time.perf_counter() - started) * 1000, 2),
+                "response_preview": content[:20],
+            }
+        except Exception as exc:
+            return {
+                "ok": False,
+                "status": "unavailable",
+                "provider": "nvidia",
+                "model": self.model,
+                "latency_ms": round((time.perf_counter() - started) * 1000, 2),
+                "error_type": type(exc).__name__,
+                "error": str(exc),
+            }
+
     def generate(self, prompt: str) -> str:
         from openai import APITimeoutError, APIConnectionError