dhee 7.2.4__tar.gz → 7.2.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dhee
-Version: 7.2.4
+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.4 → 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.4"
+__version__ = "7.2.5"
 __all__ = [
     # Memory classes
     "Engram",

{dhee-7.2.4 → 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.4 → 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.4 → 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.4 → 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.4 → 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
 

{dhee-7.2.4 → dhee-7.2.5}/dhee/memory/main.py

@@ -6,11 +6,14 @@ import logging
 import math
 import os
 import re
+import shutil
+import sqlite3
 import time
 import uuid
 from dataclasses import dataclass
 from datetime import datetime, date, timezone
 from enum import Enum
+from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple, Union
 
 from dhee.configs.base import MemoryConfig
@@ -77,6 +80,19 @@ from dhee.utils.prompts import AGENT_MEMORY_EXTRACTION_PROMPT, MEMORY_EXTRACTION
 
 logger = logging.getLogger(__name__)
 
+_SCENE_BENCHMARK_NOISE_RE = re.compile(
+    r"\b(?:you are fixing a real bug|benchmark prompt|swe-bench|fail[- ]to[- ]pass)\b",
+    re.IGNORECASE,
+)
+_SCENE_OPERATIONAL_VERB_RE = re.compile(
+    r"^\s*(?:edited|wrote|created|updated|modified|touched)\s+(.{1,240})\s*$",
+    re.IGNORECASE,
+)
+_SCENE_PATH_HINT_RE = re.compile(
+    r"(?:^|\s)(?:/|~/|\./|[\w.-]+\.(?:py|js|ts|tsx|jsx|go|rs|java|rb|php|sh|sql|toml|yaml|yml|json|md)\b)",
+    re.IGNORECASE,
+)
+
 # ---------------------------------------------------------------------------
 # Inline helpers (formerly in deleted core/acceptance and core/policy modules)
 # ---------------------------------------------------------------------------
@@ -1159,11 +1175,17 @@ class FullMemory(SmartMemory, SceneProfileMixin):
         max_batches: int = 5,
     ) -> Dict[str, Any]:
         """Batch-enrich memories that were stored with deferred enrichment."""
-        return self._write_pipeline.enrich_pending(
+        result = self._write_pipeline.enrich_pending(
             user_id=user_id,
             batch_size=batch_size,
             max_batches=max_batches,
         )
+        if self.scene_processor:
+            result["scene_summaries"] = self.scene_processor.summarize_unsummarized(
+                user_id=user_id,
+                limit=max(1, min(int(batch_size) * int(max_batches), 500)),
+            )
+        return result
 
     def reextract(
         self,
@@ -1953,6 +1975,146 @@ class FullMemory(SmartMemory, SceneProfileMixin):
                 break
         return memories
 
+    @staticmethod
+    def _scene_noise_kind(scene: Dict[str, Any]) -> Optional[str]:
+        title = str(scene.get("title") or "").strip()
+        summary = str(scene.get("summary") or "").strip()
+        topic = str(scene.get("topic") or "").strip()
+        text = "\n".join(part for part in (title, summary, topic) if part)
+        if not text:
+            return None
+        if _SCENE_BENCHMARK_NOISE_RE.search(text):
+            return "benchmark_prompt_scene"
+        operational = _SCENE_OPERATIONAL_VERB_RE.match(title)
+        if operational and _SCENE_PATH_HINT_RE.search(operational.group(1)):
+            return "operational_scene"
+        return None
+
+    def _scene_noise_candidates(
+        self,
+        *,
+        user_id: Optional[str],
+        limit: int,
+    ) -> List[Dict[str, Any]]:
+        bounded_limit = max(1, min(int(limit), 50_000))
+        query = """
+            SELECT id, user_id, title, summary, topic, start_time, end_time
+            FROM scenes
+            WHERE tombstone = 0
+        """
+        params: List[Any] = []
+        if user_id:
+            query += " AND user_id = ?"
+            params.append(user_id)
+        query += " ORDER BY start_time DESC LIMIT ?"
+        params.append(bounded_limit)
+        with self.db._get_connection() as conn:
+            rows = [dict(row) for row in conn.execute(query, params).fetchall()]
+
+        candidates: List[Dict[str, Any]] = []
+        for row in rows:
+            kind = self._scene_noise_kind(row)
+            if not kind:
+                continue
+            row["noise_kind"] = kind
+            candidates.append(row)
+        return candidates
+
+    def _backup_history_db(self, reason: str) -> Optional[str]:
+        raw_path = getattr(self.config, "history_db_path", None)
+        if not raw_path:
+            return None
+        db_path = Path(str(raw_path)).expanduser().resolve()
+        if not db_path.exists():
+            return None
+        timestamp = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+        backup_dir = db_path.parent / "backups"
+        backup_dir.mkdir(parents=True, exist_ok=True)
+        backup_path = backup_dir / f"{db_path.stem}-{reason}-{timestamp}{db_path.suffix}"
+        shutil.copy2(db_path, backup_path)
+        return str(backup_path)
+
+    def _tombstone_scene_noise(
+        self,
+        candidates: List[Dict[str, Any]],
+        *,
+        dry_run: bool,
+    ) -> Dict[str, Any]:
+        counts = {
+            "scene_noise_tombstoned": 0,
+            "operational_scenes_tombstoned": 0,
+            "benchmark_scenes_tombstoned": 0,
+            "scene_noise_events_written": 0,
+        }
+        if not candidates:
+            return {**counts, "scene_noise_backup": None}
+
+        for scene in candidates:
+            if scene["noise_kind"] == "operational_scene":
+                counts["operational_scenes_tombstoned"] += 1
+            elif scene["noise_kind"] == "benchmark_prompt_scene":
+                counts["benchmark_scenes_tombstoned"] += 1
+        counts["scene_noise_tombstoned"] = len(candidates)
+        if dry_run:
+            return {**counts, "scene_noise_backup": None}
+
+        backup_path = self._backup_history_db("scene-noise")
+        now = datetime.now(timezone.utc).isoformat()
+        events: List[Dict[str, Any]] = []
+        for scene in candidates:
+            scene_id = str(scene["id"])
+            event_time = str(scene.get("start_time") or scene.get("end_time") or now)
+            event_type = (
+                "operational_event"
+                if scene["noise_kind"] == "operational_scene"
+                else "test_fixture"
+            )
+            value_text = str(scene.get("title") or scene.get("summary") or scene_id)
+            events.append(
+                {
+                    "id": f"scene-noise:{scene_id}",
+                    "memory_id": f"scene:{scene_id}",
+                    "user_id": scene.get("user_id") or "default",
+                    "conversation_id": None,
+                    "session_id": None,
+                    "turn_id": 0,
+                    "actor_id": "dhee_scene_repair",
+                    "actor_role": "maintenance",
+                    "event_time": event_time,
+                    "event_type": event_type,
+                    "canonical_key": f"scene_noise:{scene['noise_kind']}:{scene_id}",
+                    "value_text": value_text,
+                    "value_num": None,
+                    "value_unit": None,
+                    "currency": None,
+                    "normalized_time_start": event_time,
+                    "normalized_time_end": event_time,
+                    "time_granularity": "instant",
+                    "entity_key": str(scene.get("topic") or scene.get("title") or scene_id)[:240],
+                    "value_norm": " ".join(value_text.lower().split())[:500],
+                    "confidence": 1.0,
+                    "superseded_by": None,
+                }
+            )
+        counts["scene_noise_events_written"] = self.db.add_episodic_events(events)
+        scene_ids = [(str(scene["id"]),) for scene in candidates]
+        with self.db._get_connection() as conn:
+            conn.executemany(
+                "UPDATE scenes SET tombstone = 1, strength = 0.0 WHERE id = ?",
+                scene_ids,
+            )
+            try:
+                conn.executemany(
+                    "UPDATE memories SET scene_id = NULL WHERE scene_id = ?",
+                    scene_ids,
+                )
+            except sqlite3.OperationalError as exc:
+                if "no such column" not in str(exc).lower():
+                    raise
+        with self.db._get_connection() as conn:
+            conn.execute("VACUUM")
+        return {**counts, "scene_noise_backup": backup_path}
+
     def get_stats(self, user_id: Optional[str] = None, agent_id: Optional[str] = None) -> Dict[str, Any]:
         memories = self._get_quality_health_memories(user_id=user_id, agent_id=agent_id)
         sml_count = sum(1 for m in memories if m.get("layer") == "sml")
@@ -2094,6 +2256,9 @@ class FullMemory(SmartMemory, SceneProfileMixin):
             "evidence_without_distillation": 0,
             "contract_repairs_available": 0,
             "profile_contamination": 0,
+            "scene_noise": 0,
+            "operational_scene_noise": 0,
+            "benchmark_scene_noise": 0,
         }
         samples: Dict[str, List[Dict[str, Any]]] = {
             "unresolved_test_noise": [],
@@ -2104,6 +2269,7 @@ class FullMemory(SmartMemory, SceneProfileMixin):
             "damaged_canonical": [],
             "evidence_without_distillation": [],
             "profile_contamination": [],
+            "scene_noise": [],
         }
 
         def _sample(memory: Dict[str, Any], issue: str, updates: List[str]) -> None:
@@ -2242,6 +2408,26 @@ class FullMemory(SmartMemory, SceneProfileMixin):
                     }
                 )
 
