get-claudia 1.63.0 → 1.65.0

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 All notable changes to Claudia will be documented in this file.
 
+## 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
+
+- **Status-only wrap for daemon scheduled jobs** (Proposal 11, E5). The seven background jobs (importance decay, pattern detection, consolidation, daily and weekly backups, vault sync, observation ingest) now each write `~/.claudia/loops/<job>_status.md` and check deterministic invariants (the backup jobs assert the backup file exists and is non-empty). It is status-only: a failed invariant is flagged but never halts the job, and a job that raises is recorded and then re-raised, so daemon behavior is unchanged. `memory.system_health` and the `/status` endpoint now surface each job's last verdict plus a flagged count. New module `claudia_memory/loops/job_wrapper.py` (6 tests); health surfacing has 2 tests; full daemon suite stays green (803 passed). This completes Proposal 11.
+
 ## 1.63.0 (2026-06-13)
 
 ### Added

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

@@ -152,6 +152,34 @@ def build_status_report(*, db=None) -> dict:
     except Exception:
         report["components"]["scheduler"] = "error"
 
+    # Loop status files (Proposal 11, E5): last verdict per wrapped daemon job.
+    # Purely observational; the overall status is not changed by a flagged job.
+    try:
+        from ..loops.job_wrapper import default_loops_dir
+        from ..loops.status import read_status
+
+        loops = []
+        loops_dir = default_loops_dir()
+        if loops_dir.exists():
+            for status_file in sorted(loops_dir.glob("*_status.md")):
+                try:
+                    fields, _ = read_status(status_file)
+                except Exception:
+                    continue
+                loops.append(
+                    {
+                        "job": fields.get("loop_id", status_file.stem.replace("_status", "")),
+                        "verified": fields.get("verified"),
+                        "verdict": fields.get("checker_verdict"),
+                        "updated_at": fields.get("updated_at"),
+                    }
+                )
+        report["loops"] = loops
+        report["loops_flagged"] = sum(1 for entry in loops if entry.get("verified") is False)
+    except Exception:
+        report["loops"] = []
+        report["loops_flagged"] = 0
+
     return report
 
 

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
@@ -23,10 +24,24 @@ from ..services.consolidate import (
     run_full_consolidation,
 )
 from ..services.vault_sync import run_vault_sync
+from ..loops.job_wrapper import run_with_status
 
 logger = logging.getLogger(__name__)
 
 
