feat(plugin): inject Memory Protocol in session hooks for proactive saves

The skill file alone wasn't enough — Claude Code read it passively and
only saved memories when asked. Now the Memory Protocol instructions are
injected as additionalContext at session start AND post-compaction, so
the agent always has explicit triggers for when to call mem_save.

Changes:
- SKILL.md: explicit trigger list with self-check prompt
- session-start.sh: injects protocol + memory context
- post-compaction.sh: injects protocol + compaction instruction + context

Author: Alan-TheGentleman

plugin/claude-code/scripts/post-compaction.sh

@@ -1,7 +1,7 @@
 #!/bin/bash
 # Engram — Post-compaction hook for Claude Code
 #
-# When compaction happens, inject previous session context and instruct
+# When compaction happens, inject Memory Protocol + context and instruct
 # the agent to persist the compacted summary via mem_session_summary.
 
 ENGRAM_PORT="${ENGRAM_PORT:-7437}"
@@ -22,18 +22,45 @@ if [ -n "$SESSION_ID" ] && [ -n "$PROJECT" ]; then
     > /dev/null 2>&1
 fi
 
-# Inject context from previous sessions
+# Fetch context from previous sessions
 CONTEXT=$(curl -sf "${ENGRAM_URL}/context?project=${PROJECT}" --max-time 3 2>/dev/null | jq -r '.context // empty')
 