+        scene_noise = self._scene_noise_candidates(user_id=user_id, limit=limit)
+        counts["scene_noise"] = len(scene_noise)
+        for scene in scene_noise:
+            if scene["noise_kind"] == "operational_scene":
+                counts["operational_scene_noise"] += 1
+            elif scene["noise_kind"] == "benchmark_prompt_scene":
+                counts["benchmark_scene_noise"] += 1
+            bucket = samples.setdefault("scene_noise", [])
+            if len(bucket) < 8:
+                bucket.append(
+                    {
+                        "id": scene.get("id"),
+                        "user_id": scene.get("user_id"),
+                        "noise_kind": scene.get("noise_kind"),
+                        "title": scene.get("title"),
+                    }
+                )
+        if scene_noise:
+            counts["contract_repairs_available"] += len(scene_noise)
+
         checks: List[Dict[str, Any]] = []
 
         def _check(name: str, passed: bool, severity: str, detail: str) -> None:
@@ -2323,6 +2509,12 @@ class FullMemory(SmartMemory, SceneProfileMixin):
             "critical",
             f"{counts['profile_contamination']} derived profile anchors contain tool/test/doc noise.",
         )
+        _check(
+            "no_scene_noise",
+            counts["scene_noise"] == 0,
+            "critical",
+            f"{counts['scene_noise']} operational/test prompt scenes remain active.",
+        )
 
         failed_critical = [check for check in checks if check["severity"] == "critical" and not check["passed"]]
         failed_warnings = [check for check in checks if check["severity"] == "warning" and not check["passed"]]