+def _file_nonempty(path) -> "tuple[bool, str]":
+    """Invariant: a backup path must exist and be a non-empty file."""
+    try:
+        p = Path(path)
+        if not p.exists():
+            return False, f"backup file missing: {p}"
+        if p.stat().st_size == 0:
+            return False, f"backup file is empty: {p}"
+        return True, ""
+    except Exception as e:  # noqa: BLE001
+        return False, f"could not stat backup: {e!r}"
+
+
 # Tools whose invocations are always relevant for Claudia's memory
 RELEVANT_TOOL_PREFIXES = {
     "gmail", "google_workspace", "slack", "telegram",
@@ -169,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"""
 
@@ -251,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")
@@ -282,75 +630,113 @@ class MemoryScheduler:
         """Run importance decay daily"""
         try:
             logger.debug("Running daily decay")
-            result = run_decay()
+            result = run_with_status(
+                "daily_decay",
+                run_decay,
+                invariants=[("completed", lambda r: (r is not None, "decay returned no result"))],
+            )
             logger.debug(f"Daily decay complete: {result}")
-        except Exception as e:
+        except Exception:
             logger.exception("Error in daily decay")
 
     def _run_pattern_detection(self) -> None:
         """Run pattern detection"""
         try:
             logger.debug("Running pattern detection")
-            patterns = detect_patterns()
+            patterns = run_with_status(
+                "pattern_detection",
+                detect_patterns,
+                invariants=[("is_list", lambda r: (isinstance(r, (list, tuple)), "patterns not a list"))],
+            )
             logger.info(f"Pattern detection complete: {len(patterns)} patterns detected")
-        except Exception as e:
+        except Exception:
             logger.exception("Error in pattern detection")
 
     def _run_full_consolidation(self) -> None:
         """Run full overnight consolidation"""
         try:
             logger.info("Running full consolidation")
-            result = run_full_consolidation()
+            result = run_with_status(
+                "full_consolidation",
+                run_full_consolidation,
+                invariants=[("completed", lambda r: (r is not None, "consolidation returned no result"))],
+            )
             logger.info(f"Full consolidation complete: {result}")
-        except Exception as e:
+        except Exception:
             logger.exception("Error in full consolidation")
 
     def _run_daily_backup(self) -> None:
         """Create a labeled daily backup with 7-day retention."""
         try:
             from ..database import get_db
-            backup_path = get_db().backup(label="daily")
+            backup_path = run_with_status(
+                "daily_backup",
+                lambda: get_db().backup(label="daily"),
+                invariants=[("backup_nonempty", lambda p: _file_nonempty(p))],
+            )
             logger.info(f"Daily backup created: {backup_path}")
-        except Exception as e:
+        except Exception:
             logger.exception("Error in daily backup")
 
     def _run_weekly_backup(self) -> None:
         """Create a labeled weekly backup with 4-week retention."""
         try:
             from ..database import get_db
-            backup_path = get_db().backup(label="weekly")
+            backup_path = run_with_status(
+                "weekly_backup",
+                lambda: get_db().backup(label="weekly"),
+                invariants=[("backup_nonempty", lambda p: _file_nonempty(p))],
+            )
             logger.info(f"Weekly backup created: {backup_path}")
-        except Exception as e:
+        except Exception:
             logger.exception("Error in weekly backup")
 
     def _run_vault_sync(self) -> None:
         """Run Obsidian vault sync + canvas regeneration"""
         try:
-            logger.info("[Safety-net full sync] Running after 4R Reweave inline in consolidation")
             logger.info("Running vault sync")
             from ..config import _project_id
             from ..services.vault_sync import get_vault_path
             from ..services.canvas_generator import CanvasGenerator
 
-            result = run_vault_sync(project_id=_project_id)
-            logger.info(f"Vault sync complete: {result}")
-
-            # Regenerate canvases after sync
-            vault_path = get_vault_path(_project_id)
-            gen = CanvasGenerator(vault_path)
-            canvas_result = gen.generate_all()
-            logger.info(f"Canvas regeneration complete: {canvas_result}")
-        except Exception as e:
+            def _sync_and_canvas():
+                result = run_vault_sync(project_id=_project_id)
+                logger.info(f"Vault sync complete: {result}")
+                vault_path = get_vault_path(_project_id)
+                canvas_result = CanvasGenerator(vault_path).generate_all()
+                logger.info(f"Canvas regeneration complete: {canvas_result}")
+                return result
+
+            run_with_status(
+                "vault_sync",
+                _sync_and_canvas,
+                invariants=[("completed", lambda r: (r is not None, "vault sync returned no result"))],
+            )
+        except Exception:
             logger.exception("Error in vault sync")
 
     def _run_observation_ingest(self) -> None:
         """Ingest observations from PostToolUse hook captures."""
         try:
             from ..database import get_db
-            _ingest_observations(get_db(), self.config)
+            run_with_status(
+                "observation_ingest",
+                lambda: _ingest_observations(get_db(), self.config),
+            )
         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

package/memory-daemon/claudia_memory/loops/job_wrapper.py

@@ -0,0 +1,106 @@
+"""Status-only job wrapper for daemon scheduled jobs (Proposal 11, E5).
+
+Wraps a scheduled job so it writes a status file and flags invariant failures,
+without ever changing the job's behavior. This is the "status-only" form of the
+daemon wrap: a failed invariant is recorded but does NOT halt the job, and a job
+that raises is recorded and then re-raised so the daemon's existing error
+handling is preserved.
+
+Each invariant is a ``(name, check)`` pair where ``check(result)`` returns
+``(ok: bool, detail: str)``. A check may inspect the job's return value or
+external state (a backup file on disk, an entity count); it is deterministic, not
+an LLM (see Proposal 11 Decision D2: the daemon has no agent context).
+"""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Callable, Iterable
+
+from claudia_memory.loops.status import write_status
+
+Invariant = tuple[str, Callable[[Any], "tuple[bool, str]"]]
+
+
+def default_loops_dir() -> Path:
+    """Where daemon job status files live."""
+    return Path.home() / ".claudia" / "loops"
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def run_with_status(
+    job_id: str,
+    fn: Callable[[], Any],
+    invariants: Iterable[Invariant] = (),
+    status_dir: "str | Path | None" = None,
+    now: "str | None" = None,
+) -> Any:
+    """Run ``fn``, check ``invariants``, write ``<job_id>_status.md``, return result.
+
+    Status-only contract:
+    - A failed invariant flags the run (``verified: false``) but does not halt it;
+      the job's result is still returned.
+    - A job that raises is recorded as unverified and then re-raised, so the
+      daemon's existing error handling is unchanged.
+    """
+    base = Path(status_dir) if status_dir is not None else default_loops_dir()
+
+    error: BaseException | None = None
+    result: Any = None
+    try:
+        result = fn()
+    except Exception as e:  # noqa: BLE001 - recorded below, then re-raised
+        error = e
+
+    checks: list[tuple[str, bool, str]] = []
+    if error is None:
+        for name, check in invariants:
+            try:
+                ok, detail = check(result)
+            except Exception as e:  # noqa: BLE001 - a raising check is a failed check
+                ok, detail = False, f"invariant raised: {e!r}"
+            checks.append((name, bool(ok), str(detail)))
+
+    verified = error is None and all(ok for _, ok, _ in checks)
+    summary, body = _format_verdict(job_id, error, checks)
+
+    write_status(
+        base / f"{job_id}_status.md",
+        {
+            "loop_id": job_id,
+            "verified": verified,
+            "checker_verdict": summary,
+            "next_action": "none" if verified else "review flagged job run",
+            "updated_at": now or _now_iso(),
+        },
+        body=body,
+    )
+
+    if error is not None:
+        raise error
+    return result
+
+
+def _format_verdict(job_id: str, error: "BaseException | None", checks) -> "tuple[str, str]":
+    if error is not None:
+        summary = f"job raised {type(error).__name__}: {error}"
+        return summary, f"# Loop status: {job_id}\n\n{summary}"
+
+    failed = [(name, detail) for name, ok, detail in checks if not ok]
+    if not checks:
+        summary = "ran; no invariants defined"
+    elif not failed:
+        summary = f"all {len(checks)} invariant(s) held"
+    else:
+        names = ", ".join(name for name, _ in failed)
+        summary = f"{len(failed)} of {len(checks)} invariant(s) failed: {names}"
+
+    lines = [f"# Loop status: {job_id}", "", summary]
+    if failed:
+        lines.append("")
+        lines.extend(f"- {name}: {detail}" for name, detail in failed)
+    return summary, "\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/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.63.0",
+  "version": "1.65.0",
   "description": "An AI assistant who learns how you work.",
   "keywords": [
     "claudia",

package/template-v2/.claude/hooks/session-enqueue.py

@@ -0,0 +1,75 @@
+#!/usr/bin/env python3
+"""SessionEnd hook: enqueue session for ambient memory ingestion.
+
+Reads session_id + transcript_path from stdin (same contract as session-summary.py).
+Appends ONE JSON line to ~/.claudia/sessions_pending.jsonl for later consumption
+by the memory daemon's process_sessions job.
+
+Design constraints:
+- Must complete in <50ms (file append only, no SQLite)
+- Crash-proof: mkdir -p, atomic write (tmp file then os.rename)
+- Never writes SQLite directly
+"""
+
+import json
+import os
+import sys
+import time
+from pathlib import Path
+
+
+def main():
+    # Read and parse stdin (SessionEnd hook contract)
+    try:
+        raw = sys.stdin.read()
+        if not raw.strip():
+            return
+        payload = json.loads(raw)
+    except (json.JSONDecodeError, OSError):
+        return
+
+    session_id = payload.get("session_id", "")
+    transcript_path = payload.get("transcript_path", "")
+
+    if not session_id:
+        return
+
+    entry = {
+        "session_id": session_id,
+        "transcript_path": transcript_path,
+        "enqueued_at": time.time(),
+    }
+
+    claudia_dir = Path.home() / ".claudia"
+    claudia_dir.mkdir(parents=True, exist_ok=True)
+
+    queue_file = claudia_dir / "sessions_pending.jsonl"
+    tmp_file = claudia_dir / "sessions_pending.jsonl.tmp"
+
+    # Read existing content (if any)
+    existing = ""
+    try:
+        if queue_file.exists():
+            existing = queue_file.read_text(encoding="utf-8")
+    except OSError:
+        existing = ""
+
+    # Atomic write: write to .tmp then rename
+    new_line = json.dumps(entry) + "\n"
+    try:
+        tmp_file.write_text(existing + new_line, encoding="utf-8")
+        os.rename(str(tmp_file), str(queue_file))
+    except OSError:
+        # Try direct append as fallback (non-atomic but better than losing data)
+        try:
+            with open(queue_file, "a", encoding="utf-8") as f:
+                f.write(new_line)
+        except OSError:
+            pass
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception:
+        pass  # Never block Claude

package/template-v2/.claude/hooks/session-health-check.py

@@ -92,6 +92,220 @@ def _run_claudia(*args):
     return None
 
 
+def _enqueue_missed_sessions(queue_file_path: str = None) -> None:
+    """Scan ~/.claude/projects/ for transcript files and enqueue any
+    sessions not yet in sessions_pending.jsonl or already ingested in DB.
+
+    Bounded: max 50 transcript files, skip files >50MB.
+    Must complete in <2 seconds. Wrapped in try/except -- never crashes.
+    """
+    try:
+        import sqlite3
+        import time as _time
+
+        claudia_dir = Path.home() / ".claudia"
+        queue_file = Path(queue_file_path) if queue_file_path else claudia_dir / "sessions_pending.jsonl"
+        claude_projects_dir = Path.home() / ".claude" / "projects"
+        db_path = claudia_dir / "memory" / "claudia.db"
+
+        if not claude_projects_dir.exists():
+            return
+
+        # Load already-queued session ids
+        queued_ids: set = set()
+        try:
+            if queue_file.exists():
+                with open(queue_file, "r", encoding="utf-8") as f:
+                    for line in f:
+                        line = line.strip()
+                        if not line:
+                            continue
+                        try:
+                            entry = json.loads(line)
+                            sid = entry.get("session_id", "")
+                            if sid:
+                                queued_ids.add(sid)
+                        except json.JSONDecodeError:
+                            continue
+        except OSError:
+            pass
+
+        # Load already-ingested session ids from DB (best effort)
+        ingested_ids: set = set()
+        try:
+            if db_path.exists():
+                conn = sqlite3.connect(str(db_path), timeout=1.0)
+                conn.row_factory = sqlite3.Row
+                cursor = conn.execute(
+                    "SELECT session_id FROM episodes WHERE ingested_at IS NOT NULL AND session_id IS NOT NULL"
+                )
+                for row in cursor:
+                    ingested_ids.add(row["session_id"])
+                conn.close()
+        except Exception:
+            pass  # DB unavailable is fine; skip DB check
+
+        # Scan transcript files (bounded)
+        transcript_files = []
+        try:
+            for jsonl_file in claude_projects_dir.rglob("*.jsonl"):
+                try:
+                    if jsonl_file.stat().st_size > 50 * 1024 * 1024:
+                        continue
+                    transcript_files.append(jsonl_file)
+                    if len(transcript_files) >= 50:
+                        break
+                except OSError:
+                    continue
+        except Exception:
+            return
+
+        new_entries = []
+        for transcript_path in transcript_files:
+            # Extract session_id from first 20 lines
+            session_id = None
+            try:
+                with open(transcript_path, "r", encoding="utf-8") as f:
+                    for i, line in enumerate(f):
+                        if i >= 20:
+                            break
+                        line = line.strip()
+                        if not line or "session_id" not in line:
+                            continue
+                        try:
+                            turn = json.loads(line)
+                            sid = turn.get("session_id", "")
+                            if sid:
+                                session_id = sid
+                                break
+                        except json.JSONDecodeError:
+                            continue
+            except OSError:
+                continue
+
+            if not session_id:
+                continue
+            if session_id in queued_ids or session_id in ingested_ids:
+                continue
+
+            new_entries.append({
+                "session_id": session_id,
+                "transcript_path": str(transcript_path),
+                "enqueued_at": _time.time(),
+            })
+            queued_ids.add(session_id)  # Prevent duplicates within same scan
+
+        if not new_entries:
+            return
+
+        # Append new entries to queue file atomically
+        claudia_dir.mkdir(parents=True, exist_ok=True)
+        existing_content = ""
+        try:
+            if queue_file.exists():
+                existing_content = queue_file.read_text(encoding="utf-8")
+        except OSError:
+            pass
+
+        new_lines = "".join(json.dumps(e) + "\n" for e in new_entries)
+        tmp_file = queue_file.with_suffix(".jsonl.tmp")
+        try:
+            tmp_file.write_text(existing_content + new_lines, encoding="utf-8")
+            os.rename(str(tmp_file), str(queue_file))
+        except OSError:
+            # Fallback to direct append
+            try:
+                with open(queue_file, "a", encoding="utf-8") as f:
+                    f.write(new_lines)
+            except OSError:
+                pass
+
+    except Exception:
+        pass  # Never crash or block session start
+
+
+# Update availability check.
+# Surfaces, at session start, when a newer get-claudia has shipped. The launcher
+# only update-checks when you run the installer; this covers the gap when you
+# start a session via the shell launcher. Read-only, cached daily, timeout-bounded,
+# fail-open: it must never slow or block startup.
+
+_REGISTRY_URL = "https://registry.npmjs.org/get-claudia/latest"
+_UPDATE_CACHE = Path.home() / ".claudia" / ".update_check.json"
+_UPDATE_CACHE_TTL = 86400  # 24h
+
+
+def _is_newer_version(latest: str, current: str) -> bool:
+    """True if `latest` is a higher semver (major.minor.patch) than `current`."""
+    try:
+        a = [int(x) for x in str(latest).split(".")[:3]]
+        b = [int(x) for x in str(current).split(".")[:3]]
+        a += [0] * (3 - len(a))
+        b += [0] * (3 - len(b))
+        for i in range(3):
+            if a[i] > b[i]:
+                return True
+            if a[i] < b[i]:
+                return False
+        return False
+    except (ValueError, AttributeError):
+        return False
+
+
+def _installed_version(project_dir: str):
+    """Read the installed Claudia version from <project_dir>/.claude/manifest.json."""
+    try:
+        manifest = Path(project_dir) / ".claude" / "manifest.json"
+        return json.loads(manifest.read_text(encoding="utf-8")).get("version")
+    except Exception:
+        return None
+
+
+def _fetch_latest_version():
+    """Latest get-claudia version from npm, cached 24h. Fail-open (returns None)."""
+    import time
+    now = time.time()
+    try:
+        cached = json.loads(_UPDATE_CACHE.read_text(encoding="utf-8"))
+        if now - cached.get("checked_at", 0) < _UPDATE_CACHE_TTL:
+            return cached.get("latest")
+    except Exception:
+        pass
+    latest = None
+    try:
+        req = urllib.request.Request(_REGISTRY_URL)
+        with urllib.request.urlopen(req, timeout=2) as resp:
+            latest = json.loads(resp.read().decode("utf-8")).get("version")
+    except Exception:
+        latest = None
+    # Best-effort cache write (even on failure, to back off for 24h).
+    try:
+        _UPDATE_CACHE.parent.mkdir(parents=True, exist_ok=True)
+        _UPDATE_CACHE.write_text(
+            json.dumps({"checked_at": now, "latest": latest}), encoding="utf-8"
+        )
+    except Exception:
+        pass
+    return latest
+
+
+def _update_notice(project_dir: str) -> str:
+    """One-line notice if a newer get-claudia is available, else ''."""
+    try:
+        current = _installed_version(project_dir)
+        if not current:
+            return ""
+        latest = _fetch_latest_version()
+        if latest and _is_newer_version(latest, current):
+            return (
+                f"Update available: Claudia v{latest} (you're on v{current}). "
+                f"Run `claudia update` to upgrade."
+            )
+    except Exception:
+        pass
+    return ""
+
+
 def check_health():
     project_dir = os.environ.get("CLAUDE_PROJECT_DIR", ".")
 
@@ -117,6 +331,11 @@ def check_health():
         if briefing:
             sections.append("--- Session Briefing ---\n" + briefing)
 
+        notice = _update_notice(project_dir)
+        if notice:
+            sections.append("--- Update ---\n" + notice)
+
+        _enqueue_missed_sessions()
         print(json.dumps({"additionalContext": "\n\n".join(sections)}))
         return
 
@@ -145,6 +364,11 @@ def check_health():
     if profile:
         msg += f"\n\nUser profile (from context/me.md):\n{profile}"
 
+    notice = _update_notice(project_dir)
+    if notice:
+        msg += f"\n\n{notice}"
+
+    _enqueue_missed_sessions()
     print(json.dumps({"additionalContext": msg}))
 
 

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

@@ -1,6 +1,6 @@
 {
-  "version": "1.63.0",
-  "generated": "2026-06-14T02:49:59.295Z",
+  "version": "1.65.0",
+  "generated": "2026-06-16T03:58:36.245Z",
   "algorithm": "sha256",
   "files": {
     ".claude/rules/claudia-principles.md": "939e9720421628e7f2e4c8dfbaa4aeb9c1e18e8c6a5379cd6b772a6835b812e5",

package/template-v2/.claude/settings.local.json

@@ -62,6 +62,12 @@
             "command": "python3 \"$CLAUDE_PROJECT_DIR/.claude/hooks/session-summary.py\" 2>/dev/null || python \"$CLAUDE_PROJECT_DIR/.claude/hooks/session-summary.py\" 2>/dev/null || true",
             "timeout": 10000,
             "statusMessage": "Generating daily session summary..."
+          },
+          {
+            "type": "command",
+            "command": "python3 \"$CLAUDE_PROJECT_DIR/.claude/hooks/session-enqueue.py\" 2>/dev/null || python \"$CLAUDE_PROJECT_DIR/.claude/hooks/session-enqueue.py\" 2>/dev/null || true",
+            "timeout": 3000,
+            "statusMessage": "Queuing session for memory..."
           }
         ]
       }