get-claudia 1.58.0 → 1.59.1

package/CHANGELOG.md

@@ -2,6 +2,35 @@
 
 All notable changes to Claudia will be documented in this file.
 
+## 1.59.1 (2026-05-15)
+
+### Docs uplift
+
+Pure documentation. No code change.
+
+### Documentation
+- Added subpackage READMEs under `memory-daemon/claudia_memory/`: `services/`, `daemon/`, `extraction/`, `mcp/`. Each names the public entry points, lists the most relevant files, and captures the conventions a contributor needs to know before editing.
+- Expanded `CONTRIBUTING.md` with a "Your first PR" walkthrough covering the seven-step path from picking a starter issue to opening the PR.
+
+No user-visible behavior change.
+
+---
+
+## 1.59.0 (2026-05-15)
+
+### Removed
+- `claudia_memory.services.verify.VerifyService` and `run_verification`. No production callers since v1.35; only the dedicated test referenced it.
+- `claudia_memory.services.metrics.MetricsService` and `get_metrics_service`. Never wired into the scheduler, MCP server, or any service; only the dedicated test referenced it.
+- Orphan test files `tests/test_verify.py` (7 tests) and `tests/test_metrics.py` (12 tests).
+
+### Documentation
+- Added "Verifying dead code" section to `CONTRIBUTING.md` documenting the audit method used in this release.
+- Refactor design plan: `docs/plans/2026-05-15-craft-refactor-design.md` (shipped in PR #58).
+
+No user-visible behavior change. No CLI flag change. No MCP tool change. No database schema change.
+
+---
+
 ## 1.58.0 (2026-05-13)
 
 ### The Memory Reliability Release

package/memory-daemon/claudia_memory/daemon/README.md

@@ -0,0 +1,16 @@
+# daemon/
+
+Long-running side of the memory daemon: scheduled background jobs and a local HTTP health endpoint. Only used when the daemon runs in standalone mode (`--standalone`); the MCP-server path (stdio transport, default) does not run these.
+
+## Where to look first
+
+| Concern | File | Notes |
+|---------|------|-------|
+| Scheduled background work | `scheduler.py` | APScheduler with three jobs: `daily_decay` at 02:00, `pattern_detection` every 6 hours, `full_consolidation` at 03:00. Optional `vault_sync` at 03:15 if `vault_sync_enabled` is set. |
+| Health endpoint | `health.py` | HTTP server bound to `localhost:3848`. The `/health` route is what the npm installer probes during Step 5 of install. The `/status` route powers the `memory_system_health` MCP tool. |
+
+## Conventions
+
+- **Bind localhost only.** Never `0.0.0.0`. The health server exposes internal state and is not auth-gated.
+- **New scheduled jobs go through the same path as existing ones.** Add to `scheduler.py`'s job registration. Don't spawn ad-hoc background threads from service modules.
+- **Service code stays in `services/`.** The daemon module is for *scheduling and exposing* that work, not implementing it. If you find yourself writing business logic here, move it to a service.

package/memory-daemon/claudia_memory/extraction/README.md

@@ -0,0 +1,16 @@
+# extraction/
+
+Pulling structured signal out of free-form text. Used by the remember pipeline (to identify which entities a memory is about) and by the ingest flow (to extract entities, commitments, and dates from longer documents).
+
+## Where to look first
+
+| Concern | File | Notes |
+|---------|------|-------|
+| Named-entity recognition | `entity_extractor.py` | Detects people, organizations, projects, concepts. Uses spaCy when the optional `[nlp]` extra is installed; falls back to pattern-based heuristics otherwise. |
+| Date and time parsing | `temporal.py` | Resolves relative phrases (e.g., "next Thursday") to absolute dates in the user's timezone. Used by commitment detection and event extraction. |
+
+## Conventions
+
+- **spaCy is optional.** Anything in `extraction/` must work without it. Test the no-spaCy path. If you require it, gate behind a clear `ImportError` message that tells the user to install `claudia-memory[nlp]`.
+- **Return structured results, never raw text.** Extractors emit typed dicts or dataclasses; the caller decides how to render them. This keeps the boundary clean and the call sites testable.
+- **Idempotent on re-extraction.** If a document is re-ingested, extractors must produce the same result. No hidden state.

package/memory-daemon/claudia_memory/mcp/README.md

@@ -0,0 +1,17 @@
+# mcp/
+
+The Model Context Protocol surface: how Claude Code talks to the memory daemon. Stdio transport, configured in the user's `.mcp.json` after install.
+
+## Where to look first
+
+| Concern | File | Notes |
+|---------|------|-------|
+| Tool registration | `server.py` | Single file defining all ~33 `memory_*` MCP tools. Each tool is a handler function paired with a JSONSchema-style parameter declaration. |
+
+## Conventions
+
+- **Tool names are a public API.** Never rename a `memory_*` tool. Users have skills and workflows that invoke them by name. Add new tools rather than renaming old ones.
+- **Tool docstrings are how Claude Code decides when to call.** Like skill descriptions, they need a clear verb, expected inputs, and example trigger phrases. Vague tool docs cause inconsistent invocation.
+- **Each tool is a thin wrapper.** The real work lives in `services/`. Handlers in `server.py` parse the MCP request, call into a service, format the response. No business logic here.
+- **Parameter aliases are supported for ergonomics.** `memory_about`, `memory_relate`, and `memory_recall` accept multiple parameter names (e.g., `entity` and `name`) so users can call them naturally. See PR #57 for the canonical example.
+- **Errors should be actionable.** When a handler raises, the error message reaches the user verbatim. Say what went wrong and what to try, not just "failed."

package/memory-daemon/claudia_memory/services/README.md

@@ -0,0 +1,25 @@
+# services/
+
+Business logic for the memory daemon. One module per concern. Every MCP tool exposed by `mcp/server.py` ultimately calls into a function here.
+
+## Where to look first
+
+| Concern | File | Public entry points |
+|---------|------|--------------------|
+| Write a memory, entity, or relationship | `remember.py` | `remember_fact`, `remember_entity`, `relate_entities`, `invalidate_memory` |
+| Recall memories or find entities | `recall.py` | `recall`, `recall_about`, `search_entities`, `deep_recall` |
+| Background decay + dedup + pattern detection | `consolidate.py` | `run_full_consolidation`, decay/dedup helpers, prediction lifecycle |
+| Entity type inference and naming | `entities.py` | `infer_entity_type` |
+| Memory and input validation rules | `guards.py` | `validate_memory`, `validate_entity`, `validate_relationship` |
+| File storage for filed source material | `filestore.py`, `documents.py` | `LocalFileStore`, document filing pipeline |
+| Provenance and audit trail | `audit.py` | source links, correction history |
+| Bulk historical fixes | `backfill.py` | one-shot maintenance utilities |
+| Compact session summaries for greeting | `context_builder.py` | `build_briefing_context` and friends |
+| Multi-document intake pipeline | `ingest.py` | the Extract-Then-Aggregate flow |
+| Obsidian vault projection | `vault_sync.py`, `canvas_generator.py` | PARA-layout write of entities, MOC canvases |
+
+## Conventions
+
+- **Soft-delete columns differ by table.** `memories.invalidated_at` vs. `entities.deleted_at`. Always check the schema before writing recall queries that filter "active" rows.
+- **Embedding storage is JSON text** (via `json.dumps`), not binary `struct.pack` blobs. Match this when writing new embedding paths.
+- Functions exported from a service module are the unit of testability. Tests for `recall.py` live at `tests/test_recall*.py` and call the module's public functions directly. Don't add internal coupling that bypasses those entry points.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "get-claudia",
-  "version": "1.58.0",
+  "version": "1.59.1",
   "description": "An AI assistant who learns how you work.",
   "keywords": [
     "claudia",

package/template-v2/.claude/manifest.json

@@ -1,6 +1,6 @@
 {
-  "version": "1.58.0",
-  "generated": "2026-05-13T11:19:49.402Z",
+  "version": "1.59.1",
+  "generated": "2026-05-15T13:14:19.001Z",
   "algorithm": "sha256",
   "files": {
     ".claude/rules/claudia-principles.md": "939e9720421628e7f2e4c8dfbaa4aeb9c1e18e8c6a5379cd6b772a6835b812e5",

package/memory-daemon/claudia_memory/services/metrics.py

@@ -1,312 +0,0 @@
-"""
-Metrics Service for Claudia Memory System
-
-Tracks system health and improvement over time.
-"""
-
-import json
-import logging
-from datetime import datetime, timedelta
-from typing import Any, Dict, List, Optional
-
-from ..database import get_db
-
-logger = logging.getLogger(__name__)
-
-
-class MetricsService:
-    """Track system health and quality metrics"""
-
-    def __init__(self):
-        self.db = get_db()
-
-    def record(
-        self,
-        name: str,
-        value: float,
-        dimensions: Optional[Dict[str, Any]] = None,
-    ) -> int:
-        """
-        Record a metric value.
-
-        Args:
-            name: Metric name (e.g., 'entity_count', 'memory_avg_importance')
-            value: Metric value
-            dimensions: Optional key-value pairs for filtering
-
-        Returns:
-            Metric entry ID
-        """
-        entry_id = self.db.insert(
-            "metrics",
-            {
-                "timestamp": datetime.utcnow().isoformat(),
-                "metric_name": name,
-                "metric_value": value,
-                "dimensions": json.dumps(dimensions) if dimensions else None,
-            },
-        )
-        logger.debug(f"Metric recorded: {name}={value}")
-        return entry_id
-
-    def collect_system_health(self) -> Dict[str, Any]:
-        """
-        Collect current system health metrics.
-
-        Returns a snapshot of entity counts, memory stats, reflection stats,
-        prediction engagement, and data quality indicators.
-
-        Returns:
-            Dict with current health metrics
-        """
-        health = {
-            "collected_at": datetime.utcnow().isoformat(),
-            "entities": {},
-            "memories": {},
-            "reflections": {},
-            "predictions": {},
-            "data_quality": {},
-        }
-
-        # Entity counts by type
-        try:
-            entity_rows = self.db.execute(
-                """
-                SELECT type, COUNT(*) as count
-                FROM entities
-                WHERE deleted_at IS NULL
-                GROUP BY type
-                """,
-                fetch=True,
-            ) or []
-            for row in entity_rows:
-                health["entities"][row["type"]] = row["count"]
-            health["entities"]["total"] = sum(health["entities"].values())
-        except Exception as e:
-            logger.debug(f"Could not collect entity metrics: {e}")
-
-        # Memory stats
-        try:
-            mem_row = self.db.execute(
-                """
-                SELECT
-                    COUNT(*) as total,
-                    AVG(importance) as avg_importance,
-                    COUNT(CASE WHEN invalidated_at IS NOT NULL THEN 1 END) as invalidated,
-                    COUNT(CASE WHEN corrected_at IS NOT NULL THEN 1 END) as corrected
-                FROM memories
-                """,
-                fetch=True,
-            )
-            if mem_row:
-                health["memories"] = {
-                    "total": mem_row[0]["total"],
-                    "avg_importance": round(mem_row[0]["avg_importance"] or 0, 3),
-                    "invalidated": mem_row[0]["invalidated"],
-                    "corrected": mem_row[0]["corrected"],
-                }
-
-            # Memory counts by type
-            mem_type_rows = self.db.execute(
-                """
-                SELECT type, COUNT(*) as count
-                FROM memories
-                WHERE invalidated_at IS NULL
-                GROUP BY type
-                """,
-                fetch=True,
-            ) or []
-            health["memories"]["by_type"] = {row["type"]: row["count"] for row in mem_type_rows}
-        except Exception as e:
-            logger.debug(f"Could not collect memory metrics: {e}")
-
-        # Reflection stats
-        try:
-            ref_row = self.db.execute(
-                """
-                SELECT
-                    COUNT(*) as total,
-                    AVG(importance) as avg_importance,
-                    AVG(aggregation_count) as avg_confirmations
-                FROM reflections
-                """,
-                fetch=True,
-            )
-            if ref_row:
-                health["reflections"] = {
-                    "total": ref_row[0]["total"],
-                    "avg_importance": round(ref_row[0]["avg_importance"] or 0, 3),
-                    "avg_confirmations": round(ref_row[0]["avg_confirmations"] or 0, 1),
-                }
-
-            # By type
-            ref_type_rows = self.db.execute(
-                """
-                SELECT reflection_type, COUNT(*) as count
-                FROM reflections
-                GROUP BY reflection_type
-                """,
-                fetch=True,
-            ) or []
-            health["reflections"]["by_type"] = {row["reflection_type"]: row["count"] for row in ref_type_rows}
-        except Exception as e:
-            logger.debug(f"Could not collect reflection metrics: {e}")
-
-        # Prediction engagement rate
-        try:
-            pred_row = self.db.execute(
-                """
-                SELECT
-                    COUNT(*) as total,
-                    COUNT(CASE WHEN is_shown = 1 THEN 1 END) as shown,
-                    COUNT(CASE WHEN is_acted_on = 1 THEN 1 END) as acted_on
-                FROM predictions
-                """,
-                fetch=True,
-            )
-            if pred_row:
-                total = pred_row[0]["total"]
-                shown = pred_row[0]["shown"]
-                acted = pred_row[0]["acted_on"]
-                health["predictions"] = {
-                    "total": total,
-                    "shown": shown,
-                    "acted_on": acted,
-                    "engagement_rate": round(acted / shown, 3) if shown > 0 else 0,
-                }
-        except Exception as e:
-            logger.debug(f"Could not collect prediction metrics: {e}")
-
-        # Data quality indicators
-        try:
-            # Potential duplicates count (using name similarity > 0.85)
-            # This is expensive so we just count entities without the full comparison
-            entity_count = health["entities"].get("total", 0)
-
-            # Orphan memories (no entity links)
-            orphan_row = self.db.execute(
-                """
-                SELECT COUNT(*) as count
-                FROM memories m
-                WHERE NOT EXISTS (
-                    SELECT 1 FROM memory_entities me WHERE me.memory_id = m.id
-                )
-                AND m.invalidated_at IS NULL
-                """,
-                fetch=True,
-            )
-            orphan_count = orphan_row[0]["count"] if orphan_row else 0
-
-            # Stale entities (no activity in 90 days)
-            stale_cutoff = (datetime.utcnow() - timedelta(days=90)).isoformat()
-            stale_row = self.db.execute(
-                """
-                SELECT COUNT(*) as count
-                FROM entities
-                WHERE updated_at < ? AND deleted_at IS NULL
-                """,
-                (stale_cutoff,),
-                fetch=True,
-            )
-            stale_count = stale_row[0]["count"] if stale_row else 0
-
-            health["data_quality"] = {
-                "orphan_memories": orphan_count,
-                "stale_entities": stale_count,
-                "entities_needing_review": stale_count,
-            }
-        except Exception as e:
-            logger.debug(f"Could not collect data quality metrics: {e}")
-
-        return health
-
-    def get_trend(
-        self,
-        metric_name: str,
-        days: int = 30,
-    ) -> List[Dict[str, Any]]:
-        """
-        Get metric values over time.
-
-        Args:
-            metric_name: Name of the metric
-            days: Number of days to look back
-
-        Returns:
-            List of {timestamp, value} ordered by time
-        """
-        cutoff = (datetime.utcnow() - timedelta(days=days)).isoformat()
-        rows = self.db.execute(
-            """
-            SELECT timestamp, metric_value, dimensions
-            FROM metrics
-            WHERE metric_name = ? AND timestamp > ?
-            ORDER BY timestamp ASC
-            """,
-            (metric_name, cutoff),
-            fetch=True,
-        ) or []
-        return [
-            {
-                "timestamp": row["timestamp"],
-                "value": row["metric_value"],
-                "dimensions": json.loads(row["dimensions"]) if row["dimensions"] else None,
-            }
-            for row in rows
-        ]
-
-    def collect_and_store(self) -> Dict[str, Any]:
-        """
-        Collect health metrics and store them.
-
-        Called by scheduler for daily metrics collection.
-
-        Returns:
-            The collected health metrics
-        """
-        health = self.collect_system_health()
-
-        # Store key metrics for trend tracking
-        self.record("entities_total", health["entities"].get("total", 0))
-        self.record("memories_total", health["memories"].get("total", 0))
-        self.record("memories_avg_importance", health["memories"].get("avg_importance", 0))
-        self.record("reflections_total", health["reflections"].get("total", 0))
-        self.record("predictions_engagement_rate", health["predictions"].get("engagement_rate", 0))
-        self.record("orphan_memories", health["data_quality"].get("orphan_memories", 0))
-        self.record("stale_entities", health["data_quality"].get("stale_entities", 0))
-
-        logger.info("Daily metrics collected and stored")
-        return health
-
-
-# Global service instance
-_service: Optional[MetricsService] = None
-
-
-def get_metrics_service() -> MetricsService:
-    """Get or create the global metrics service"""
-    global _service
-    if _service is None:
-        _service = MetricsService()
-    return _service
-
-
-# Convenience functions
-def record_metric(name: str, value: float, **kwargs) -> int:
-    """Record a metric value"""
-    return get_metrics_service().record(name, value, **kwargs)
-
-
-def get_system_health() -> Dict[str, Any]:
-    """Collect current system health metrics"""
-    return get_metrics_service().collect_system_health()
-
-
-def get_metric_trend(metric_name: str, days: int = 30) -> List[Dict[str, Any]]:
-    """Get metric values over time"""
-    return get_metrics_service().get_trend(metric_name, days)
-
-
-def collect_daily_metrics() -> Dict[str, Any]:
-    """Collect and store daily metrics"""
-    return get_metrics_service().collect_and_store()

package/memory-daemon/claudia_memory/services/verify.py

@@ -1,279 +0,0 @@
-"""
-Background Verification Service for Claudia Memory System
-
-Async background verification of recently stored memories.
-Never blocks conversation. Runs on a schedule via the daemon scheduler.
-
-Verification cascade (cheapest to most expensive):
-1. Commitment deadline check (deterministic, reuses guards)
-2. Entity duplicate check (deterministic, reuses guards)
-3. Fact contradiction check (LLM, only if available)
-4. Commitment completeness check (LLM, only if available)
-"""
-
-import json
-import logging
-from datetime import datetime
-from typing import Any, Dict, List, Optional
-
-from ..config import get_config
-from ..database import get_db
-from .guards import DEADLINE_PATTERNS, validate_entity
-
-logger = logging.getLogger(__name__)
-
-
-class VerifyService:
-    """Background memory verification"""
-
-    _instance: Optional["VerifyService"] = None
-
-    def __init__(self):
-        self.db = get_db()
-        self.config = get_config()
-
-    @classmethod
-    def get_instance(cls) -> "VerifyService":
-        """Singleton accessor"""
-        if cls._instance is None:
-            cls._instance = cls()
-        return cls._instance
-
-    def run_verification(self) -> Dict[str, Any]:
-        """
-        Verify recently stored memories that have passed the 5-minute buffer.
-
-        Returns:
-            Dict with verification stats
-        """
-        batch_size = self.config.verify_batch_size
-
-        # Query pending memories older than 5 minutes (buffer prevents mid-session verification)
-        # Use REPLACE to normalize T-separator from Python's isoformat() for comparison
-        pending = self.db.execute(
-            """
-            SELECT id, content, type, importance, metadata
-            FROM memories
-            WHERE verification_status = 'pending'
-              AND julianday(REPLACE(created_at, 'T', ' ')) < julianday('now', '-5 minutes')
-            ORDER BY created_at ASC
-            LIMIT ?
-            """,
-            (batch_size,),
-            fetch=True,
-        ) or []
-
-        if not pending:
-            return {"verified": 0, "flagged": 0, "contradicts": 0, "skipped": 0}
-
-        stats = {"verified": 0, "flagged": 0, "contradicts": 0, "skipped": 0}
-
-        for memory in pending:
-            try:
-                result = self._verify_single(memory)
-                self._apply_result(memory["id"], result)
-                stats[result["status"]] = stats.get(result["status"], 0) + 1
-            except Exception as e:
-                logger.warning(f"Verification failed for memory {memory['id']}: {e}")
-                stats["skipped"] += 1
-
-        logger.info(f"Verification batch complete: {stats}")
-        return stats
-
-    def _verify_single(self, memory: dict) -> Dict[str, Any]:
-        """
-        Run verification cascade on a single memory.
-
-        Returns:
-            Dict with status ('verified', 'flagged', 'contradicts') and reasons
-        """
-        reasons = []
-        memory_type = memory["type"]
-        content = memory["content"]
-        memory_id = memory["id"]
-
-        # Check 1: Commitment deadline (deterministic)
-        if memory_type == "commitment":
-            has_deadline = any(p.search(content) for p in DEADLINE_PATTERNS)
-            if not has_deadline:
-                reasons.append("Commitment has no detected deadline")
-
-        # Check 2: Entity duplicate (deterministic)
-        entity_links = self.db.execute(
-            """
-            SELECT e.name, e.canonical_name
-            FROM memory_entities me
-            JOIN entities e ON me.entity_id = e.id
-            WHERE me.memory_id = ?
-            """,
-            (memory_id,),
-            fetch=True,
-        ) or []
-
-        if entity_links:
-            all_canonical = [
-                row["canonical_name"]
-                for row in self.db.query("entities", columns=["canonical_name"])
-            ]
-            for linked in entity_links:
-                result = validate_entity(
-                    linked["name"],
-                    entity_type="person",
-                    existing_canonical_names=[
-                        n for n in all_canonical if n != linked["canonical_name"]
-                    ],
-                )
-                for w in result.warnings:
-                    if "near-duplicate" in w.lower():
-                        reasons.append(w)
-
-        # Check 3: Fact contradiction (LLM, only if available)
-        if memory_type == "fact" and self._has_language_model():
-            contradiction = self._check_fact_contradiction(memory_id, content, entity_links)
-            if contradiction:
-                return {"status": "contradicts", "reasons": [contradiction]}
-
-        # Check 4: Commitment completeness (LLM, only if available)
-        if memory_type == "commitment" and self._has_language_model():
-            completeness = self._check_commitment_completeness(content)
-            if completeness:
-                reasons.append(completeness)
-
-        # Determine final status
-        if reasons:
-            return {"status": "flagged", "reasons": reasons}
-        return {"status": "verified", "reasons": []}
-
-    def _apply_result(self, memory_id: int, result: Dict[str, Any]) -> None:
-        """Apply verification result to the database"""
-        status = result["status"]
-        update_data = {
-            "verification_status": status,
-            "verified_at": datetime.utcnow().isoformat(),
-        }
-
-        # Flagged/contradicting memories get importance reduced
-        if status in ("flagged", "contradicts"):
-            update_data["importance"] = 0.1
-
-        # Store reasons in metadata
-        if result.get("reasons"):
-            memory = self.db.get_one("memories", where="id = ?", where_params=(memory_id,))
-            if memory:
-                meta = json.loads(memory["metadata"] or "{}")
-                meta["verification_reasons"] = result["reasons"]
-                update_data["metadata"] = json.dumps(meta)
-
-        self.db.update("memories", update_data, "id = ?", (memory_id,))
-
-    def _has_language_model(self) -> bool:
-        """Check if a language model is configured"""
-        return bool(self.config.language_model)
-
-    def _check_fact_contradiction(
-        self, memory_id: int, content: str, entity_links: list
-    ) -> Optional[str]:
-        """
-        Check if a new fact contradicts existing verified facts about the same entities.
-        Uses LLM to assess contradiction.
-
-        Returns:
-            Contradiction description or None
-        """
-        if not entity_links:
-            return None
-
-        try:
-            from ..language_model import get_language_model_service
-
-            lm = get_language_model_service()
-            if not lm.is_available():
-                return None
-
-            # Get existing verified facts about the same entities
-            entity_ids = []
-            for link in entity_links:
-                entity = self.db.get_one(
-                    "entities",
-                    where="canonical_name = ?",
-                    where_params=(link["canonical_name"],),
-                )
-                if entity:
-                    entity_ids.append(entity["id"])
-
-            if not entity_ids:
-                return None
-
-            placeholders = ", ".join(["?" for _ in entity_ids])
-            existing_facts = self.db.execute(
-                f"""
-                SELECT DISTINCT m.content
-                FROM memories m
-                JOIN memory_entities me ON m.id = me.memory_id
-                WHERE me.entity_id IN ({placeholders})
-                  AND m.type = 'fact'
-                  AND m.verification_status = 'verified'
-                  AND m.id != ?
-                  AND m.importance > 0.1
-                ORDER BY m.importance DESC
-                LIMIT 10
-                """,
-                tuple(entity_ids) + (memory_id,),
-                fetch=True,
-            ) or []
-
-            if not existing_facts:
-                return None
-
-            facts_text = "\n".join(f"- {f['content']}" for f in existing_facts)
-            prompt = (
-                f"Existing verified facts:\n{facts_text}\n\n"
-                f"New fact: {content}\n\n"
-                f"Does the new fact directly contradict any existing fact? "
-                f"Answer ONLY 'no' or describe the specific contradiction in one sentence."
-            )
-
-            response = lm.generate_sync(prompt)
-            if response and response.strip().lower() != "no":
-                return f"Potential contradiction: {response.strip()[:200]}"
-
-        except Exception as e:
-            logger.debug(f"Fact contradiction check failed: {e}")
-
-        return None
-
-    def _check_commitment_completeness(self, content: str) -> Optional[str]:
-        """
-        Check if a commitment has a clear owner and deadline using LLM.
-
-        Returns:
-            Incompleteness description or None
-        """
-        try:
-            from ..language_model import get_language_model_service
-
-            lm = get_language_model_service()
-            if not lm.is_available():
-                return None
-
-            prompt = (
-                f"Commitment: {content}\n\n"
-                f"Does this commitment have a clear owner (who is responsible) "
-                f"and a clear deadline (when it should be done)? "
-                f"Answer ONLY 'yes' or describe what is missing in one sentence."
-            )
-
-            response = lm.generate_sync(prompt)
-            if response and response.strip().lower() != "yes":
-                return f"Incomplete commitment: {response.strip()[:200]}"
-
-        except Exception as e:
-            logger.debug(f"Commitment completeness check failed: {e}")
-
-        return None
-
-
-# Convenience function
-def run_verification() -> Dict[str, Any]:
-    """Run background verification"""
-    return VerifyService.get_instance().run_verification()