feat(hooks): add visual indicators and fix validate cleanup

Visual indicators (emoji icons) added to all hooks:
- 📚 SessionStart: memory count status
- 💾 UserPromptSubmit: capture confirmation
- 🔍 PostToolUse: related memories found
- 🛑 Stop: uncaptured content warning

validate command improvements:
- Auto-cleanup test memories after validation
- Verify cleanup via search instead of count comparison
- Use reindex() instead of non-existent sync()

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: zircote

commands/validate.md

@@ -332,8 +332,39 @@ print("## 8. Cleanup")
 print("-" * 40)
 
 if test_memory_id:
-    test_pass("Test cleanup", f"Test memory {test_memory_id[:16]}... will persist")
-    log("To remove: git notes --ref=refs/notes/mem/learnings remove <commit>", 1)
+    try:
+        # Parse memory ID: {namespace}:{commit_sha}:{index}
+        parts = test_memory_id.split(":")
+        if len(parts) >= 2:
+            namespace = parts[0]
+            commit_sha = parts[1]
+
+            # Remove the git note
+            log(f"Removing test note from refs/notes/mem/{namespace}...", 1)
+            rm_result = subprocess.run(
+                ["git", "notes", f"--ref=refs/notes/mem/{namespace}", "remove", commit_sha],
+                capture_output=True, text=True
+            )
+
+            if rm_result.returncode == 0:
+                # Reindex to update SQLite index
+                sync_svc = get_sync_service()
+                sync_svc.reindex()
+
+                # Verify the test note is gone by searching for the marker
+                verify_results = recall.search(query=test_marker, k=5, namespace=namespace)
+                still_exists = any(test_marker in (r.content or '') for r in verify_results)
+
+                if not still_exists:
+                    test_pass("Test cleanup", f"Removed {test_memory_id[:20]}...")
+                else:
+                    test_warn("Test cleanup", "Note removed but still in index")
+            else:
+                test_warn("Test cleanup", f"git notes remove failed: {rm_result.stderr.strip()}")
+        else:
+            test_warn("Test cleanup", f"Invalid memory ID format: {test_memory_id}")
+    except Exception as e:
+        test_warn("Test cleanup", f"Cleanup failed: {e}")
 else:
     test_pass("Test cleanup", "No test memory to clean up")
 

hooks/sessionstart.py

@@ -109,6 +109,22 @@ def build_context_message(status: dict) -> str:
     return "\n".join(lines)
 
 
+def build_user_message(status: dict) -> str:
+    """Build a concise user-visible status message.
+
+    Args:
+        status: Memory system status dict.
+
+    Returns:
+        Short status message with emoji indicator.
+    """
+    if status.get("initialized"):
+        total = status.get("total_memories", 0)
+        return f"📚 Memory system: {total} memories indexed"
+    else:
+        return "📚 Memory system: not initialized"
+
+
 def main() -> None:
     """Main hook entry point."""
     # Read hook input from stdin (not used but must be consumed)
@@ -120,13 +136,15 @@ def main() -> None:
     # Get memory system status
     status = get_memory_status()
 
-    # Build context message
+    # Build context message (for Claude) and user message (visible)
     context_message = build_context_message(status)
+    user_message = build_user_message(status)
 
-    # Output the context injection
+    # Output the context injection with user-visible message
     output = {
         "continue": True,
         "additionalContext": context_message,
+        "message": user_message,
     }
 
     print(json.dumps(output))

hooks/userpromptsubmit.py

@@ -110,12 +110,14 @@ def main() -> None:
     # Capture the memory
     result = capture_memory(content)
 
-    # Output result (Claude Code will display any messages)
+    # Output result with visual indicator
     output = {"continue": True}
     if result.get("success"):
-        output["message"] = result.get("message", "Memory captured")
+        # Extract summary for display (first 50 chars of content)
+        summary = content[:50] + "..." if len(content) > 50 else content
+        output["message"] = f"💾 Captured to learnings: \"{summary}\""
     else:
-        output["warning"] = f"Failed to capture: {result.get('error', 'Unknown error')}"
+        output["warning"] = f"💾 Capture failed: {result.get('error', 'Unknown error')}"
 
     print(json.dumps(output))
 

src/git_notes_memory/hooks/post_tool_use_handler.py

