fix(commands): update status command to use correct git notes syntax

- Change 'git notes --list' to 'git notes list'
- Use actual API methods from IndexService and config
- Add memory capture reminder sections to all commands
- Update Python snippets to use uv run

Author: zircote

commands/capture.md

@@ -1,6 +1,6 @@
 ---
-description: Capture a memory (decision, learning, context, preference, or pattern) to the git-backed memory system
-argument-hint: "[type] content to capture"
+description: Capture a memory (decision, learning, blocker, progress, etc.) to the git-backed memory system
+argument-hint: "[namespace] <summary> -- <content>"
 allowed-tools: ["Bash", "Write", "Read", "AskUserQuestion"]
 ---
 
@@ -17,83 +17,122 @@ You will help the user capture a memory. The memory will be stored as a git note
 **Arguments format**: `$ARGUMENTS`
 
 Parse the arguments:
-1. If first word is a known type (`decision`, `learning`, `context`, `preference`, `pattern`), use it as the memory type
-2. Everything else is the memory content
-3. If no type specified, auto-detect based on content patterns:
-   - Contains "decided", "chose", "will use" → `decision`
-   - Contains "learned", "discovered", "TIL", "found out" → `learning`
-   - Contains "remember", "note that", "keep in mind" → `context`
-   - Contains "prefer", "always", "never", "should" → `preference`
-   - Contains "pattern", "recurring", "often" → `pattern`
-   - Default → `context`
+1. If first word matches a known namespace, use it as the namespace
+2. Look for `--` separator: text before is summary, text after is content
+3. If no `--` separator, use the entire text as both summary (truncated) and content
+
+**Valid namespaces**: `decisions`, `learnings`, `blockers`, `progress`, `reviews`, `patterns`, `retrospective`, `inception`, `elicitation`, `research`
+
+If no namespace specified, auto-detect based on content patterns:
+- Contains "decided", "chose", "will use" → `decisions`
+- Contains "learned", "discovered", "TIL", "found out" → `learnings`
+- Contains "blocked", "stuck", "cannot", "impediment" → `blockers`
+- Contains "completed", "finished", "milestone" → `progress`
+- Contains "pattern", "recurring", "often" → `patterns`
+- Default → `learnings`
 
 ### Step 2: Validate Content
 
 If `$ARGUMENTS` is empty or very short (< 10 characters):
 - Use AskUserQuestion to prompt for the memory content
 - Question: "What would you like to capture?"
-- Options: provide example prompts for each memory type
+- Provide examples for each memory type
 
 ### Step 3: Capture the Memory
 
 Use Bash to invoke the Python library:
 
 ```bash
-python3 -c "
+uv run python3 -c "
 from git_notes_memory import get_capture_service
 
 capture = get_capture_service()
-memory = capture.capture_$TYPE(
+result = capture.capture(
+    namespace='$NAMESPACE',
+    summary='''$SUMMARY''',
     content='''$CONTENT''',
-    source='command',
 )
-print(f'✅ Captured as {memory.namespace}: {memory.id[:8]}...')
-print(f'   Summary: {memory.title or memory.content[:60]}...')
+
+if result.success:
+    print(f'Captured as {result.memory.namespace}: {result.memory.id[:16]}...')
+    print(f'Summary: {result.memory.summary}')
+    if result.warning:
+        print(f'Warning: {result.warning}')
+else:
+    print(f'Capture failed')
 "
 ```
 
 Replace:
-- `$TYPE` with the memory type method: `capture_decision`, `capture_learning`, `capture_context`, `capture_preference`, `capture_pattern`
-- `$CONTENT` with the user's content (escape quotes properly)
+- `$NAMESPACE` with the detected namespace
+- `$SUMMARY` with a one-line summary (max 100 chars, escape quotes)
+- `$CONTENT` with the full content (escape quotes)
 
 ### Step 4: Confirm to User
 
 Show the result:
 ```
-✅ Memory captured!
+Memory captured!
 
-**Type**: decision
-**ID**: abc12345...
+**Namespace**: decisions
+**ID**: decisions:abc123:0
 **Summary**: Use PostgreSQL for the main database...
 
 This memory will be available for recall in future sessions.
 Use `/memory:recall` to retrieve it.
 ```
 
-## Memory Types Reference
-
-| Type | Use For | Example |
-|------|---------|---------|
-| `decision` | Architectural or design decisions | "Use PostgreSQL for JSONB support" |
-| `learning` | New knowledge or discoveries | "pytest fixtures can be module-scoped" |
-| `context` | Project-specific information | "This project uses tabs for indentation" |
-| `preference` | User preferences | "Prefer functional style over classes" |
-| `pattern` | Recurring patterns | "Error handling follows Result pattern" |
+## Namespace Reference
+
+| Namespace | Use For | Example |
+|-----------|---------|---------|
+| `decisions` | Architectural or design decisions | "Use PostgreSQL for JSONB support" |
+| `learnings` | New knowledge or discoveries | "pytest fixtures can be module-scoped" |
+| `blockers` | Obstacles and impediments | "API rate limiting blocking progress" |
+| `progress` | Milestones and completions | "Completed Phase 1 implementation" |
+| `reviews` | Code review findings | "Found SQL injection in auth module" |
+| `patterns` | Recurring patterns | "Error handling follows Result pattern" |
+| `retrospective` | Post-mortems and retrospectives | "Project completed successfully" |
+| `inception` | Problem statements and scope | "Building a memory plugin for Claude" |
+| `elicitation` | Requirements clarifications | "Must support offline mode" |
+| `research` | External findings | "Evaluated 3 embedding models" |
+
+## Convenience Methods
+
+For structured captures, the library also provides:
+- `capture_decision(spec, summary, context, rationale, alternatives)` - Decisions with rationale
+- `capture_blocker(spec, summary, description, impact)` - Blockers with impact
+- `capture_learning(summary, insight, context)` - Learnings with context
+- `capture_progress(spec, summary, milestone, details)` - Progress updates
+- `capture_pattern(summary, pattern_type, evidence, confidence)` - Patterns
+- `capture_review(spec, summary, findings, verdict)` - Code reviews
 
 ## Error Handling
 
 If the capture fails:
 1. Check if we're in a git repository: `git rev-parse --git-dir`