@@ -2335,6 +2527,8 @@ class FullMemory(SmartMemory, SceneProfileMixin):
             recommended_actions.append("Run repair_memory_quality with dry_run=false, then rerun this audit.")
         if counts["degraded_or_queued"]:
             recommended_actions.append("Run enrich_pending after repair to reconcile queued/degraded rows.")
+        if counts["scene_noise"]:
+            recommended_actions.append("Run repair_memory_quality with dry_run=false to tombstone operational/test prompt scenes.")
         if require_personal_model and counts["canonical_personal"] == 0:
             recommended_actions.append("Ingest explicit goals, preferences, decisions, style, and product philosophy as canonical personal memories.")
         if profile_l and counts["canonical_profile_matches"] == 0:
@@ -2404,6 +2598,10 @@ class FullMemory(SmartMemory, SceneProfileMixin):
             "queued_reopened": 0,
             "malformed_metadata_normalized": 0,
             "profiles_cleaned": 0,
+            "scene_noise_tombstoned": 0,
+            "operational_scenes_tombstoned": 0,
+            "benchmark_scenes_tombstoned": 0,
+            "scene_noise_events_written": 0,
         }
         for memory in memories:
             raw_metadata = memory.get("metadata")
@@ -2520,11 +2718,31 @@ class FullMemory(SmartMemory, SceneProfileMixin):
             if not dry_run:
                 self.db.update_profile(str(profile["id"]), updates)
 
+        scene_noise = self._scene_noise_candidates(user_id=user_id, limit=limit)
+        for scene in scene_noise:
+            repaired.append(
+                {
+                    "id": scene.get("id"),
+                    "memory_class": scene.get("noise_kind"),
+                    "updates": ["tombstone", "episodic_event"],
+                    "title": scene.get("title"),
+                }
+            )
+        scene_repair = self._tombstone_scene_noise(scene_noise, dry_run=dry_run)
+        for key in (
+            "scene_noise_tombstoned",
+            "operational_scenes_tombstoned",
+            "benchmark_scenes_tombstoned",
+            "scene_noise_events_written",
+        ):
+            counts[key] = int(scene_repair.get(key, 0) or 0)
+
         result = {
             "dry_run": dry_run,
             "scanned_count": len(memories),
             "repair_count": len(repaired),
             **counts,
+            "scene_noise_backup": scene_repair.get("scene_noise_backup"),
             "repairs": repaired[:200],
             "truncated_repairs": max(0, len(repaired) - 200),
         }

{dhee-7.2.4 → dhee-7.2.5}/dhee/provider_defaults.py

@@ -8,7 +8,7 @@ from typing import Any, Dict, Optional
 DEFAULT_PROVIDER = "nvidia"
 DEFAULT_COLLECTION = "dhee"
 
-DEFAULT_NVIDIA_LLM_MODEL = "moonshotai/kimi-k2.5"
+DEFAULT_NVIDIA_LLM_MODEL = "moonshotai/kimi-k2.6"
 DEFAULT_NVIDIA_EMBEDDER_MODEL = "nvidia/llama-nemotron-embed-vl-1b-v2"
 DEFAULT_NVIDIA_RERANK_MODEL = "nvidia/llama-nemotron-rerank-vl-1b-v2"
 DEFAULT_NVIDIA_EMBEDDING_DIMS = 2048