get-claudia 1.63.0 → 1.64.0

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 All notable changes to Claudia will be documented in this file.
 
+## 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

@@ -23,10 +23,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",
@@ -282,72 +296,99 @@ 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}")
 

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/package.json

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

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

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