get-claudia 1.64.0 → 1.66.0

package/CHANGELOG.md

@@ -2,6 +2,41 @@
 
 All notable changes to Claudia will be documented in this file.
 
+## 1.66.0 (2026-07-09)
+
+### Added
+
+- **Commitment resolver: expired and stale auto-archive** (Proposal 12, P2). A new nightly `resolve_commitments()` phase inside `run_full_consolidation` (Phase 1c) retires commitments that have gone quiet: `expired` when a deadline passed more than the grace window ago and the item has not been touched since, `stale` when a deadline-less commitment is old, unreferenced, and low importance. It is archive-never-delete (Prop 12 D5): rows keep `lifecycle_tier='archived'` and stay fully queryable, with `metadata.resolution` and `metadata.resolved_at` recording why and when, so the briefing can disclose the batch and you can restore any of them by setting `lifecycle_tier='active'`. Sacred and invalidated commitments are never touched. Gentle, tunable thresholds via new config knobs (`commitment_grace_days=14`, `commitment_stale_days=60`, `commitment_stale_importance_ceiling=0.5`, `commitment_resolver_enabled=true`).
+- **Salience-ranked session briefing** (Proposal 12, P3). The briefing's commitment section no longer dumps a raw "N active" count. It shows the top 3 by soonest deadline then importance, each with its due date, followed by one honest summary line ("+N more active; M auto-archived recently, say 'restore' to correct") so an auto-archived batch is always disclosed (Prop 12 locked decision 4). The top proactive prediction is now gated by importance (new `prediction_surface_threshold=0.6` knob) so weak hunches stay quiet at session start.
+- **Honest memory-degradation disclosure** (Proposal 12, P3). When local embedding intelligence (Ollama) is unreachable, the briefing's first line says so plainly: recall still works, but semantic extraction and ambient capture are paused. The check is warm by the time the briefing runs (the SessionStart health check populates it first) and fails open, so it never blocks startup or false-alarms.
+- **Daemon self-heal at session start.** The SessionStart health-check hook now probes the memory daemon and, when it is down on macOS with a LaunchAgent present, attempts exactly one automatic restart (a launchd reload mirroring the installer), then re-probes: on recovery it says so, otherwise it injects concrete, stepwise fix guidance (`claudia system-health`, reinstall via `npx get-claudia .`, the Windows deps known issue, and the context-files fallback). A hook never becomes a process manager, so every non-macOS or no-plist path only advises. Fail-open and hard-bounded so it never blocks or crashes session start. So a fresh install (or a crashed daemon) surfaces the problem and often fixes itself instead of silently doing nothing.
+
+### Fixed
+
+- **Briefing counted archived and invalidated commitments** (issue #67 class). The commitment count filtered only `invalidated_at IS NULL`, so once the new resolver archived a commitment it would still inflate the "active" number. The briefing now routes through a single `_top_commitments` helper whose active filter excludes both archived and invalidated rows.
+
+### Changed
+
+- **`auto-research` worked example** (Proposal 11, E2/B4). The skill now includes a short dry-run transcript: a board-update iteration showing baseline scoring, keep/revert decisions, a `contested` iteration where Claudia self-scores 9.5 but the independent Checker holds it to 8.4, the resulting `research_status.md`, and the hand-off. This closes the last open sub-tranche of Proposal 11.
+- **Retroactive credit: automated memory lifecycle transitions.** The active to cooling to archived lifecycle transitions (`run_lifecycle_transitions`, Phase 1b of nightly consolidation) shipped in v1.65.0 inside `run_full_consolidation` but were not listed in that release's changelog entry. Noting it here for the record; Proposal 12 P2 (the commitment resolver above) builds directly on that machinery.
+
+### Stats
+
+- 34 new tests (12 commitment resolver, 11 briefing salience/degradation, 11 daemon self-heal). Daemon suite 851 passed, 12 skipped; hooks suite 57 passed, 29 subtests. 0 regressions.
+- No schema migration. One template hook changed (`session-health-check.py`, daemon self-heal), added per the release requirement.
+
+## 1.65.0 (2026-06-15)
+
+### Added
+
+- **Ambient session memory capture** (Proposal 12, P1). Claudia now forms memories from the conversation itself, without anyone having to invoke a memory tool. A `SessionStart` disk-scan (crash-proof) and a `SessionEnd` fast-path enqueue finished sessions to `~/.claudia/sessions_pending.jsonl`; a new daemon `process_sessions` job parses the transcript, extracts facts, commitments, and decisions via the local Ollama ingest service, and writes them through an AUDN (add/update/no-op) pass that dedupes against existing memories. The daemon is the sole writer and the hooks never touch SQLite, so it cannot reintroduce the WAL-contention class. The AUDN update validates the target id against the candidate set (a hallucinated id can never overwrite an unrelated memory) and preserves superseded content in `metadata.corrected_from`. New files: `memory-daemon/claudia_memory/services/audn.py`, `template-v2/.claude/hooks/session-enqueue.py`. Defaults on; set `session_capture_enabled` to false to disable.
+- **Session-start "update available" notice.** When a newer `get-claudia` has shipped, Claudia surfaces it at session start (for example, "Update available: Claudia v1.66.0, run claudia update"). The check is cached for 24 hours, timeout-bounded, and fail-open, so it never slows or blocks startup. This covers the gap where the launcher only update-checks when you run the installer, not when you start a session.
+
+### Stats
+
+- 30 new tests; full daemon suite 828 passed, hooks 46 passed, 0 regressions.
+- Install: `npx get-claudia`
+
 ## 1.64.0 (2026-06-13)
 
 ### Added

package/memory-daemon/claudia_memory/config.py

@@ -104,6 +104,15 @@ class MemoryConfig:
     # Lifecycle & Sacred memory settings
     cooling_threshold_days: int = 60        # Days without access before memory enters 'cooling'
     archive_threshold_days: int = 180       # Days in cooling + low importance before archiving
+
+    # Commitment resolution (Proposal 12 P2): gentle, reversible auto-archive
+    commitment_resolver_enabled: bool = True         # Toggle the nightly commitment resolver
+    commitment_grace_days: int = 14                  # Grace after a deadline passes before it counts as expired
+    commitment_stale_days: int = 60                  # Age (no deadline) + unreferenced before a commitment goes stale
+    commitment_stale_importance_ceiling: float = 0.5 # Only stale-archive commitments below this importance
+
+    # Proactive surfacing (Proposal 12 P3)
+    prediction_surface_threshold: float = 0.6        # Min prediction priority before it surfaces in the brief
     enable_auto_sacred: bool = True         # Auto-detect sacred facts for close-circle entities
     close_circle_keywords: list = field(default_factory=lambda: [
         "close friend", "bestie", "family", "inner circle", "best friend",
@@ -230,6 +239,16 @@ class MemoryConfig:
                     config.cooling_threshold_days = data["cooling_threshold_days"]
                 if "archive_threshold_days" in data:
                     config.archive_threshold_days = data["archive_threshold_days"]
+                if "commitment_resolver_enabled" in data:
+                    config.commitment_resolver_enabled = data["commitment_resolver_enabled"]
+                if "commitment_grace_days" in data:
+                    config.commitment_grace_days = data["commitment_grace_days"]
+                if "commitment_stale_days" in data:
+                    config.commitment_stale_days = data["commitment_stale_days"]
+                if "commitment_stale_importance_ceiling" in data:
+                    config.commitment_stale_importance_ceiling = data["commitment_stale_importance_ceiling"]
+                if "prediction_surface_threshold" in data:
+                    config.prediction_surface_threshold = data["prediction_surface_threshold"]
                 if "enable_auto_sacred" in data:
                     config.enable_auto_sacred = data["enable_auto_sacred"]
                 if "close_circle_keywords" in data:
@@ -335,6 +354,18 @@ class MemoryConfig:
         if self.archive_threshold_days < self.cooling_threshold_days:
             logger.warning(f"archive_threshold_days must be >= cooling_threshold_days, using {self.cooling_threshold_days * 3}")
             self.archive_threshold_days = self.cooling_threshold_days * 3
+        if self.commitment_grace_days < 0:
+            logger.warning(f"commitment_grace_days={self.commitment_grace_days} below minimum, using 14")
+            self.commitment_grace_days = 14
+        if self.commitment_stale_days < 1:
+            logger.warning(f"commitment_stale_days={self.commitment_stale_days} below minimum, using 60")
+            self.commitment_stale_days = 60
+        if not (0.0 <= self.commitment_stale_importance_ceiling <= 1.0):
+            logger.warning(f"commitment_stale_importance_ceiling={self.commitment_stale_importance_ceiling} out of range [0,1], using default 0.5")
+            self.commitment_stale_importance_ceiling = 0.5
+        if not (0.0 <= self.prediction_surface_threshold <= 1.0):
+            logger.warning(f"prediction_surface_threshold={self.prediction_surface_threshold} out of range [0,1], using default 0.6")
+            self.prediction_surface_threshold = 0.6
         if self.context_builder_token_budget < 500:
             logger.warning(f"context_builder_token_budget={self.context_builder_token_budget} too small, using 2000")
             self.context_builder_token_budget = 2000
@@ -389,6 +420,11 @@ class MemoryConfig:
             "backup_weekly_retention": self.backup_weekly_retention,
             "cooling_threshold_days": self.cooling_threshold_days,
             "archive_threshold_days": self.archive_threshold_days,
+            "commitment_resolver_enabled": self.commitment_resolver_enabled,
+            "commitment_grace_days": self.commitment_grace_days,
+            "commitment_stale_days": self.commitment_stale_days,
+            "commitment_stale_importance_ceiling": self.commitment_stale_importance_ceiling,
+            "prediction_surface_threshold": self.prediction_surface_threshold,
             "enable_auto_sacred": self.enable_auto_sacred,
             "enable_chain_verification": self.enable_chain_verification,
             "context_builder_token_budget": self.context_builder_token_budget,

package/memory-daemon/claudia_memory/daemon/scheduler.py

@@ -4,6 +4,7 @@ Background Scheduler for Claudia Memory System
 Runs scheduled consolidation tasks using APScheduler.
 """
 
+import asyncio
 import json
 import logging
 import os
@@ -183,6 +184,328 @@ def _ingest_observations(db, config):
         logger.debug(f"Ingested {ingested} observations from hook capture")
 
 
+def _parse_transcript(transcript_path: str, max_chars: int = 4000) -> str:
+    """Parse a Claude Code JSONL transcript and extract readable conversation text.
+
+    Tolerates truncated last lines. Skips tool_use/tool_result entries.
+    Returns up to max_chars of concatenated human/assistant text.
+    """
+    path = Path(transcript_path)
+    if not path.exists():
+        return ""
+
+    # Skip very large files
+    try:
+        if path.stat().st_size > 50 * 1024 * 1024:  # 50MB
+            return ""
+    except OSError:
+        return ""
+
+    text_parts = []
+    total_chars = 0
+
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            for line in f:
+                if total_chars >= max_chars:
+                    break
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    turn = json.loads(line)
+                except json.JSONDecodeError:
+                    # Tolerate truncated last line silently
+                    continue
+
+                # Skip tool use entries
+                turn_type = turn.get("type", "")
+                if turn_type in ("tool_use", "tool_result"):
+                    continue
+
+                role = turn.get("role") or turn.get("type", "")
+                if role not in ("user", "human", "assistant"):
+                    continue
+
+                content = turn.get("content") or turn.get("text") or ""
+                if isinstance(content, list):
+                    # Extract text blocks, skip tool_use blocks
+                    parts = []
+                    for block in content:
+                        if isinstance(block, dict):
+                            if block.get("type") == "tool_use" or block.get("type") == "tool_result":
+                                continue
+                            if block.get("type") == "text":
+                                parts.append(block.get("text", ""))
+                    content = " ".join(parts)
+                elif not isinstance(content, str):
+                    continue
+
+                content = content.strip()
+                if not content:
+                    continue
+
+                prefix = "User: " if role in ("user", "human") else "Assistant: "
+                chunk = prefix + content[:500] + "\n"
+                text_parts.append(chunk)
+                total_chars += len(chunk)
+
+    except OSError:
+        return ""
+
+    return "".join(text_parts)[:max_chars]
+
+
+def _process_sessions(db, config):
+    """Poll ~/.claudia/sessions_pending.jsonl and ingest sessions into memory.
+
+    Mirrors _ingest_observations() exactly in structure:
+    - Atomic rename to prevent race conditions with hook writers
+    - Skips sessions already ingested (ingested_at IS NOT NULL in episodes)
+    - Extracts text from transcript JSONL
+    - Files raw source material first (Source Preservation)
+    - Runs LLM extraction via ingest service
+    - Uses AUDN write helper for semantic dedup
+    - Marks episode as ingested when done
+    """
+    if not getattr(config, "session_capture_enabled", True):
+        return
+
+    queue_file = Path.home() / ".claudia" / "sessions_pending.jsonl"
+    processing_file = queue_file.with_suffix(".jsonl.processing")
+
+    if not queue_file.exists():
+        return
+
+    try:
+        if queue_file.stat().st_size == 0:
+            return
+    except OSError:
+        return
+
+    # Atomic rename to prevent race with hook writes
+    try:
+        os.rename(str(queue_file), str(processing_file))
+    except OSError:
+        return
+
+    processed = 0
+
+    try:
+        with open(processing_file, "r", encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    entry = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+
+                session_id = entry.get("session_id", "")
+                transcript_path = entry.get("transcript_path", "")
+
+                if not session_id:
+                    continue
+
+                # Skip if already ingested
+                try:
+                    row = db.execute(
+                        "SELECT id, ingested_at FROM episodes WHERE session_id = ?",
+                        (session_id,),
+                        fetch=True,
+                    )
+                    if row and row[0]["ingested_at"] is not None:
+                        logger.debug(f"Session {session_id} already ingested, skipping")
+                        continue
+                    episode_id = row[0]["id"] if row else None
+                except Exception as e:
+                    logger.debug(f"Could not check episode for {session_id}: {e}")
+                    episode_id = None
+
+                # Parse transcript
+                raw_text = ""
+                if transcript_path:
+                    try:
+                        raw_text = _parse_transcript(transcript_path)
+                    except Exception as e:
+                        logger.debug(f"Transcript parse error for {session_id}: {e}")
+
+                # Create or reuse episode
+                try:
+                    if episode_id is None:
+                        now = datetime.utcnow().isoformat()
+                        episode_id = db.insert(
+                            "episodes",
+                            {
+                                "session_id": session_id,
+                                "started_at": now,
+                                "message_count": 0,
+                                "is_summarized": 0,
+                            },
+                        )
+                except Exception as e:
+                    logger.debug(f"Could not create episode for {session_id}: {e}")
+                    continue
+
+                now_iso = datetime.utcnow().isoformat()
+
+                # If transcript is empty, mark as ingested and continue
+                if not raw_text.strip():
+                    try:
+                        db.update(
+                            "episodes",
+                            {"ingested_at": now_iso, "is_summarized": 1},
+                            "id = ?",
+                            (episode_id,),
+                        )
+                    except Exception:
+                        pass
+                    processed += 1
+                    continue
+
+                # Source Preservation: file raw transcript first
+                try:
+                    from ..services.remember import get_remember_service
+                    remember_svc = get_remember_service()
+                    # Store a stub memory to link to source material
+                    stub_id = remember_svc.remember_fact(
+                        content=f"Session transcript: {session_id}",
+                        memory_type="observation",
+                        importance=0.3,
+                        source="session_transcript",
+                        source_id=session_id,
+                        origin_type="extracted",
+                        metadata={"verification_status": "pending", "is_source_stub": True},
+                    )
+                    if stub_id:
+                        remember_svc.save_source_material(
+                            stub_id,
+                            raw_text,
+                            metadata={
+                                "source": "session_transcript",
+                                "session_id": session_id,
+                            },
+                        )
+                except Exception as e:
+                    logger.debug(f"Source preservation failed for {session_id}: {e}")
+
+                # LLM extraction
+                try:
+                    from ..services.ingest import get_ingest_service
+                    from ..language_model import get_language_model_service
+                    from ..services.audn import audn_write
+
+                    ingest_svc = get_ingest_service()
+                    llm_svc = get_language_model_service()
+
+                    result = asyncio.run(ingest_svc.ingest(raw_text, source_type="session"))
+
+                    if result["status"] == "llm_unavailable":
+                        # Mark as ingested so we don't re-queue; no data to store
+                        logger.debug(f"LLM unavailable for session {session_id}, marking as processed")
+                        db.update(
+                            "episodes",
+                            {"ingested_at": now_iso, "is_summarized": 0},
+                            "id = ?",
+                            (episode_id,),
+                        )
+                        processed += 1
+                        continue
+
+                    if result["status"] == "extracted" and result.get("data"):
+                        data = result["data"]
+
+                        # Write facts via AUDN
+                        for fact in data.get("facts", []):
+                            try:
+                                asyncio.run(audn_write(
+                                    content=fact.get("content", ""),
+                                    memory_type=fact.get("type", "fact"),
+                                    about_entities=fact.get("about", []),
+                                    importance=fact.get("importance", 0.6),
+                                    source="session_transcript",
+                                    source_id=session_id,
+                                    db=db,
+                                    llm_service=llm_svc,
+                                ))
+                            except Exception as e:
+                                logger.debug(f"AUDN write failed for fact: {e}")
+
+                        # Write commitments via AUDN
+                        for commitment in data.get("commitments", []):
+                            try:
+                                asyncio.run(audn_write(
+                                    content=commitment.get("content", ""),
+                                    memory_type="commitment",
+                                    about_entities=[commitment["who"]] if commitment.get("who") else [],
+                                    importance=commitment.get("importance", 0.7),
+                                    source="session_transcript",
+                                    source_id=session_id,
+                                    db=db,
+                                    llm_service=llm_svc,
+                                ))
+                            except Exception as e:
+                                logger.debug(f"AUDN write failed for commitment: {e}")
+
+                        # Write decisions via AUDN
+                        for decision in data.get("decisions", []):
+                            try:
+                                asyncio.run(audn_write(
+                                    content=decision.get("content", ""),
+                                    memory_type="fact",
+                                    about_entities=[],
+                                    importance=decision.get("importance", 0.7),
+                                    source="session_transcript",
+                                    source_id=session_id,
+                                    db=db,
+                                    llm_service=llm_svc,
+                                ))
+                            except Exception as e:
+                                logger.debug(f"AUDN write failed for decision: {e}")
+
+                        # Store narrative and structured data via end_session
+                        try:
+                            from ..services.remember import get_remember_service
+                            remember_svc = get_remember_service()
+                            narrative = data.get("summary", f"Session {session_id} processed from transcript.")
+                            remember_svc.end_session(
+                                episode_id=episode_id,
+                                narrative=narrative,
+                                entities=data.get("entities", []),
+                                relationships=data.get("relationships", []),
+                                key_topics=data.get("key_topics", []),
+                            )
+                        except Exception as e:
+                            logger.debug(f"end_session failed for {session_id}: {e}")
+
+                except Exception as e:
+                    logger.debug(f"Extraction failed for session {session_id}: {e}")
+
+                # Mark as ingested regardless of extraction outcome
+                try:
+                    db.update(
+                        "episodes",
+                        {"ingested_at": now_iso},
+                        "id = ?",
+                        (episode_id,),
+                    )
+                    processed += 1
+                except Exception as e:
+                    logger.debug(f"Could not mark session {session_id} as ingested: {e}")
+
+    except Exception as e:
+        logger.debug(f"Error reading sessions_pending file: {e}")
+    finally:
+        try:
+            processing_file.unlink(missing_ok=True)
+        except Exception:
+            pass
+
+    if processed > 0:
+        logger.debug(f"Processed {processed} sessions from session capture queue")
+
+
 class MemoryScheduler:
     """Manages scheduled memory maintenance tasks"""
 
@@ -265,6 +588,17 @@ class MemoryScheduler:
                 misfire_grace_time=60,
             )
 
+        # Every 60 seconds: Session ingestion from SessionEnd/SessionStart hooks
+        if getattr(self.config, "session_capture_enabled", True):
+            self.scheduler.add_job(
+                self._run_session_ingest,
+                IntervalTrigger(seconds=60),
+                id="session_ingest",
+                name="Session ingestion",
+                replace_existing=True,
+                misfire_grace_time=300,
+            )
+
         self.scheduler.start()
         self._started = True
         logger.info("Memory scheduler started")
@@ -392,6 +726,17 @@ class MemoryScheduler:
         except Exception as e:
             logger.debug(f"Error in observation ingestion: {e}")
 
+    def _run_session_ingest(self) -> None:
+        """Ingest sessions from SessionEnd/SessionStart hook queue."""
+        try:
+            from ..database import get_db
+            run_with_status(
+                "session_ingest",
+                lambda: _process_sessions(get_db(), self.config),
+            )
+        except Exception as e:
+            logger.debug(f"Error in session ingestion: {e}")
+
 
 # Global scheduler instance
 _scheduler: Optional[MemoryScheduler] = None