Release Dhee 7.2.5 lifecycle repair

Author: Ashish-dwi99

CHANGELOG.md

@@ -4,6 +4,17 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/), and this project adheres to [Semantic Versioning](https://semver.org/).
 
+## [7.2.5] - 2026-07-03 - Clear-water lifecycle repair
+
+- Updated the default NVIDIA extraction/generation model to
+  `moonshotai/kimi-k2.6` and added a live provider model ping in Dhee doctor.
+- Enabled scene summarization by default and wired lifecycle enrichment to fill
+  missing scene summaries with deterministic fallback summaries.
+- Added scene-noise audit and repair for operational/test prompt scenes,
+  tombstoning active noise while preserving it as episodic events.
+- Expanded `DHEE_DATA_DIR` tildes consistently and hardened pytest data-dir
+  isolation so fixture users do not write into the live vault by accident.
+
 ## [7.2.4] - 2026-07-02 - Clear-water memory enrichment
 
 - Deferred enrichment now runs structured engram extraction and marks honest

dhee/__init__.py

@@ -50,7 +50,7 @@
 # Default import remains model-free for backwards compatibility.
 Memory = CoreMemory
 
-__version__ = "7.2.4"
+__version__ = "7.2.5"
 __all__ = [
     # Memory classes
     "Engram",

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 @@
 )
 
 
+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/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/core/scene.py

@@ -229,16 +229,10 @@ def close_scene(self, scene_id: str, timestamp: Optional[str] = None) -> None:
 
         # 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 @@ def auto_close_stale(self, user_id: str) -> List[str]:
     # 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 @@ def _extractive_scene_summary(memories: List[Dict[str, Any]], max_lines: int = 4
             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/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 @@ def to_dict(self) -> dict[str, Any]:
             "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/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 @@ def __init__(self, config: Optional[dict] = None):
         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