get-claudia 1.65.0 → 1.66.0

package/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 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

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

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

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

@@ -9,6 +9,8 @@ import json
 import os
 import shutil
 import subprocess
+import sys
+import time
 import urllib.request
 from pathlib import Path
 
@@ -24,6 +26,88 @@ def _fetch_briefing():
         return None
 
 
+# Daemon self-heal at session start.
+# A fresh install (or a crashed/killed daemon) can leave the memory daemon down,
+# in which case the in-session memory tools silently do nothing. This probes the
+# daemon and, on macOS with a LaunchAgent present, attempts exactly one automatic
+# restart; every other down path only advises. A hook must never become a process
+# manager, so process spawning is limited to a single launchd reload that mirrors
+# the installer (bin/index.js). Fail-open and hard-bounded: it must never block or
+# crash session start.
+
+DAEMON_HEALTH_URL = "http://localhost:3848/health"
+LAUNCHD_LABEL = "com.claudia.memory"
+LAUNCHD_PLIST = Path.home() / "Library" / "LaunchAgents" / "com.claudia.memory.plist"
+
+
+def _daemon_up(timeout: float = 2.0) -> bool:
+    """True if the memory daemon answers its /health endpoint. Fail-closed."""
+    try:
+        req = urllib.request.Request(DAEMON_HEALTH_URL)
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            return getattr(resp, "status", 200) == 200
+    except Exception:
+        return False
+
+
+def _is_macos() -> bool:
+    return sys.platform == "darwin"
+
+
+def _launchd_restart() -> None:
+    """One launchd reload: unload then load the plist (mirrors bin/index.js).
+    Bounded 5s per call, fail-open, never raises."""
+    for action in ("unload", "load"):
+        try:
+            subprocess.run(
+                ["launchctl", action, str(LAUNCHD_PLIST)],
+                capture_output=True, timeout=5,
+            )
+        except Exception:
+            pass
+
+
+def _daemon_fix_guidance() -> str:
+    """Concrete, stepwise fix guidance when the daemon is down and could not be
+    auto-restarted, so the persona can walk the user through it."""
+    return (
+        "Memory daemon is not running and I could not auto-restart it. To fix: "
+        "(1) run `claudia system-health` to diagnose; "
+        "(2) on macOS, re-run `npx get-claudia .` from your Claudia folder to reinstall "
+        "the LaunchAgent, then restart this session; "
+        "(3) on Windows, this is known issue #37 (the daemon's Python dependencies may "
+        "never have installed) -- re-run the installer and check that ~/.claudia/daemon/ "
+        "has a venv. "
+        "Meanwhile I will work from context/ files only (no semantic search or pattern "
+        "detection), and I will say so rather than imply memory is live."
+    )
+
+
+def _ensure_daemon() -> str:
+    """Ensure the memory daemon is up at session start.
+
+    Returns a message to surface (a recovery note or fix guidance), or '' when the
+    daemon is healthy. Fail-open and hard-bounded so it never blocks or crashes
+    session start.
+    """
+    try:
+        if _daemon_up(timeout=2.0):
+            return ""
+        if _is_macos() and LAUNCHD_PLIST.exists():
+            _launchd_restart()
+            time.sleep(2)  # give launchd a moment to bring the daemon up
+            if _daemon_up(timeout=2.0):
+                return (
+                    "Memory daemon was down at session start; I restarted it "
+                    "automatically. Memory is available."
+                )
+            return _daemon_fix_guidance()
+        # Non-macOS, or macOS with no LaunchAgent plist: advise only, never spawn.
+        return _daemon_fix_guidance()
+    except Exception:
+        return ""
+
+
 def _recent_sessions_summary(max_days: int = 3) -> str:
     """Return a compact recap of the last N days of session summaries.
 
@@ -322,10 +406,13 @@ def check_health():
             parts.append("Embeddings unavailable.")
 
         summary = " ".join(parts) if parts else "System ready."
+        daemon_note = _ensure_daemon()
         briefing = _fetch_briefing()
         recent = _recent_sessions_summary()
 
         sections = [f"Memory system healthy. {summary}"]
+        if daemon_note:
+            sections.append("--- Memory Daemon ---\n" + daemon_note)
         if recent:
             sections.append("--- Recent Sessions ---\n" + recent)
         if briefing:

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

@@ -1,6 +1,6 @@
 {
-  "version": "1.65.0",
-  "generated": "2026-06-16T03:58:36.245Z",
+  "version": "1.66.0",
+  "generated": "2026-07-09T20:07:26.062Z",
   "algorithm": "sha256",
   "files": {
     ".claude/rules/claudia-principles.md": "939e9720421628e7f2e4c8dfbaa4aeb9c1e18e8c6a5379cd6b772a6835b812e5",
@@ -21,7 +21,7 @@
     ".claude/skills/archetypes/executive.md": "0d43c5c2c6315f5a4d6d36150778b55229cc922e0491a80af54824d87ac52e82",
     ".claude/skills/archetypes/founder.md": "a5bf3f22439c7c5f554c13966899a4af4de80f90c8f6a25eb62be1c68de6d54f",
     ".claude/skills/archetypes/solo.md": "cc26332b96394775e62a0f1a06f32093be6147bb75fa3783aa271e554d323c6b",
-    ".claude/skills/auto-research/SKILL.md": "2f7f8a7d0731813921094b0117026693314f0f59e8d9b52637bd3e775a2e95f8",
+    ".claude/skills/auto-research/SKILL.md": "ca02992657324bd48c84c00168062903ce7fda303479185b1aeb62a90a97c46d",
     ".claude/skills/auto-research/references/program-template.md": "850457de96bde5ad65d24f1018509da94dd31fec9ec45c15087031f470a28dbc",
     ".claude/skills/auto-research/references/safety-rules.md": "ae036270e86949ed0f9bface582f6038276adafd3f40a29aa733698111a26683",
     ".claude/skills/brain/SKILL.md": "b87dd93c85923c676292bea67f7a0580ee71eea2bea05426ea6eda951a140d5c",

package/template-v2/.claude/skills/auto-research/SKILL.md

@@ -151,6 +151,56 @@ proposes one fix, and proves it on the exact failing input before adopting it.
 See `.claude/skills/_loop/repair.md`. It is capped at 2 repair attempts and never
 auto-edits shipped briefs (those changes go to a human approval gate).
 
+## Worked example (dry run)
+
+A short run of "tighten this board update", to show the loop and the independent
+Checker in practice. The artifact is `artifact.md`; the rubric is the board
+update rubric below. Budget: 20 iterations.
+
+```
+iter 0: score 6.1 (baseline)            checker: solid update, but the lede buries the one number that matters; the ask is split across two sentences
+iter 1: score 7.0 (kept)                maker: moved the revenue number into the opening line | checker: lede now leads with the number; ask still split
+iter 2: score 7.0 (reverted)            maker: cut the second paragraph | checker: lost the context the board needs for the ask; net neutral
+iter 3: score 7.8 (kept)                maker: merged the ask into one sentence | checker: ask is now one clear line; tone matches prior updates
+iter 4: score 8.4 (kept) [contested]    maker self-score 9.5 | checker: tighter, but "significantly" is doing unearned work in the headline
+iter 5: score 8.4 (reverted)            maker: swapped the closing line | checker: weaker call to action than iter 4; revert
+iter 6: plateau                         no gain for the last 3 iterations; remaining changes are cosmetic
+```
+
+The loop stops at iteration 6 on plateau. `research_status.md` at that point:
+
+```markdown
+---
+loop_id: tighten-board-update-20260613
+iteration: 6
+verified: true
+score: 8.4
+budget_remaining: 14
+last_input: board update draft v4
+maker_proposal: swapped the closing line (reverted)
+checker_verdict: best version is iter 4; remaining changes are cosmetic
+next_action: hand off iter 4 to the user
+updated_at: 2026-06-13T15:02:00Z
+---
+
+# Loop status: tighten-board-update
+
+Ratcheted 6.1 to 8.4 over 4 kept iterations. One contested iteration (iter 4):
+Claudia self-scored 9.5, the Checker scored 8.4 and flagged an unearned
+intensifier. The Checker's score governed. Plateaued at iter 6.
+```
+
+Hand-off to the user: "Started at 6.1, ended at 8.4 over 6 iterations. The three
+biggest jumps were moving the revenue number into the lede (iter 1), collapsing
+the ask into one sentence (iter 3), and the tone pass (iter 4). One iteration was
+contested: I scored iter 4 a 9.5, the Checker held it to 8.4 because the headline
+leaned on 'significantly' with no number behind it. I kept the Checker's call.
+Want iter 4 back at the original location?"
+
+That contested iteration is the whole point of the split. Without an independent
+Checker, iter 4 ships at the inflated 9.5 self-score. With it, the unearned
+intensifier gets caught and the honest 8.4 governs.
+
 ## Safety rules (mandatory, follow without exception)
 
 1. **Workspace-only edits.** The loop never writes to a file outside `~/.claudia/auto-research/<task-id>/`. The user's original file at `/Users/.../wherever.md` is untouched until the user explicitly approves the final hand-off.