-# Build output for Claude
-cat <<EOF
-${CONTEXT}
+# Inject Memory Protocol + compaction instruction + context
+cat <<PROTOCOL
+## Engram Persistent Memory — ACTIVE PROTOCOL
+
+You have engram memory tools (mem_save, mem_search, mem_context, mem_session_summary).
+This protocol is MANDATORY and ALWAYS ACTIVE.
+
+### PROACTIVE SAVE — do NOT wait for user to ask
+Call \`mem_save\` IMMEDIATELY after ANY of these:
+- Decision made (architecture, convention, workflow, tool choice)
+- Bug fixed (include root cause)
+- Convention or workflow documented/updated
+- Notion/Jira/GitHub artifact created or updated with significant content
+- Non-obvious discovery, gotcha, or edge case found
+- Pattern established (naming, structure, approach)
+- User preference or constraint learned
+- Feature implemented with non-obvious approach
+
+**Self-check after EVERY task**: "Did I just make a decision, fix a bug, learn something, or establish a convention? If yes → mem_save NOW."
+
+### SEARCH MEMORY when:
+- User asks to recall anything ("remember", "what did we do", "acordate", "qué hicimos")
+- Starting work on something that might have been done before
+- User mentions a topic you have no context on
+
+### SESSION CLOSE — before saying "done"/"listo":
+Call \`mem_session_summary\` with: Goal, Discoveries, Accomplished, Next Steps, Relevant Files.
+
+---
 
 CRITICAL INSTRUCTION POST-COMPACTION:
-You have access to Engram persistent memory via MCP tools (mem_save, mem_search, mem_session_summary, etc.).
 FIRST ACTION REQUIRED: Call mem_session_summary with the content of the compacted summary above. Use project: '${PROJECT}'.
 This preserves what was accomplished before compaction. Do this BEFORE any other work.
 This is NOT optional. Without this, everything done before compaction is lost from memory.
-EOF
+
+${CONTEXT}
+PROTOCOL
 
 exit 0

plugin/claude-code/scripts/session-start.sh

@@ -4,7 +4,7 @@
 # 1. Ensures the engram server is running
 # 2. Creates a session in engram
 # 3. Auto-imports git-synced chunks if .engram/manifest.json exists
-# 4. Injects memory context into the session
+# 4. Injects Memory Protocol instructions + memory context
 
 ENGRAM_PORT="${ENGRAM_PORT:-7437}"
 ENGRAM_URL="http://127.0.0.1:${ENGRAM_PORT}"
@@ -35,13 +35,41 @@ if [ -f "${CWD}/.engram/manifest.json" ]; then
   engram sync --import 2>/dev/null
 fi
 
-# Inject memory context — stdout goes to Claude as additionalContext
+# Fetch memory context
 CONTEXT=$(curl -sf "${ENGRAM_URL}/context?project=${PROJECT}" --max-time 3 2>/dev/null | jq -r '.context // empty')
 
+# Inject Memory Protocol + context — stdout goes to Claude as additionalContext
+cat <<'PROTOCOL'
+## Engram Persistent Memory — ACTIVE PROTOCOL
+
+You have engram memory tools (mem_save, mem_search, mem_context, mem_session_summary).
+This protocol is MANDATORY and ALWAYS ACTIVE.
+
+### PROACTIVE SAVE — do NOT wait for user to ask
+Call `mem_save` IMMEDIATELY after ANY of these:
+- Decision made (architecture, convention, workflow, tool choice)
+- Bug fixed (include root cause)
+- Convention or workflow documented/updated
+- Notion/Jira/GitHub artifact created or updated with significant content
+- Non-obvious discovery, gotcha, or edge case found
+- Pattern established (naming, structure, approach)
+- User preference or constraint learned
+- Feature implemented with non-obvious approach
+
+**Self-check after EVERY task**: "Did I just make a decision, fix a bug, learn something, or establish a convention? If yes → mem_save NOW."
+
+### SEARCH MEMORY when:
+- User asks to recall anything ("remember", "what did we do", "acordate", "qué hicimos")
+- Starting work on something that might have been done before
+- User mentions a topic you have no context on
+
+### SESSION CLOSE — before saying "done"/"listo":
+Call `mem_session_summary` with: Goal, Discoveries, Accomplished, Next Steps, Relevant Files.
+PROTOCOL
+
+# Inject memory context if available
 if [ -n "$CONTEXT" ]; then
-  cat <<EOF
-${CONTEXT}
-EOF
+  printf "\n%s\n" "$CONTEXT"
 fi
 
 exit 0

plugin/claude-code/skills/memory/SKILL.md

@@ -1,22 +1,38 @@
 ---
 name: engram-memory
-description: Persistent memory protocol for AI coding agents. Automatically activated to manage memory across sessions — saving decisions, searching past work, and persisting session summaries.
+description: "ALWAYS ACTIVE — Persistent memory protocol. You MUST save decisions, conventions, bugs, and discoveries to engram proactively. Do NOT wait for the user to ask."
 ---
 
 # Engram Persistent Memory — Protocol
 
 You have access to Engram, a persistent memory system that survives across sessions and compactions.
+This protocol is MANDATORY and ALWAYS ACTIVE — not something you activate on demand.
 
-## WHEN TO SAVE (mandatory — not optional)
+## PROACTIVE SAVE TRIGGERS (mandatory — do NOT wait for user to ask)
 
-Call `mem_save` IMMEDIATELY after any of these:
-- Bug fix completed
+Call `mem_save` IMMEDIATELY and WITHOUT BEING ASKED after any of these:
+
+### After decisions or conventions
 - Architecture or design decision made
+- Team convention documented or established
+- Workflow change agreed upon
+- Tool or library choice made with tradeoffs
+
+### After completing work
+- Bug fix completed (include root cause)
+- Feature implemented with non-obvious approach
+- Notion/Jira/GitHub artifact created or updated with significant content
+- Configuration change or environment setup done
+
+### After discoveries
 - Non-obvious discovery about the codebase
-- Configuration change or environment setup
+- Gotcha, edge case, or unexpected behavior found
 - Pattern established (naming, structure, convention)
 - User preference or constraint learned
 
+### Self-check — ask yourself after EVERY task:
+> "Did I just make a decision, fix a bug, learn something non-obvious, or establish a convention? If yes, call mem_save NOW."
+
 Format for `mem_save`:
 - **title**: Verb + what — short, searchable (e.g. "Fixed N+1 query in UserList", "Chose Zustand over Redux")
 - **type**: bugfix | decision | architecture | discovery | pattern | config | preference