-2. Check if the library is installed: `python3 -c "import git_notes_memory"`
+2. Check if the library is installed: `uv run python3 -c "import git_notes_memory"`
 3. Show helpful error message with recovery action
 
 ## Examples
 
-**User**: `/memory:capture decision Use Redis for session storage due to built-in expiration`
-**Action**: Capture as decision type
+**User**: `/memory:capture decisions Use Redis for session storage -- Due to built-in expiration and cluster support`
+**Action**: Capture as decisions namespace with structured content
 
 **User**: `/memory:capture TIL you can use pytest -k to filter tests by name`
-**Action**: Auto-detect as learning (contains "TIL")
+**Action**: Auto-detect as learnings (contains "TIL"), content becomes both summary and body
 
 **User**: `/memory:capture This project requires Python 3.10+`
-**Action**: Auto-detect as context (general information)
+**Action**: Auto-detect as learnings (general information)
+
+## Memory Capture Reminder
+
+After successfully capturing a memory, remind the user:
+
+```
+💡 **Pro tip**: You can capture memories inline using markers:
+- `[remember] <insight>` - Captures a learning
+- `[capture] <decision>` - Captures any type of memory
+- `@memory <content>` - Same as [capture]
+
+These markers work anywhere in your message and are automatically processed.

commands/recall.md

@@ -17,7 +17,7 @@ You will help the user recall memories relevant to their current context or quer
 **Arguments format**: `$ARGUMENTS`
 
 Parse the arguments:
-1. Extract `--namespace=<ns>` if present (one of: `decisions`, `learnings`, `context`, `preferences`, `patterns`)
+1. Extract `--namespace=<ns>` if present (one of: `decisions`, `learnings`, `blockers`, `progress`, `reviews`, `patterns`, `retrospective`, `inception`, `elicitation`, `research`)
 2. Extract `--limit=<n>` if present (default: 5)
 3. Everything else is the search query
 4. If no query provided, use recent conversation context
@@ -34,31 +34,32 @@ If query is empty:
 Use Bash to invoke the Python library:
 
 ```bash
-python3 -c "
+uv run python3 -c "
 from git_notes_memory import get_recall_service
 
 recall = get_recall_service()
 results = recall.search(
     query='''$QUERY''',
     namespace=$NAMESPACE,  # None for all namespaces
-    limit=$LIMIT,
+    k=$LIMIT,
 )
 
 if not results:
     print('No relevant memories found.')
 else:
     print(f'## Recalled Memories ({len(results)} results)\n')
     for i, r in enumerate(results, 1):
-        print(f'### {i}. {r.namespace.title()}: {r.title or r.content[:50]}')
-        print(f'**Relevance**: {r.score:.2f} | **Captured**: {r.created_at[:10]}')
+        # Use summary (not title) and timestamp (not created_at)
+        print(f'### {i}. {r.namespace.title()}: {r.summary[:50]}')
+        print(f'**Relevance**: {r.score:.2f} | **Captured**: {r.timestamp.strftime(\"%Y-%m-%d\")}')
         print(f'> {r.content[:200]}...\n')
 "
 ```
 
 Replace:
 - `$QUERY` with the search query
 - `$NAMESPACE` with `'$ns'` or `None`
-- `$LIMIT` with the limit number
+- `$LIMIT` with the limit number (default 5)
 
 ### Step 4: Present Results
 
@@ -67,15 +68,15 @@ Format the output as:
 ```
 ## Recalled Memories (3 results)
 
-### 1. Decision: Use PostgreSQL for main database
+### 1. Decisions: Use PostgreSQL for main database
 **Relevance**: 0.92 | **Captured**: 2024-01-15
 > Due to JSONB support and strong ecosystem for Python...
 
-### 2. Learning: Connection pooling best practices
+### 2. Learnings: Connection pooling best practices
 **Relevance**: 0.85 | **Captured**: 2024-01-10
 > Always use connection pooling in production to prevent...
 
-### 3. Context: Database schema location
+### 3. Progress: Database schema completed
 **Relevance**: 0.78 | **Captured**: 2024-01-08
 > Database migrations are in migrations/ directory...
 ```
@@ -96,8 +97,9 @@ No relevant memories found for your query.
 |-----------|----------|
 | `decisions` | Architectural and design decisions |
 | `learnings` | Knowledge and discoveries |
-| `context` | Project-specific information |
-| `preferences` | User preferences and style |
+| `blockers` | Obstacles and impediments |
+| `progress` | Milestones and completions |
+| `reviews` | Code review findings |
 | `patterns` | Recurring patterns and idioms |
 
 ## Examples
@@ -113,3 +115,15 @@ No relevant memories found for your query.
 
 **User**: `/memory:recall`
 **Action**: Extract context from recent conversation and search
+
+## Memory Capture Reminder
+
+After showing recalled memories, if the conversation reveals new insights worth preserving, remind the user:
+
+```
+💡 **Capture tip**: If you discover something worth remembering, use:
+- `[remember] <insight>` - Inline capture of learnings
+- `/memory:capture <namespace> <content>` - Explicit capture with namespace
+```
+
+Consider whether the current context or findings should be captured for future recall.