get-claudia 1.64.0 → 1.66.0

package/memory-daemon/claudia_memory/mcp/server.py

@@ -3249,6 +3249,185 @@ async def call_tool(name: str, arguments: Dict[str, Any]) -> CallToolResult:
         )
 
 
+def _top_commitments(db, n: int = 3) -> dict:
+    """Salience-ranked active commitments for the session briefing (Prop 12 P3).
+
+    'Active' excludes invalidated and archived rows (the #67 class): once the
+    resolver archives a commitment it must never reappear in the brief. Ranks by
+    deadline (soonest first, no-deadline last) then importance, and reports how
+    many were auto-archived in the last 7 days so the brief can disclose the
+    batch (Prop 12 locked decision 4).
+
+    Returns {"active_count": int, "top": [ {content, deadline_at, importance} ],
+             "recently_archived_count": int}.
+    """
+    from datetime import datetime, timedelta
+
+    active_where = (
+        "type = 'commitment' AND importance > 0.1 AND invalidated_at IS NULL "
+        "AND (lifecycle_tier IS NULL OR lifecycle_tier != 'archived')"
+    )
+
+    active_count = 0
+    top = []
+    recently_archived = 0
+
+    try:
+        count_row = db.execute(
+            f"SELECT COUNT(*) as cnt FROM memories WHERE {active_where}",
+            fetch=True,
+        )
+        active_count = count_row[0]["cnt"] if count_row else 0
+    except Exception as e:
+        logger.debug(f"Briefing active commitment count failed: {e}")
+
+    try:
+        rows = db.execute(
+            f"""
+            SELECT content, deadline_at, importance FROM memories
+            WHERE {active_where}
+            ORDER BY (deadline_at IS NULL), deadline_at ASC, importance DESC
+            LIMIT ?
+            """,
+            (n,),
+            fetch=True,
+        ) or []
+        top = [
+            {
+                "content": r["content"],
+                "deadline_at": r["deadline_at"],
+                "importance": r["importance"],
+            }
+            for r in rows
+        ]
+    except Exception as e:
+        logger.debug(f"Briefing top commitments failed: {e}")
+
+    try:
+        cutoff = (datetime.utcnow() - timedelta(days=7)).isoformat()
+        arch_row = db.execute(
+            """
+            SELECT COUNT(*) as cnt FROM memories
+            WHERE type = 'commitment'
+              AND json_valid(metadata)
+              AND json_extract(metadata, '$.resolution') IS NOT NULL
+              AND json_extract(metadata, '$.resolved_at') >= ?
+            """,
+            (cutoff,),
+            fetch=True,
+        )
+        recently_archived = arch_row[0]["cnt"] if arch_row else 0
+    except Exception as e:
+        logger.debug(f"Briefing recent auto-archive count failed: {e}")
+
+    return {
+        "active_count": active_count,
+        "top": top,
+        "recently_archived_count": recently_archived,
+    }
+
+
+def _render_commitment_lines(commitments: dict) -> list:
+    """Render the ranked commitment section for the briefing (Prop 12 D6).
+
+    A top-3 bulleted list (soonest deadline first), then one demoted summary line
+    disclosing how many more are active and how many were auto-archived recently
+    with a hint to restore (locked decision 4). Never a bare "N active" count.
+    """
+    lines = []
+    top = commitments.get("top", [])
+    active_count = commitments.get("active_count", 0)
+    recently_archived = commitments.get("recently_archived_count", 0)
+
+    if not top:
+        # No active items; still disclose a recent auto-archive batch if any.
+        if recently_archived > 0:
+            lines.append(
+                f'**Commitments:** none active ({recently_archived} auto-archived '
+                f'recently, say "restore" to correct)'
+            )
+        return lines
+
+    lines.append("**Commitments:**")
+    for c in top:
+        snippet = (c.get("content") or "").strip()[:80]
+        deadline = c.get("deadline_at")
+        due = f"due {str(deadline)[:10]}" if deadline else "no deadline"
+        lines.append(f"- {snippet} ({due})")
+
+    summary_bits = []
+    more = active_count - len(top)
+    if more > 0:
+        summary_bits.append(f"+{more} more active")
+    if recently_archived > 0:
+        summary_bits.append(
+            f'{recently_archived} auto-archived recently, say "restore" to correct'
+        )
+    if summary_bits:
+        lines.append(f"({'; '.join(summary_bits)})")
+
+    return lines
+
+
+def _top_prediction(db, threshold: float):
+    """Return the single most salient un-shown prediction, or None if the top one
+    is below the surface threshold (Prop 12 P3 interruptibility gate).
+
+    Gates on `priority` (the predictions table's salience field). No surfaced-history
+    field beyond is_shown exists, so the gate is importance-only, no migration.
+    """
+    try:
+        rows = db.execute(
+            """
+            SELECT content, prediction_type, priority FROM predictions
+            WHERE expires_at > datetime('now') AND is_shown = 0
+            ORDER BY priority DESC
+            LIMIT 1
+            """,
+            fetch=True,
+        )
+        if not rows:
+            return None
+        row = rows[0]
+        if row["priority"] is None or row["priority"] < threshold:
+            return None
+        return {
+            "content": row["content"],
+            "prediction_type": row["prediction_type"],
+            "priority": row["priority"],
+        }
+    except Exception as e:
+        logger.debug(f"Briefing top prediction failed: {e}")
+        return None
+
+
+def _embeddings_available() -> bool:
+    """Whether local embedding intelligence (Ollama) is up.
+
+    Delegates to the embedding service's is_available_sync(), which returns
+    instantly once availability is known. The SessionStart health check calls
+    the same method before the briefing is built, so it is warm in the normal
+    flow and never blocks here. Fails open on error so a transient hiccup never
+    cries wolf.
+    """
+    try:
+        return bool(get_embedding_service().is_available_sync())
+    except Exception as e:
+        logger.debug(f"Embedding availability check failed: {e}")
+        return True
+
+
+def _memory_degraded_line(available: bool):
+    """The honest degradation disclosure (Prop 12). Returned as the briefing's
+    first line when local memory intelligence is down; None when healthy."""
+    if available:
+        return None
+    return (
+        "⚠️ Memory intelligence degraded: Ollama unreachable. "
+        "Recall works; semantic extraction and ambient capture are paused."
+    )
+
+
 def _build_briefing() -> str:
     """
     Build a compact session briefing (~500 tokens).
@@ -3331,25 +3510,11 @@ def _build_briefing() -> str:
     except Exception as e:
         logger.debug(f"Briefing consolidation check failed: {e}")
 
-    # 1. Active commitments count + stale count
+    # 1. Active commitments: salience-ranked top-3 + honest summary (Prop 12 P3).
+    #    Active excludes archived (resolver output) and invalidated rows (#67 class).
     try:
-        total_row = db.execute(
-            "SELECT COUNT(*) as cnt FROM memories WHERE type = 'commitment' AND importance > 0.1 AND invalidated_at IS NULL",
-            fetch=True,
-        )
-        total_commitments = total_row[0]["cnt"] if total_row else 0
-
-        stale_cutoff = (datetime.utcnow() - timedelta(days=7)).isoformat()
-        stale_row = db.execute(
-            "SELECT COUNT(*) as cnt FROM memories WHERE type = 'commitment' AND importance > 0.1 AND invalidated_at IS NULL AND created_at < ?",
-            (stale_cutoff,),
-            fetch=True,
-        )
-        stale_commitments = stale_row[0]["cnt"] if stale_row else 0
-
-        if total_commitments > 0:
-            stale_note = f" ({stale_commitments} older than 7d)" if stale_commitments else ""
-            lines.append(f"**Commitments:** {total_commitments} active{stale_note}")
+        commitments = _top_commitments(db, n=3)
+        lines.extend(_render_commitment_lines(commitments))
     except Exception as e:
         logger.debug(f"Briefing commitments failed: {e}")
 
@@ -3384,19 +3549,12 @@ def _build_briefing() -> str:
     except Exception as e:
         logger.debug(f"Briefing unread failed: {e}")
 
-    # 4. Top prediction (1 line)
+    # 4. Top prediction (1 line), gated by importance (Prop 12 P3 interruptibility)
     try:
-        pred_row = db.execute(
-            """
-            SELECT content, prediction_type FROM predictions
-            WHERE expires_at > datetime('now') AND is_shown = 0
-            ORDER BY priority DESC
-            LIMIT 1
-            """,
-            fetch=True,
-        )
-        if pred_row:
-            p = pred_row[0]
+        from ..config import get_config as _get_config
+        threshold = _get_config().prediction_surface_threshold
+        p = _top_prediction(db, threshold)
+        if p:
             lines.append(f"**Top prediction:** [{p['prediction_type']}] {p['content'][:100]}")
     except Exception as e:
         logger.debug(f"Briefing prediction failed: {e}")
@@ -3461,6 +3619,15 @@ def _build_briefing() -> str:
     if len(lines) <= 1:
         lines.append("No context available yet. This appears to be a fresh workspace.")
 
+    # Honest degradation disclosure goes first (Prop 12). Prepend last so it does
+    # not affect the fresh-workspace check above.
+    try:
+        degraded = _memory_degraded_line(_embeddings_available())
+        if degraded:
+            lines.insert(0, degraded)
+    except Exception as e:
+        logger.debug(f"Briefing degradation disclosure failed: {e}")
+
     return "\n".join(lines)
 
 

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

@@ -0,0 +1,267 @@
+"""
+AUDN write helper for P1 ambient memory.
+
+Before inserting an extracted fact, semantic-search top-k similar existing
+memories and use the local LLM to choose: Add / Update / No-op.
+Conservative: only Update on high confidence; otherwise Add with
+verification_status='pending' (stored in metadata).
+
+Delete is intentionally excluded from P1 (too risky without supervision).
+"""
+
+import json
+import logging
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+_AUDN_DECISION_PROMPT = """/no_think
+You are deciding whether a new extracted fact duplicates or contradicts an existing memory.
+
+New fact:
+{new_fact}
+
+Top similar existing memories:
+{existing}
+
+Return JSON with this exact schema:
+{{"action": "add"|"update"|"noop", "target_id": null|integer, "reason": "string"}}
+
+Rules:
+- Use "update" ONLY when confidence > 0.85 that the new fact supersedes an existing one.
+- Use "noop" ONLY when confidence > 0.85 that the new fact is already captured.
+- Use "add" in all other cases (default to adding; false negatives are recoverable).
+- "target_id" must be the integer id of the memory to update, or null for add/noop.
+- Return ONLY valid JSON. No markdown, no explanation.
+"""
+
+
+async def audn_write(
+    content: str,
+    memory_type: str,
+    about_entities: Optional[List[str]],
+    importance: float,
+    source: str,
+    source_id: str,
+    db,
+    llm_service,
+) -> Optional[int]:
+    """Add/Update/No-op a fact using semantic dedup before inserting.
+
+    Args:
+        content: Fact text to store
+        memory_type: 'fact', 'commitment', 'decision', etc.
+        about_entities: List of entity names this fact is about
+        importance: Importance score (0.0-1.0)
+        source: Source label (e.g. 'session_transcript')
+        source_id: Reference ID (e.g. session_id)
+        db: Database instance
+        llm_service: Language model service (may be unavailable)
+
+    Returns:
+        Memory ID if stored/updated, None if noop or error
+    """
+    try:
+        return await _audn_write_inner(
+            content, memory_type, about_entities, importance, source, source_id, db, llm_service
+        )
+    except Exception as e:
+        logger.debug(f"AUDN write error, falling back to plain add: {e}")
+        return _plain_add(content, memory_type, about_entities, importance, source, source_id)
+
+
+async def _audn_write_inner(
+    content: str,
+    memory_type: str,
+    about_entities: Optional[List[str]],
+    importance: float,
+    source: str,
+    source_id: str,
+    db,
+    llm_service,
+) -> Optional[int]:
+    """Inner implementation with structured error propagation."""
+    # Step 1: Semantic search for similar memories
+    similar: List[Dict[str, Any]] = []
+    try:
+        from .recall import RecallService
+        from ..database import get_db as _get_db
+
+        # Use a fresh RecallService with the provided db if possible
+        recall_svc = RecallService.__new__(RecallService)
+        recall_svc.db = db
+        from ..embeddings import get_embedding_service
+        recall_svc.embedding_service = get_embedding_service()
+        from ..extraction.entity_extractor import get_extractor
+        recall_svc.extractor = get_extractor()
+        from ..config import get_config
+        recall_svc.config = get_config()
+
+        results = recall_svc.recall(content, limit=3, min_importance=0.0)
+        similar = [
+            {"id": r.id, "content": r.content, "type": r.type}
+            for r in results
+        ]
+    except Exception as e:
+        logger.debug(f"AUDN: recall failed, adding without dedup: {e}")
+        # No recall = safe to add without dedup
+        return _plain_add(content, memory_type, about_entities, importance, source, source_id)
+
+    # Step 2: If no similar memories found, add directly
+    if not similar:
+        return _plain_add(content, memory_type, about_entities, importance, source, source_id)
+
+    # Step 3: Ask LLM to decide
+    action = "add"
+    target_id = None
+
+    try:
+        if llm_service is not None and await llm_service.is_available():
+            existing_text = "\n".join(
+                f"[id={m['id']}] ({m['type']}) {m['content']}"
+                for m in similar
+            )
+            prompt = _AUDN_DECISION_PROMPT.format(
+                new_fact=content,
+                existing=existing_text,
+            )
+            raw = await llm_service.generate(
+                prompt=content,
+                system=prompt,
+                temperature=0.0,
+                format_json=True,
+            )
+            if raw:
+                parsed = _parse_decision(raw)
+                if parsed:
+                    action = parsed.get("action", "add")
+                    target_id = parsed.get("target_id")
+    except Exception as e:
+        logger.debug(f"AUDN: LLM decision failed, defaulting to add: {e}")
+        action = "add"
+        target_id = None
+
+    # Step 4: Execute decision (validates target_id against the candidate set).
+    return _apply_decision(
+        action, target_id, similar, content, memory_type,
+        about_entities, importance, source, source_id, db,
+    )
+
+
+def _apply_decision(
+    action: str,
+    target_id,
+    similar: List[Dict[str, Any]],
+    content: str,
+    memory_type: str,
+    about_entities: Optional[List[str]],
+    importance: float,
+    source: str,
+    source_id: str,
+    db,
+) -> Optional[int]:
+    """Execute an AUDN decision.
+
+    Safety: an "update" is only honored when target_id is one of the candidate
+    memories that were actually shown to the model. A hallucinated or out-of-set
+    id can never overwrite an unrelated memory; it falls through to a safe add.
+    The superseded content is preserved in metadata.corrected_from for provenance
+    (Trust North Star).
+    """
+    similar_ids = {m.get("id") for m in similar}
+
+    if action == "noop":
+        logger.debug(f"AUDN: noop for fact: {content[:60]}")
+        return None
+
+    if action == "update":
+        if target_id is None or int(target_id) not in similar_ids:
+            logger.debug(
+                f"AUDN: rejected update to non-candidate id {target_id}; adding instead"
+            )
+        else:
+            try:
+                now = datetime.utcnow().isoformat()
+                # Preserve the superseded content for provenance before overwriting.
+                existing = db.execute(
+                    "SELECT content, metadata FROM memories WHERE id = ?",
+                    (int(target_id),),
+                    fetch=True,
+                )
+                meta = {}
+                if existing:
+                    try:
+                        meta = json.loads(existing[0]["metadata"] or "{}")
+                    except (json.JSONDecodeError, TypeError):
+                        meta = {}
+                    meta["corrected_from"] = existing[0]["content"]
+                db.update(
+                    "memories",
+                    {"content": content, "updated_at": now, "metadata": json.dumps(meta)},
+                    "id = ?",
+                    (int(target_id),),
+                )
+                logger.debug(f"AUDN: updated memory {target_id}: {content[:60]}")
+                return int(target_id)
+            except Exception as e:
+                logger.debug(f"AUDN: update failed, falling back to add: {e}")
+
+    # Default: add
+    return _plain_add(content, memory_type, about_entities, importance, source, source_id)
+
+
+def _plain_add(
+    content: str,
+    memory_type: str,
+    about_entities: Optional[List[str]],
+    importance: float,
+    source: str,
+    source_id: str,
+) -> Optional[int]:
+    """Add a fact without dedup, with verification_status=pending in metadata."""
+    try:
+        from .remember import get_remember_service
+        svc = get_remember_service()
+        return svc.remember_fact(
+            content=content,
+            memory_type=memory_type,
+            about_entities=about_entities,
+            importance=importance,
+            source=source,
+            source_id=source_id,
+            origin_type="extracted",
+            metadata={"verification_status": "pending"},
+        )
+    except Exception as e:
+        logger.debug(f"AUDN: plain_add failed: {e}")
+        return None
+
+
+def _parse_decision(text: str) -> Optional[Dict]:
+    """Parse LLM decision JSON, handling common quirks."""
+    text = text.strip()
+    try:
+        return json.loads(text)
+    except json.JSONDecodeError:
+        pass
+
+    # Strip markdown fences
+    if text.startswith("```"):
+        lines = [l for l in text.split("\n") if not l.strip().startswith("```")]
+        text = "\n".join(lines).strip()
+        try:
+            return json.loads(text)
+        except json.JSONDecodeError:
+            pass
+
+    # Find first {...}
+    start = text.find("{")
+    end = text.rfind("}")
+    if start != -1 and end != -1 and end > start:
+        try:
+            return json.loads(text[start:end + 1])
+        except json.JSONDecodeError:
+            pass
+
+    return None

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

@@ -2707,6 +2707,94 @@ class ConsolidateService:
 
         return {"cooled": cooled, "archived": archived}
 
+    def resolve_commitments(self) -> dict:
+        """Archive commitments that expired or went stale. Never delete (Prop 12 D5).
+
+        expired: deadline passed more than the grace window ago and not recently
+                 accessed (a recent access means it is still live in conversation).
+        stale:   no deadline, old, unreferenced, and low importance.
+
+        Sacred and invalidated rows are never touched. metadata.resolution records
+        why and metadata.resolved_at records when, so the briefing can disclose the
+        batch and the user can correct it (restore lifecycle_tier='active').
+
+        Counts use SELECT changes() (like _surge_approaching_deadlines): this db.execute
+        wrapper returns None, so the cursor.rowcount idiom would always report 0.
+        """
+        config = self.config
+        if not getattr(config, "commitment_resolver_enabled", True):
+            return {"expired": 0, "stale": 0}
+
+        now = datetime.utcnow()
+        now_iso = now.isoformat()
+        grace_cutoff = (now - timedelta(days=config.commitment_grace_days)).isoformat()
+        stale_cutoff = (now - timedelta(days=config.commitment_stale_days)).isoformat()
+        importance_ceiling = config.commitment_stale_importance_ceiling
+
+        # Expired: deadline passed the grace window, not recently accessed.
+        expired = 0
+        try:
+            with self.db.transaction():
+                self.db.execute(
+                    """
+                    UPDATE memories
+                    SET lifecycle_tier = 'archived',
+                        archived_at = ?,
+                        updated_at = ?,
+                        metadata = json_set(
+                            CASE WHEN json_valid(metadata) THEN metadata ELSE '{}' END,
+                            '$.resolution', 'expired',
+                            '$.resolved_at', ?
+                        )
+                    WHERE type = 'commitment'
+                      AND invalidated_at IS NULL
+                      AND (lifecycle_tier IS NULL OR lifecycle_tier NOT IN ('sacred', 'archived'))
+                      AND deadline_at IS NOT NULL
+                      AND deadline_at < ?
+                      AND (last_accessed_at IS NULL OR last_accessed_at < ?)
+                    """,
+                    (now_iso, now_iso, now_iso, grace_cutoff, grace_cutoff),
+                )
+                res = self.db.execute("SELECT changes()", fetch=True)
+                expired = res[0][0] if res else 0
+        except Exception as e:
+            logger.debug(f"Commitment expiry resolution error: {e}")
+
+        # Stale: no deadline, old, unreferenced, low importance.
+        stale = 0
+        try:
+            with self.db.transaction():
+                self.db.execute(
+                    """
+                    UPDATE memories
+                    SET lifecycle_tier = 'archived',
+                        archived_at = ?,
+                        updated_at = ?,
+                        metadata = json_set(
+                            CASE WHEN json_valid(metadata) THEN metadata ELSE '{}' END,
+                            '$.resolution', 'stale',
+                            '$.resolved_at', ?
+                        )
+                    WHERE type = 'commitment'
+                      AND invalidated_at IS NULL
+                      AND (lifecycle_tier IS NULL OR lifecycle_tier NOT IN ('sacred', 'archived'))
+                      AND deadline_at IS NULL
+                      AND created_at < ?
+                      AND (last_accessed_at IS NULL OR last_accessed_at < ?)
+                      AND importance < ?
+                    """,
+                    (now_iso, now_iso, now_iso, stale_cutoff, stale_cutoff, importance_ceiling),
+                )
+                res = self.db.execute("SELECT changes()", fetch=True)
+                stale = res[0][0] if res else 0
+        except Exception as e:
+            logger.debug(f"Commitment stale resolution error: {e}")
+
+        if expired > 0 or stale > 0:
+            logger.info(f"Commitment resolution: {expired} expired, {stale} stale (archived)")
+
+        return {"expired": expired, "stale": stale}
+
     def detect_auto_sacred(self) -> int:
         """Auto-promote memories about close-circle entities that match sacred keywords."""
         config = self.config
@@ -2840,6 +2928,13 @@ class ConsolidateService:
             logger.warning(f"Lifecycle phase failed: {e}")
             results["lifecycle"] = {"error": str(e)}
 
+        # Phase 1c: Commitment resolution (expired/stale auto-archive, Prop 12 P2)
+        try:
+            results["commitments"] = self.resolve_commitments()
+        except Exception as e:
+            logger.warning(f"Commitment resolution phase failed: {e}")
+            results["commitments"] = {"error": str(e)}
+
         # [4R: Reflect]
         # Phase 2: Merging (modifies memory content)
         try:

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

@@ -106,6 +106,26 @@ Return JSON with this exact schema:
   "topics": ["string"],
   "summary": "string"
 }
+""",
+
+    "session": _SYSTEM_BASE + """
+You are extracting structured data from a CLAUDE CODE CONVERSATION TRANSCRIPT.
+
+The transcript is a JSONL file where each line is a conversation turn.
+Focus on substantive content: decisions made, facts stated, commitments given,
+people and entities mentioned. SKIP: tool calls, file reads, generic chit-chat,
+meta-commentary about the AI's own process.
+
+Return JSON with this exact schema:
+{
+  "facts": [{"content": "string", "type": "string", "about": ["string"], "importance": number}],
+  "commitments": [{"content": "string", "who": "string or null", "deadline": "string or null", "importance": number}],
+  "decisions": [{"content": "string", "importance": number}],
+  "entities": [{"name": "string", "type": "string", "description": "string or null"}],
+  "relationships": [{"source": "string", "target": "string", "relationship": "string"}],
+  "key_topics": ["string"],
+  "summary": "string"
+}
 """,
 }
 

package/package.json

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