@@ -230,7 +230,7 @@ def _format_memories_xml(
     return builder.to_string()
 
 
-def _write_output(context: str | None = None) -> None:
+def _write_output(context: str | None = None, memory_count: int = 0) -> None:
     """Write hook output to stdout.
 
     Args:
@@ -243,6 +243,9 @@ def _write_output(context: str | None = None) -> None:
                 "additionalContext": context,
             }
         }
+        # Add user-visible message when memories are found
+        if memory_count > 0:
+            output["message"] = f"🔍 Found {memory_count} related memories"
     else:
         output = {"continue": True}
 
@@ -329,8 +332,8 @@ def main() -> None:
         # Format as XML
         context = _format_memories_xml(results, file_path)
 
-        # Output result
-        _write_output(context)
+        # Output result with memory count for user message
+        _write_output(context, memory_count=len(results))
 
     except json.JSONDecodeError as e:
         logger.error("Failed to parse hook input: %s", e)

src/git_notes_memory/hooks/session_start_handler.py

@@ -34,11 +34,12 @@
 import sys
 from typing import Any
 
-from git_notes_memory.config import HOOK_SESSION_START_TIMEOUT
+from git_notes_memory.config import HOOK_SESSION_START_TIMEOUT, get_index_path
 from git_notes_memory.hooks.config_loader import load_hook_config
 from git_notes_memory.hooks.context_builder import ContextBuilder
 from git_notes_memory.hooks.guidance_builder import GuidanceBuilder
 from git_notes_memory.hooks.project_detector import detect_project
+from git_notes_memory.index import IndexService
 
 __all__ = ["main"]
 
@@ -117,18 +118,43 @@ def _validate_input(data: dict[str, Any]) -> bool:
     return all(field in data and data[field] for field in required_fields)
 
 
-def _write_output(context: str) -> None:
+def _get_memory_count() -> int:
+    """Get total memory count from index.
+
+    Returns:
+        Number of memories indexed, or 0 if index doesn't exist.
+    """
+    try:
+        index_path = get_index_path()
+        if not index_path.exists():
+            return 0
+        index = IndexService(index_path)
+        index.initialize()
+        stats = index.get_stats()
+        index.close()
+        return stats.total_memories
+    except Exception:
+        return 0
+
+
+def _write_output(context: str, memory_count: int = 0) -> None:
     """Write hook output to stdout.
 
     Args:
         context: XML context string to inject.
+        memory_count: Number of memories in the system.
     """
-    output = {
+    output: dict[str, Any] = {
         "hookSpecificOutput": {
             "hookEventName": "SessionStart",
             "additionalContext": context,
         }
     }
+    # Add user-visible status message
+    if memory_count > 0:
+        output["message"] = f"📚 Memory system: {memory_count} memories indexed"
+    else:
+        output["message"] = "📚 Memory system: initialized"
     print(json.dumps(output))
 
 
@@ -214,8 +240,11 @@ def main() -> None:
 
         logger.debug("Total context (%d chars)", len(full_context))
 
-        # Output result
-        _write_output(full_context)
+        # Get memory count for status message
+        memory_count = _get_memory_count()
+
+        # Output result with memory count
+        _write_output(full_context, memory_count=memory_count)
 
     except json.JSONDecodeError as e:
         logger.error("Failed to parse hook input: %s", e)

src/git_notes_memory/hooks/stop_handler.py

@@ -256,7 +256,7 @@ def _write_output(
 
         # Add a message about uncaptured content
         output["message"] = (
-            f"Found {len(uncaptured)} potentially uncaptured memory(s) "
+            f"🛑 Found {len(uncaptured)} potentially uncaptured memory(s) "
             "from this session. Consider using /remember to capture them."
         )
 
@@ -267,7 +267,7 @@ def _write_output(
             hook_output["syncStats"] = stats
             indexed = stats.get("indexed", 0)
             if indexed > 0:
-                sync_msg = f"Index synced: {indexed} memories indexed"
+                sync_msg = f"📚 Index synced: {indexed} memories indexed"
                 if "message" in output:
                     output["message"] += f"\n{sync_msg}"
                 else:

src/git_notes_memory/hooks/user_prompt_handler.py

@@ -258,7 +258,7 @@ def _write_output(
         # Report captured memories
         successful = [c for c in captured if c.get("success")]
         if successful:
-            output["message"] = f"Captured {len(successful)} memory(s) automatically"
+            output["message"] = f"💾 Captured {len(successful)} memory(s) automatically"
             output["hookSpecificOutput"] = {
                 "hookEventName": "UserPromptSubmit",
                 "capturedMemories": captured,