smartmemory-core 0.7.0__tar.gz → 0.7.2__tar.gz

{smartmemory_core-0.7.0 → smartmemory_core-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: smartmemory-core
-Version: 0.7.0
+Version: 0.7.2
 Summary: Multi-layered AI memory system with graph databases, vector stores, and intelligent processing pipelines
 Author: SmartMemory Team
 License-Expression: AGPL-3.0-or-later

smartmemory_core-0.7.2/VERSION

@@ -0,0 +1 @@
+0.7.2

smartmemory_core-0.7.2/smartmemory/anchors/__init__.py

@@ -0,0 +1,4 @@
+from smartmemory.anchors.manager import AnchorManager
+from smartmemory.anchors.queries import AnchorQueries
+
+__all__ = ["AnchorManager", "AnchorQueries"]

smartmemory_core-0.7.2/smartmemory/anchors/drift.py

@@ -0,0 +1,100 @@
+"""Stateless drift checker for CORE-GAPS-1.
+
+Compares anchor content against recent outputs using keyword overlap.
+No SmartMemory dependency — pure Python, testable with plain strings.
+"""
+
+from __future__ import annotations
+
+from smartmemory.anchors.models import DriftReport
+from smartmemory.models.memory_item import MemoryItem
+
+# Common English stopwords to filter out of keyword extraction
+_STOPWORDS = frozenset({
+    "a", "an", "the", "is", "are", "was", "were", "be", "been", "being",
+    "have", "has", "had", "do", "does", "did", "will", "would", "could",
+    "should", "may", "might", "shall", "can", "need", "must", "ought",
+    "and", "but", "or", "nor", "not", "no", "so", "yet", "both", "either",
+    "neither", "each", "every", "all", "any", "few", "more", "most", "other",
+    "some", "such", "than", "too", "very", "just", "also", "only",
+    "in", "on", "at", "to", "for", "of", "with", "by", "from", "as",
+    "into", "through", "during", "before", "after", "above", "below",
+    "between", "under", "over", "about", "up", "out", "off", "then",
+    "once", "here", "there", "when", "where", "why", "how", "what",
+    "which", "who", "whom", "this", "that", "these", "those",
+    "i", "me", "my", "we", "our", "you", "your", "he", "him", "his",
+    "she", "her", "it", "its", "they", "them", "their",
+    "use", "used", "using", "get", "got", "set", "let", "put", "run",
+    "make", "made", "take", "give", "keep", "find", "tell", "ask",
+})
+
+
+class AnchorDriftChecker:
+    """Stateless comparator — receives anchors and recent text, returns drift signals."""
+
+    def check(
+        self,
+        anchors: list[MemoryItem],
+        recent_outputs: list[str],
+    ) -> list[DriftReport]:
+        """Check each anchor against recent outputs for keyword drift.
+
+        Args:
+            anchors: List of anchor MemoryItems.
+            recent_outputs: List of recent output strings to check against.
+
+        Returns:
+            One DriftReport per anchor.
+        """
+        if not anchors:
+            return []
+
+        output_tokens = self._extract_keywords(" ".join(recent_outputs))
+
+        reports = []
+        for anchor in anchors:
+            anchor_keywords = self._extract_keywords(anchor.content)
+            if not anchor_keywords:
+                reports.append(DriftReport(
+                    anchor_id=getattr(anchor, "item_id", "") or "",
+                    anchor_content=anchor.content,
+                    drift_score=0.0,
+                    missing_keywords=[],
+                    severity="none",
+                ))
+                continue
+
+            overlap = anchor_keywords & output_tokens
+            missing = sorted(anchor_keywords - output_tokens)
+            score = 1.0 - (len(overlap) / len(anchor_keywords))
+
+            reports.append(DriftReport(
+                anchor_id=getattr(anchor, "item_id", "") or "",
+                anchor_content=anchor.content,
+                drift_score=round(score, 3),
+                missing_keywords=missing,
+                severity=self._severity(score),
+            ))
+
+        return reports
+
+    def _extract_keywords(self, text: str) -> set[str]:
+        """Extract meaningful keywords from text."""
+        tokens = set()
+        for word in text.lower().split():
+            # Strip punctuation
+            cleaned = word.strip(".,;:!?()[]{}\"'`-_/\\")
+            if len(cleaned) >= 3 and cleaned not in _STOPWORDS:
+                tokens.add(cleaned)
+        return tokens
+
+    def _severity(self, score: float) -> str:
+        """Map drift score to severity level."""
+        if score <= 0.2:
+            return "none"
+        elif score <= 0.5:
+            return "mild"
+        elif score <= 0.8:
+            return "significant"
+        else:
+            return "critical"

smartmemory_core-0.7.2/smartmemory/anchors/manager.py

@@ -0,0 +1,186 @@
+"""AnchorManager — lifecycle orchestrator for CORE-GAPS-1.
+
+Manages anchor creation, listing, clearing, graduation to decisions,
+and drift detection. Follows the PlanManager pattern.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any, Optional
+from uuid import uuid4
+
+from smartmemory.anchors.drift import AnchorDriftChecker
+from smartmemory.anchors.models import DriftReport
+from smartmemory.anchors.queries import AnchorQueries
+
+if TYPE_CHECKING:
+    from smartmemory.smart_memory import SmartMemory
+
+logger = logging.getLogger(__name__)
+
+VALID_ANCHOR_TYPES = {"spec", "scope", "decision", "constraint"}
+
+# Graduation mapping: anchor_type -> decision_type
+_GRADUATION_MAP = {
+    "spec": "policy",
+    "scope": "policy",
+    "constraint": "policy",
+    "decision": "inference",
+}
+
+
+class AnchorManager:
+    """Lifecycle manager for spec anchors."""
+
+    def __init__(self, memory: SmartMemory) -> None:
+        self.memory = memory
+        self.queries = AnchorQueries(memory)
+        self.drift_checker = AnchorDriftChecker()
+
+    def set(self, content: str, anchor_type: str, session_id: str) -> str:
+        """Create a new anchor.
+
+        Args:
+            content: The requirement/constraint text.
+            anchor_type: One of spec, scope, decision, constraint.
+            session_id: Session scope for this anchor.
+
+        Returns:
+            The anchor item_id.
+
+        Raises:
+            ValueError: If anchor_type is invalid.
+        """
+        if anchor_type not in VALID_ANCHOR_TYPES:
+            raise ValueError(
+                f"Invalid anchor_type '{anchor_type}'. "
+                f"Must be one of: {', '.join(sorted(VALID_ANCHOR_TYPES))}"
+            )
+
+        anchor_id = f"anchor_{uuid4().hex[:12]}"
+        item_id = self.memory.ingest_structured(
+            {
+                "content": content,
+                "anchor_type": anchor_type,
+                "session_id": session_id,
+                "anchor_id": anchor_id,
+            },
+            schema="anchor",
+        )
+        logger.info(f"Anchor set: {item_id} type={anchor_type} session={session_id}")
+        return item_id
+
+    def list(
+        self, session_id: str, anchor_type: Optional[str] = None
+    ) -> list[dict[str, Any]]:
+        """List active anchors for a session.
+
+        Args:
+            session_id: Session scope.
+            anchor_type: Optional type filter.
+
+        Returns:
+            List of anchor dicts.
+        """
+        return self.queries.get_active(session_id, anchor_type)
+
+    def clear(
+        self, session_id: str, anchor_type: Optional[str] = None
+    ) -> int:
+        """Clear (deactivate) anchors for a session.
+
+        Args:
+            session_id: Session scope.
+            anchor_type: Optional type filter. If None, clears all.
+
+        Returns:
+            Number of anchors cleared.
+        """
+        active = self.queries.get_active(session_id, anchor_type)
+        count = 0
+        for anchor in active:
+            try:
+                self.memory.update_properties(
+                    anchor["anchor_id"],
+                    {"anchor_status": "cleared"},
+                )
+                count += 1
+            except Exception as e:
+                logger.warning(f"Failed to clear anchor {anchor['anchor_id']}: {e}")
+        logger.info(f"Cleared {count} anchors for session={session_id}")
+        return count
+
+    def graduate(self, session_id: str) -> list[str]:
+        """Graduate active anchors to decisions.
+
+        Creates a decision for each active anchor via DecisionManager,
+        then marks the anchor as graduated.
+
+        Args:
+            session_id: Session scope.
+
+        Returns:
+            List of created decision IDs.
+        """
+        from smartmemory.decisions.manager import DecisionManager
+
+        active = self.queries.get_active(session_id)
+        if not active:
+            return []
+
+        dm = DecisionManager(self.memory)
+        decision_ids = []
+
+        for anchor in active:
+            anchor_type = anchor.get("anchor_type", "spec")
+            decision_type = _GRADUATION_MAP.get(anchor_type, "policy")
+
+            try:
+                decision = dm.create(
+                    content=anchor["content"],
+                    decision_type=decision_type,
+                    evidence_ids=[anchor["anchor_id"]],
+                )
+                decision_id = decision.decision_id
+
+                self.memory.update_properties(
+                    anchor["anchor_id"],
+                    {
+                        "anchor_status": "graduated",
+                        "graduated_to": decision_id,
+                    },
+                )
+                decision_ids.append(decision_id)
+                logger.info(
+                    f"Graduated anchor {anchor['anchor_id']} -> decision {decision_id}"
+                )
+            except Exception as e:
+                logger.error(f"Failed to graduate anchor {anchor['anchor_id']}: {e}")
+
+        return decision_ids
+
+    def check_drift(
+        self, session_id: str, recent_outputs: list[str]
+    ) -> list[DriftReport]:
+        """Check active anchors for drift against recent outputs.
+
+        Args:
+            session_id: Session scope.
+            recent_outputs: List of recent output strings.
+
+        Returns:
+            List of DriftReport, one per active anchor.
+        """
+        active = self.queries.get_active(session_id)
+        if not active:
+            return []
+
+        # Convert dicts to MemoryItems for the drift checker
+        anchor_items = []
+        for a in active:
+            item = self.memory.get(a["anchor_id"])
+            if item is not None:
+                anchor_items.append(item)
+
+        return self.drift_checker.check(anchor_items, recent_outputs)

smartmemory_core-0.7.2/smartmemory/anchors/models.py

@@ -0,0 +1,16 @@
+"""Data models for CORE-GAPS-1 anchor drift detection."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class DriftReport:
+    """Result of comparing an anchor against recent outputs."""
+
+    anchor_id: str
+    anchor_content: str
+    drift_score: float  # 0.0 = aligned, 1.0 = fully drifted
+    missing_keywords: list[str]
+    severity: str  # "none" | "mild" | "significant" | "critical"

smartmemory_core-0.7.2/smartmemory/anchors/queries.py

@@ -0,0 +1,139 @@
+"""Read-only query helpers for CORE-GAPS-1 anchors.
+
+Follows the PlanQueries pattern: direct SQLite for INDEXED types,
+search fallback for FalkorDB.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import TYPE_CHECKING, Any, Optional
+
+if TYPE_CHECKING:
+    from smartmemory.smart_memory import SmartMemory
+
+logger = logging.getLogger(__name__)
+
+
+class AnchorQueries:
+    """Read-only queries for anchor items."""
+
+    def __init__(self, memory: SmartMemory) -> None:
+        self.memory = memory
+
+    def get_active(
+        self, session_id: str, anchor_type: Optional[str] = None
+    ) -> list[dict[str, Any]]:
+        """Get active anchors for a session.
+
+        Args:
+            session_id: Session scope.
+            anchor_type: Optional filter (spec, scope, decision, constraint).
+
+        Returns:
+            List of anchor dicts with keys: anchor_id, content, anchor_type,
+            session_id, status, created_at.
+        """
+        backend = self.memory._graph.backend
+
+        from smartmemory.graph.backends.sqlite import SQLiteBackend
+        if isinstance(backend, SQLiteBackend):
+            return self._get_active_sqlite(backend, session_id, anchor_type)
+        return self._get_active_search_fallback(session_id, anchor_type)
+
+    def get_by_id(self, anchor_id: str) -> Optional[dict[str, Any]]:
+        """Get a single anchor by ID."""
+        item = self.memory.get(anchor_id)
+        if item is None:
+            return None
+        if getattr(item, "memory_type", None) != "anchor":
+            return None
+        return self._to_dict(item)
+
+    # -- SQLite path --
+
+    def _get_active_sqlite(
+        self, backend: Any, session_id: str, anchor_type: Optional[str]
+    ) -> list[dict[str, Any]]:
+        """Direct SQLite query for active anchors."""
+        sql = (
+            "SELECT item_id, properties FROM nodes "
+            "WHERE memory_type = 'anchor' "
+            "AND json_extract(properties, '$.anchor_status') = 'active' "
+            "AND json_extract(properties, '$.anchor_session') = ?"
+        )
+        params: list[Any] = [session_id]
+
+        if anchor_type:
+            sql += " AND json_extract(properties, '$.anchor_type') = ?"
+            params.append(anchor_type)
+
+        with backend._lock:
+            rows = backend._conn.execute(sql, params).fetchall()
+
+        return [self._row_to_dict(row) for row in rows]
+
+    # -- Search fallback --
+
+    def _get_active_search_fallback(
+        self, session_id: str, anchor_type: Optional[str]
+    ) -> list[dict[str, Any]]:
+        """Fallback using graph.search_nodes() for non-SQLite backends.
+
+        INDEXED types have no embeddings, so memory.search() is unreliable.
+        Use direct property-equality queries on the graph backend instead.
+        """
+        query: dict[str, Any] = {
+            "memory_type": "anchor",
+            "anchor_status": "active",
+            "anchor_session": session_id,
+        }
+        if anchor_type:
+            query["anchor_type"] = anchor_type
+
+        try:
+            rows = self.memory._graph.backend.search_nodes(query)
+        except Exception as e:
+            logger.warning(f"FalkorDB anchor query failed: {e}")
+            return []
+
+        return [self._node_to_dict(row) for row in rows]
+
+    def _node_to_dict(self, node: dict[str, Any]) -> dict[str, Any]:
+        """Convert a graph node dict to anchor dict."""
+        return {
+            "anchor_id": node.get("item_id", ""),
+            "content": node.get("content", ""),
+            "anchor_type": node.get("anchor_type", "spec"),
+            "session_id": node.get("anchor_session", ""),
+            "status": node.get("anchor_status", "active"),
+            "created_at": node.get("transaction_time", ""),
+        }
+
+    # -- Converters --
+
+    def _row_to_dict(self, row: tuple) -> dict[str, Any]:
+        """Convert SQLite row to anchor dict."""
+        item_id, props_str = row
+        props = json.loads(props_str) if props_str else {}
+        return {
+            "anchor_id": item_id,
+            "content": props.get("content", ""),
+            "anchor_type": props.get("anchor_type", "spec"),
+            "session_id": props.get("anchor_session", ""),
+            "status": props.get("anchor_status", "active"),
+            "created_at": props.get("transaction_time", ""),
+        }
+
+    def _to_dict(self, item: Any) -> dict[str, Any]:
+        """Convert MemoryItem to anchor dict."""
+        meta = getattr(item, "metadata", {}) or {}
+        return {
+            "anchor_id": getattr(item, "item_id", ""),
+            "content": getattr(item, "content", ""),
+            "anchor_type": meta.get("anchor_type", "spec"),
+            "session_id": meta.get("anchor_session", ""),
+            "status": meta.get("anchor_status", "active"),
+            "created_at": str(getattr(item, "transaction_time", "")),
+        }

{smartmemory_core-0.7.0 → smartmemory_core-0.7.2}/smartmemory/background/extraction_worker.py

@@ -50,6 +50,7 @@ def _entity_for_storage(memory: Any, entity: MemoryItem) -> MemoryItem:
             entities=entity.entities,
             relations=entity.relations,
             metadata=dict(entity.metadata or {}),
+            derived_from=entity.derived_from,  # Phase 0: preserve lineage (CORE-ORIGIN-1)
         )
     return entity
 
@@ -171,6 +172,7 @@ def process_extract_job(
             if stored_entity.metadata is None:
                 stored_entity.metadata = {}
             stored_entity.metadata.setdefault("node_category", "entity")
+            stored_entity.derived_from = item_id  # Phase 0: link to parent memory (CORE-ORIGIN-1)
             result = memory._crud.add(stored_entity)
             if isinstance(result, dict):
                 net_new_node_id = result.get("memory_node_id") or stored_entity.item_id or entity.item_id
@@ -225,6 +227,8 @@ def process_extract_job(
                 "canonical_type": canonical,
                 "raw_predicate": raw_pred,
                 "normalization_confidence": norm_conf,
+                "origin": "enricher:llm_extract",
+                "confidence": 0.6,
             }
             memory._graph.add_edge(
                 rel["source_id"],

{smartmemory_core-0.7.0 → smartmemory_core-0.7.2}/smartmemory/cli.py

@@ -31,11 +31,39 @@ def _get_memory(ctx):
 @main.command()
 @click.argument("text")
 @click.option("--no-markdown", is_flag=True, default=False, help="Skip markdown file creation")
+@click.option("--schema", default=None, help="Structured ingestion schema (e.g. decision, tool_call, plan)")
 @click.pass_context
-def add(ctx, text, no_markdown):
-    """Add a memory. Extracts entities and stores to local database."""
+def add(ctx, text, no_markdown, schema):
+    """Add a memory. Extracts entities and stores to local database.
+
+    With --schema, treats TEXT as JSON and routes through structured ingestion
+    (bypasses NLP pipeline). Available schemas: decision, tool_call, plan_task,
+    conversation_turn, hook_capture, seed_item, code_entity, plan.
+    """
     memory = _get_memory(ctx)
-    item_id = memory.ingest(text)
+
+    if schema:
+        import json as _json
+
+        try:
+            data = _json.loads(text)
+        except _json.JSONDecodeError as e:
+            console.print(f"[red]Invalid JSON:[/red] {e}")
+            raise SystemExit(1) from None
+        try:
+            item_id = memory.ingest_structured(data, schema=schema)
+        except KeyError as e:
+            console.print(f"[red]Unknown schema:[/red] {e}")
+            raise SystemExit(1) from None
+        except ValueError as e:
+            console.print(f"[red]Validation error:[/red] {e}")
+            raise SystemExit(1) from None
+        console.print(f"[green]Stored ({schema}):[/green] {item_id}")
+        return
+
+    from smartmemory.models.memory_item import MemoryItem as _MI
+    _item = _MI(content=text, origin="cli:add")
+    item_id = memory.ingest(_item)
     console.print(f"[green]Stored:[/green] {item_id}")
     if not no_markdown:
         data_dir = ctx.obj["data_dir"] or str(Path.home() / ".smartmemory")
@@ -146,7 +174,9 @@ def watch(ctx, vault_path):
         def _ingest(self, path):
             try:
                 content = Path(path).read_text(encoding="utf-8")
-                item_id = memory.ingest(content)
+                from smartmemory.models.memory_item import MemoryItem as _MI
+                _item = _MI(content=content, origin="cli:watch")
+                item_id = memory.ingest(_item)
                 console.print(f"[green]Ingested:[/green] {path} → {item_id}")
             except Exception as e:
                 console.print(f"[red]Error ingesting {path}:[/red] {e}")
@@ -162,3 +192,50 @@ def watch(ctx, vault_path):
     except KeyboardInterrupt:
         observer.stop()
     observer.join()
+
+
+@main.command()
+@click.argument("text")
+@click.option("--type", "anchor_type", default="spec",
+              type=click.Choice(["spec", "scope", "decision", "constraint"]))
+@click.option("--session", default="")
+@click.pass_context
+def anchor(ctx, text, anchor_type, session):
+    """Set a spec anchor (requirement/constraint for anti-drift)."""
+    memory = _get_memory(ctx)
+    from smartmemory.anchors.manager import AnchorManager
+    manager = AnchorManager(memory)
+    item_id = manager.set(text, anchor_type, session)
+    console.print(f"[green]Anchor set:[/green] {item_id} (type={anchor_type})")
+
+
+@main.command()
+@click.option("--session", default="")
+@click.option("--type", "anchor_type", default=None,
+              type=click.Choice(["spec", "scope", "decision", "constraint"]))
+@click.pass_context
+def anchors(ctx, session, anchor_type):
+    """List active anchors."""
+    memory = _get_memory(ctx)
+    from smartmemory.anchors.manager import AnchorManager
+    manager = AnchorManager(memory)
+    items = manager.list(session, anchor_type)
+    if not items:
+        console.print("[dim]No active anchors.[/dim]")
+        return
+    for item in items:
+        console.print(f"[bold][{item['anchor_type']}][/bold] {item['content']}")
+
+
+@main.command(name="anchor-clear")
+@click.option("--session", default="")
+@click.option("--type", "anchor_type", default=None,
+              type=click.Choice(["spec", "scope", "decision", "constraint"]))
+@click.pass_context
+def anchor_clear(ctx, session, anchor_type):
+    """Clear active anchors."""
+    memory = _get_memory(ctx)
+    from smartmemory.anchors.manager import AnchorManager
+    manager = AnchorManager(memory)
+    count = manager.clear(session, anchor_type)
+    console.print(f"[green]Cleared {count} anchor(s).[/green]")

{smartmemory_core-0.7.0 → smartmemory_core-0.7.2}/smartmemory/code/models.py

@@ -42,6 +42,7 @@ class CodeEntity:
             "line_number": self.line_number,
             "repo": self.repo,
             "memory_type": "code",
+            "origin": "code:index",
         }
         if self.docstring:
             props["docstring"] = self.docstring[:500]  # truncate long docstrings

{smartmemory_core-0.7.0 → smartmemory_core-0.7.2}/smartmemory/corpus/importer.py

@@ -148,9 +148,12 @@ class CorpusImporter:
 
     def _import_full(self, record: CorpusRecord) -> None:
         """Full pipeline import via SmartMemory.ingest()."""
+        # CORE-PROPS-1 Phase 6: pack content is reference data
+        meta = dict(record.metadata) if record.metadata else {}
+        meta["reference"] = True
         self._sm.ingest(
             {"content": record.content, "memory_type": record.memory_type},
-            **record.metadata,
+            **meta,
         )
 
     def _import_direct(self, record: CorpusRecord) -> None:
@@ -158,6 +161,7 @@ class CorpusImporter:
         from smartmemory.models.memory_item import MemoryItem
 
         item = MemoryItem(content=record.content, memory_type=record.memory_type)
+        item.reference = True  # CORE-PROPS-1 Phase 6: pack content is reference data
         if record.metadata:
             item.metadata.update(record.metadata)
 

{smartmemory_core-0.7.0 → smartmemory_core-0.7.2}/smartmemory/decisions/manager.py

@@ -86,7 +86,7 @@ class DecisionManager:
                 source_id=source_trace_id,
                 target_id=decision.decision_id,
                 edge_type="PRODUCED",
-                properties={"confidence": confidence, "timestamp": datetime.now(timezone.utc).isoformat()},
+                properties={"confidence": 0.5, "timestamp": datetime.now(timezone.utc).isoformat(), "origin": "evolver:decision"},
             )
 
         if evidence_ids:
@@ -153,7 +153,7 @@ class DecisionManager:
                 source_id=new_decision.decision_id,
                 target_id=old_decision_id,
                 edge_type="SUPERSEDES",
-                properties={"reason": reason, "timestamp": datetime.now(timezone.utc).isoformat()},
+                properties={"reason": reason, "timestamp": datetime.now(timezone.utc).isoformat(), "origin": "evolver:decision", "confidence": 0.5},
             )
 
         return new_decision
@@ -229,7 +229,7 @@ class DecisionManager:
                 source_id=evidence_id,
                 target_id=decision_id,
                 edge_type="CONTRADICTS",
-                properties={"detected_at": datetime.now(timezone.utc).isoformat()},
+                properties={"detected_at": datetime.now(timezone.utc).isoformat(), "origin": "evolver:decision", "confidence": 0.5},
             )
 
         return decision
@@ -284,6 +284,8 @@ class DecisionManager:
             content=decision.content,
             memory_type="decision",
             item_id=decision.decision_id,
+            confidence=decision.confidence,  # Phase 0: first-class field (CORE-ORIGIN-1)
+            derived_from=decision.evidence_ids[0] if decision.evidence_ids else None,  # Phase 0: primary evidence
             metadata=decision.to_dict(),
         )
         return self.memory.add(item)
@@ -321,7 +323,7 @@ class DecisionManager:
                     source_id=decision_id,
                     target_id=evidence_id,
                     edge_type="DERIVED_FROM",
-                    properties={"role": "evidence"},
+                    properties={"role": "evidence", "origin": "evolver:decision", "confidence": 0.5},
                 )
             except Exception as e:
                 logger.debug(f"Failed to create DERIVED_FROM edge {decision_id} -> {evidence_id}: {e}")