get-claudia 1.28.0 → 1.28.2

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

@@ -1427,6 +1427,19 @@ async def call_tool(name: str, arguments: Dict[str, Any]) -> CallToolResult:
 
         elif name == "memory.end_session":
             episode_id = arguments["episode_id"]
+
+            # Auto-create episode if it doesn't exist (handles skipped buffer_turn)
+            svc = get_remember_service()
+            episode = svc.db.get_one("episodes", where="id = ?", where_params=(episode_id,))
+            if not episode:
+                from datetime import datetime
+                new_id = svc.db.insert("episodes", {
+                    "started_at": datetime.utcnow().isoformat(),
+                    "source": arguments.get("source", "claude_code"),
+                })
+                logger.info(f"Auto-created episode {new_id} (requested {episode_id} did not exist)")
+                episode_id = new_id
+
             result = end_session(
                 episode_id=episode_id,
                 narrative=arguments["narrative"],

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

@@ -993,6 +993,13 @@ class RememberService:
             "relationships_stored": 0,
         }
 
+        # Validate episode exists before any DB operations
+        episode = self.db.get_one("episodes", where="id = ?", where_params=(episode_id,))
+        if not episode:
+            result["error"] = f"Episode {episode_id} not found. Call memory.buffer_turn first to create an episode."
+            logger.warning(f"end_session called with non-existent episode_id={episode_id}")
+            return result
+
         # 1. Store narrative in episode
         update_data = {
             "narrative": narrative,

package/memory-daemon/tests/test_turn_buffering.py

@@ -160,6 +160,43 @@ class TestEndSession:
             db.close()
 
 
+    def test_end_session_nonexistent_episode(self):
+        """end_session with a non-existent episode_id should return error, not raise."""
+        db, tmpdir = _make_db()
+        try:
+            svc = _make_service(db)
+
+            # Call end_session with an episode_id that was never created
+            result = svc.end_session(
+                episode_id=9999,
+                narrative="This episode does not exist."
+            )
+
+            assert result["episode_id"] == 9999
+            assert result["narrative_stored"] is False
+            assert "error" in result
+            assert "not found" in result["error"].lower()
+        finally:
+            db.close()
+
+    def test_end_session_episode_zero(self):
+        """end_session with episode_id=0 should return error (AUTOINCREMENT starts at 1)."""
+        db, tmpdir = _make_db()
+        try:
+            svc = _make_service(db)
+
+            result = svc.end_session(
+                episode_id=0,
+                narrative="Default zero episode."
+            )
+
+            assert result["episode_id"] == 0
+            assert result["narrative_stored"] is False
+            assert "error" in result
+        finally:
+            db.close()
+
+
 class TestUnsummarized:
     """Tests for get_unsummarized_turns functionality."""
 

package/package.json

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

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

@@ -1,10 +1,40 @@
 #!/bin/bash
 # Quick health check at session start
 # Returns JSON with additionalContext to inform Claudia of memory system status
+# Provides actionable guidance when daemon is down
 
 if curl -s "http://localhost:3848/health" 2>/dev/null | grep -q "healthy"; then
   echo '{"additionalContext": "Memory system healthy."}'
-else
-  echo '{"additionalContext": "Warning: Memory daemon not responding. Run /diagnose for details. Operating in fallback mode."}'
+  exit 0
 fi
+
+# Daemon is NOT healthy. Figure out why and provide actionable guidance.
+CONTEXT="IMPORTANT: Memory daemon is NOT running. Without it, you lose semantic search, pattern detection, cross-session learning, and proactive predictions. You MUST surface this to the user and offer to help fix it."
+
+# Check if daemon is installed
+if [[ "$OSTYPE" == "darwin"* ]]; then
+  PLIST="$HOME/Library/LaunchAgents/com.claudia.memory.plist"
+  if [ -f "$PLIST" ]; then
+    CONTEXT="$CONTEXT Daemon is installed (LaunchAgent exists) but not running. Suggest: 'Your memory daemon is installed but stopped. Want me to try starting it? I can run: launchctl load ~/Library/LaunchAgents/com.claudia.memory.plist'"
+  else
+    CONTEXT="$CONTEXT Daemon is NOT installed. Suggest: 'The memory daemon hasn\u0027t been set up yet. Want me to install it? I can run the installer for you.'"
+  fi
+elif [[ "$OSTYPE" == "linux-gnu"* ]]; then
+  SERVICE="$HOME/.config/systemd/user/claudia-memory.service"
+  if [ -f "$SERVICE" ]; then
+    CONTEXT="$CONTEXT Daemon is installed (systemd service exists) but not running. Suggest: 'Your memory daemon is installed but stopped. Want me to try starting it? I can run: systemctl --user start claudia-memory'"
+  else
+    CONTEXT="$CONTEXT Daemon is NOT installed. Suggest: 'The memory daemon hasn\u0027t been set up yet. Want me to install it? I can run the installer for you.'"
+  fi
+fi
+
+# Check for recent crash logs
+if [ -f "$HOME/.claudia/daemon-stderr.log" ]; then
+  LAST_ERROR=$(tail -5 "$HOME/.claudia/daemon-stderr.log" 2>/dev/null | head -3)
+  if [ -n "$LAST_ERROR" ]; then
+    CONTEXT="$CONTEXT Recent daemon log: $LAST_ERROR"
+  fi
+fi
+
+echo "{\"additionalContext\": \"$CONTEXT\"}"
 exit 0

package/template-v2/.claude/skills/memory-manager.md

@@ -81,9 +81,17 @@ User shares transcript/email/document
 
 Before greeting the user:
 1. Check that `memory.*` tools are in your available tools
-2. If missing: Warn user "Memory daemon not connected. Run /diagnose."
+2. If missing: **Do not silently fall back.** Proactively tell the user and offer to fix it:
+   - If the session-health-check hook reported the daemon is installed but stopped, offer to start it:
+     - macOS: `launchctl load ~/Library/LaunchAgents/com.claudia.memory.plist`
+     - Linux: `systemctl --user start claudia-memory`
+   - If the daemon was never installed, offer to run the installer:
+     - `~/.claudia/daemon/scripts/install.sh` (if daemon dir exists)
+     - Or `cd [claudia-dir] && ./memory-daemon/scripts/install.sh`
+   - Briefly explain what's lost without it: "Without the daemon, I can't search memories semantically, detect patterns, track relationships across sessions, or give you proactive predictions."
+   - After starting, the user needs to restart Claude Code for MCP tools to appear
 3. Call `memory.session_context` to load context
-4. If this fails: Warn user about degraded mode
+4. If this fails: Warn user about degraded mode and suggest checking `~/.claudia/daemon-stderr.log`
 
 ### 3. Buffer Turns During Sessions
 
@@ -157,21 +165,32 @@ Do NOT:
 
 ## Memory System Detection
 
-At session start, check which memory system is available:
+At session start, check which memory system is available. **This is not optional.** The daemon is Claudia's brain. Without it she's operating at a fraction of her capability.
 
 1. **Enhanced Memory (Preferred):** Check if `memory.recall` MCP tool is available
-2. **Fallback:** Use markdown files in `context/` directory
+2. **If missing, diagnose and offer to fix** (don't silently degrade)
+3. **Fallback:** Use markdown files in `context/` directory only as last resort
 
 ```
 Session Start:
 ├── Check if memory.recall tool exists
 │   ├── YES → Use enhanced memory system
-│   └── NO → Check if this might be a restart issue
-│       ├── Check daemon health: curl -s localhost:3848/health
+│   └── NO → Check session-health-check hook output for diagnosis
+│       ├── Hook says "installed but stopped"
+│       │   → Offer to start: "Your memory daemon is installed but stopped.
+│       │     Want me to start it?" Then run the platform-specific command.
+│       │     After starting, user must restart Claude Code for MCP tools.
+│       ├── Hook says "not installed"
+│       │   → Offer to install: "The memory system hasn't been set up yet.
+│       │     Want me to run the installer?"
+│       ├── No hook output → Check daemon health: curl -s localhost:3848/health
 │       │   ├── Healthy but no MCP tools → User needs to restart Claude Code
-│       │   └── Not healthy → Fall back to markdown files
+│       │   └── Not healthy → Offer to start/install (as above)
+│       └── After offering, if user declines → Fall back to markdown files
 ```
 
+**The key behavior change:** Never silently fall back to markdown. Always tell the user and offer to fix it. The daemon makes Claudia dramatically more capable and users should know when they're missing out.
+
 ---
 
 ## Troubleshooting MCP Connection

package/template-v2/CLAUDE.md

@@ -81,14 +81,18 @@ Check for `context/me.md` at the start of any session. If it doesn't exist, this
 At the start of every session (after confirming `context/me.md` exists):
 
 1. **Verify memory tools** - Check that `memory.*` MCP tools are available in your tool list
-   - If NO memory tools: Warn user "Memory daemon not connected. Memories won't persist this session. Run `/diagnose` to troubleshoot."
+   - If NO memory tools: **Don't just warn. Offer to fix it.** Check the session-health-check hook output:
+     - Daemon installed but stopped → Offer to start it (platform-specific command)
+     - Daemon not installed → Offer to run the installer
+     - Briefly explain what's lost: semantic search, pattern detection, cross-session learning, proactive predictions
+     - If user agrees to start it, they'll need to restart Claude Code afterward for MCP tools to register
    - If memory tools present: Continue to step 2
 2. **Load context** - Call `memory.session_context` to get recent memories, predictions, commitments, and unsummarized session alerts
    - If this call fails: The daemon may have crashed. Suggest checking `~/.claudia/daemon-stderr.log`
 3. **Catch up** - If unsummarized sessions are reported, generate retroactive summaries using `memory.end_session`
 4. **Greet naturally** - Use the loaded context to inform your greeting and surface urgent items
 
-**Fallback mode:** If memory tools aren't available, read markdown context files directly (`context/*.md`). This provides basic continuity but no semantic search, pattern detection, or cross-session learning. Always inform the user they're in degraded mode.
+**Fallback mode:** If memory tools aren't available and the user declines to start the daemon, read markdown context files directly (`context/*.md`). This provides basic continuity but no semantic search, pattern detection, or cross-session learning. Always inform the user they're in degraded mode.
 
 ### Returning User Greetings