@stackmemoryai/stackmemory 1.10.5 → 1.14.0

package/packs/core/commands/restart.md

@@ -0,0 +1,58 @@
+# /restart — Close session, clear context, and reboot
+
+Chain `/stop done` → `/clear` → `/start` in one command. Use when switching contexts or resetting after a long session.
+
+## Usage
+
+`$ARGUMENTS` — optional: `quick` (skip /learn, just capture + clear + start)
+
+## Execution
+
+### Phase 1: Stop (condensed)
+
+Run /stop logic with `done` mode:
+
+1. **Summary** — Review all actions, decisions, files changed (hold output)
+2. **Capture** — Run `stackmemory capture --no-commit`
+   - If uncommitted changes exist, ask: "Commit before restart? (y/n)"
+   - If yes: commit, re-capture
+3. **Learn** — Unless `quick` argument was passed:
+   - Audit memory, CLAUDE.md, skills for needed updates
+   - Apply non-controversial updates automatically
+   - Ask for confirmation on new memories or CLAUDE.md changes
+4. Output the stop summary (keep under 15 lines):
+
+```
+## Closing session
+
+**Done:** [1-3 bullet summary]
+**Captured:** [yes/no]
+**Updates:** [applied/none]
+```
+
+### Phase 2: Clear
+
+Tell the user: "Clearing context. Starting fresh session..."
+
+Then run `/clear` to reset the conversation context.
+
+### Phase 3: Start
+
+Run full /start logic:
+
+1. **Context Load** (parallel):
+   - Git state: branch, log, status, stash list
+   - Restore: `stackmemory restore --no-copy`
+   - Open PRs: `gh pr list --author @me --state open --limit 5`
+   - Memory: review MEMORY.md
+2. **Situational Awareness** — branch state, handoff, PRs, stashes
+3. **Output** — standard /start format with branch, commits, next steps
+
+## Rules
+
+- If /stop capture fails, warn but continue — don't block the restart
+- Never force-clear with uncommitted work — always ask first
+- If `quick` mode, skip /learn entirely (saves ~30s)
+- The /clear step resets conversation context — everything after is a fresh start
+- Total output: stop summary (15 lines) + start output (25 lines)
+- If any phase fails, continue to the next — report errors inline

package/packs/core/commands/restore.md

@@ -0,0 +1,29 @@
+# /restore — Restore session context via StackMemory
+
+Run `stackmemory restore` to load context from the last handoff and resume where you left off.
+
+## Usage
+
+`$ARGUMENTS` — optional flags passed directly to `stackmemory restore`.
+
+## Behavior
+
+1. Run `stackmemory restore $ARGUMENTS`
+2. Read the restored handoff prompt
+3. Use the restored context to understand current state: branch, in-progress work, blockers, next steps
+4. Run `stackmemory status` to confirm project state
+5. Summarize what was restored and suggest next actions
+
+## Common flags
+
+| Flag | Effect |
+|------|--------|
+| `--no-copy` | Don't copy prompt to clipboard |
+| `--force` | Restore even if branch doesn't match |
+
+## Examples
+
+```
+/restore              # Restore last handoff
+/restore --force      # Restore even on different branch
+```

package/packs/core/commands/start.md

@@ -0,0 +1,57 @@
+# /start — Boot a session with full context
+
+Load memory, restore last handoff, review recent history, and suggest what to work on.
+
+## Execution
+
+Run all phases. Keep output tight — the user wants to start working, not read a report.
+
+### Phase 1: Context Load (parallel)
+
+1. **Memory** — Read `MEMORY.md` from project memory dir (already in context, just review)
+2. **Git state** — Run in parallel:
+   - `git branch --show-current`
+   - `git log --oneline -10`
+   - `git status`
+   - `git stash list`
+3. **Restore** — Run `stackmemory restore --no-copy` to load last handoff
+4. **Open PRs** — `/opt/homebrew/bin/gh pr list --author @me --state open --limit 5 --json number,title,headRefName,reviews,statusCheckRollup 2>/dev/null`
+
+### Phase 2: Situational Awareness
+
+From the gathered context, determine:
+
+- **Current branch** and whether it has uncommitted work
+- **Last session's state** from the handoff (in-progress work, blockers, next steps)
+- **Open PRs** and their CI/review status
+- **Any stashes** that might be forgotten work
+
+### Phase 3: Output
+
+```
+## Session Start
+
+**Branch:** [branch] [clean|dirty]
+**Last session:** [1-line summary from handoff]
+**Open PRs:** [count] — [brief status of each]
+
+**Recent commits:**
+- [last 3-5 relevant commits, 1 line each]
+
+**Restored context:**
+- [key items from handoff: active work, blockers, decisions]
+
+## What's next
+
+A) [Primary — continue from handoff / fix CI / address review]
+B) [Alternative]
+C) [Something else]
+```
+
+## Rules
+
+- Total output under 25 lines
+- Don't re-read files already in context (CLAUDE.md, MEMORY.md)
+- If restore fails (no handoff), skip gracefully — still show git state + suggest /next
+- If on main with clean state and no handoff, just run /next logic directly
+- Never block on a failed command — report and continue

package/packs/core/commands/stop.md

@@ -0,0 +1,65 @@
+# /stop — End a session cleanly
+
+Run /summary → /capture → /learn, then either /compact or clear based on whether work remains.
+
+## Usage
+
+`$ARGUMENTS` — optional: `done` (session complete, clear context) or omit (default: compact for continuation)
+
+## Execution
+
+### Phase 1: Summary (silent)
+
+Run /summary logic internally — review all actions, decisions, files changed. Hold the output for Phase 3.
+
+### Phase 2: Capture
+
+1. Run `stackmemory capture --no-commit` to generate handoff
+2. If there are uncommitted changes, ask: "Commit before closing? (y/n)"
+   - If yes: commit with auto-generated message, then re-run capture
+
+### Phase 3: Learn
+
+Run /learn logic — audit memory, CLAUDE.md, skills, scripts for needed updates.
+
+Output the combined summary + learnings report:
+
+```
+## Session Close
+
+**What was done:**
+- [actions from summary]
+
+**Captured:** [handoff saved / failed]
+
+**Updates needed:**
+| Target | Action | Detail |
+|--------|--------|--------|
+| ... | ... | ... |
+
+**Updates applied:** [list] or "none needed"
+```
+
+Apply any non-controversial updates automatically (stale memory cleanup, factual corrections). Ask for confirmation on new memories or CLAUDE.md changes.
+
+### Phase 4: Close
+
+Determine session state:
+
+**If `done` argument OR no open work remaining:**
+- All tasks complete, no blockers, clean branch
+- Output: "Session complete. Clearing context."
+- Clear conversation (suggest user run /clear)
+
+**If work remains (default):**
+- Open tasks, uncommitted changes, or active blockers
+- Run /compact to preserve context for continuation
+- Output: "Compacted. Resume with /start"
+
+## Rules
+
+- Total output under 30 lines (excluding the updates table)
+- If /learn finds nothing to update, skip the table — just say "Nothing to update"
+- If capture fails, warn but continue — don't block the close
+- Commit confirmation only if there are actual uncommitted changes
+- Never force-clear if there's uncommitted work — always warn first

package/packs/core/commands/summary.md

@@ -0,0 +1,40 @@
+# /summary — Summarize what was accomplished this session
+
+Generate a concise summary of work done in the current conversation.
+
+## Execution
+
+1. Review the conversation history for all actions taken
+2. Group by topic/theme if multiple things were done
+3. Output in this format:
+
+## Format
+
+```
+## Session Summary
+
+**What was done:**
+- [action 1]
+- [action 2]
+- ...
+
+**Files changed:**
+- [file path] — [what changed]
+
+**Decisions made:**
+- [decision and rationale]
+
+**Status:** [complete | in-progress | blocked]
+
+**Next steps:**
+- [follow-up if any]
+```
+
+## Rules
+
+- Keep it short — one line per item
+- Focus on outcomes, not process
+- Include file paths for any created/modified files
+- Note any new commands, tools, or integrations set up
+- If commits were made, list them
+- Skip filler — no "I helped the user..." framing

package/packs/core/manifest.json

@@ -0,0 +1,24 @@
+{
+  "name": "core",
+  "version": "1.0.0",
+  "description": "Session lifecycle commands for Claude Code — start, stop, restart, and next",
+  "requires": "stackmemory >= 1.10.0",
+  "commands": {
+    "public": [
+      { "file": "commands/start.md", "name": "start", "description": "Boot a session with full context" },
+      { "file": "commands/stop.md", "name": "stop", "description": "End a session cleanly" },
+      { "file": "commands/restart.md", "name": "restart", "description": "Close session, clear context, and reboot" },
+      { "file": "commands/next.md", "name": "next", "description": "What should I do next?" }
+    ],
+    "internal": [
+      { "file": "commands/summary.md", "name": "summary", "description": "Summarize session work (used by /stop)" },
+      { "file": "commands/capture.md", "name": "capture", "description": "Save context via StackMemory (used by /stop)" },
+      { "file": "commands/learn.md", "name": "learn", "description": "Review session and update memory (used by /stop)" },
+      { "file": "commands/restore.md", "name": "restore", "description": "Restore from last handoff (used by /start)" }
+    ]
+  },
+  "install": {
+    "target": "~/.claude/commands",
+    "method": "symlink"
+  }
+}

package/packs/ops/decision-recovery/instructions.md

@@ -0,0 +1,65 @@
+# ops/decision-recovery
+
+## Purpose
+
+Track decisions, recover context, and hand off work between sessions. This pack ensures nothing is lost when an agent session ends, a human picks up work, or context needs to be recovered after a failure.
+
+## Decision Tracking
+
+Every significant decision should be logged with:
+
+1. **The decision itself** — what was chosen
+2. **Rationale** — why (the most important part)
+3. **Alternatives considered** — what else was evaluated
+4. **Confidence level** — how certain (0-1 scale)
+
+### When to log decisions
+
+- Architecture choices (database, framework, protocol)
+- Trade-off resolutions (speed vs. correctness, scope vs. timeline)
+- Integration selections (which tool, which API)
+- Rejection decisions (what was explicitly *not* done, and why)
+- Policy choices (error handling strategy, naming conventions)
+
+### Decision supersession
+
+When a decision is reversed or updated, log the new decision with a reference to the old one. Don't delete old decisions — they provide valuable context about what was tried and why it didn't work.
+
+## Context Recovery
+
+When starting a new session or recovering from a failure:
+
+1. **Check the last handoff** — what was the previous session working on?
+2. **Review recent decisions** — what constraints are in place?
+3. **Check for blockers** — what's preventing progress?
+4. **Review git state** — uncommitted work, open PRs, branch state
+
+### Recovery priority order
+
+1. Uncommitted changes → commit or stash
+2. Open blockers → address or escalate
+3. Failed CI → fix before continuing
+4. In-progress work → resume from handoff
+5. Next task → pick from queue
+
+## Session Handoff
+
+At the end of every session, create a structured handoff:
+
+- **Summary** — 1-3 sentences on what was accomplished
+- **Key decisions** — decisions made during the session
+- **Blockers** — anything that's preventing progress
+- **Next steps** — concrete, actionable items for the next session
+- **Open questions** — things that need human input
+
+### Handoff format
+
+Keep handoffs concise. The next agent or human should be able to resume in < 2 minutes by reading the handoff.
+
+## Anti-Patterns
+
+- Starting work without checking the last handoff → duplicate work
+- Making decisions without logging rationale → lost context
+- Ending a session without a handoff → cold start next time
+- Logging implementation details as decisions → noise
+- Deleting or overwriting old decisions → lost history

package/packs/ops/decision-recovery/pack.yaml

@@ -0,0 +1,89 @@
+name: ops/decision-recovery
+version: 1.0.0
+description: Decision tracking, context recovery, and session handoff patterns for agent workflows
+author: stackmemory
+license: MIT
+runtime:
+  type: local
+ingestion:
+  sources:
+    - linear
+    - github
+  scope: decisions-and-anchors
+ontology:
+  entities:
+    - decision
+    - anchor
+    - blocker
+    - handoff
+    - session
+  relations:
+    - supersedes
+    - blocks
+    - resolves
+    - continues
+mcp:
+  tools:
+    - name: log_decision
+      description: Record a decision with rationale, alternatives considered, and confidence level
+      inputSchema:
+        type: object
+        properties:
+          decision:
+            type: string
+            description: The decision made
+          rationale:
+            type: string
+            description: Why this was chosen
+          alternatives:
+            type: array
+            items:
+              type: string
+            description: Alternatives that were considered
+          confidence:
+            type: number
+            description: Confidence level (0-1)
+        required:
+          - decision
+          - rationale
+    - name: recover_context
+      description: Retrieve decisions, anchors, and blockers from the current or recent sessions
+      inputSchema:
+        type: object
+        properties:
+          scope:
+            type: string
+            enum:
+              - current
+              - recent
+              - all
+            description: How far back to look
+          filter:
+            type: string
+            description: Optional keyword filter
+    - name: create_handoff
+      description: Create a structured session handoff for the next agent or human
+      inputSchema:
+        type: object
+        properties:
+          summary:
+            type: string
+            description: What was accomplished
+          blockers:
+            type: array
+            items:
+              type: string
+            description: Open blockers
+          next_steps:
+            type: array
+            items:
+              type: string
+            description: Suggested next actions
+        required:
+          - summary
+examples:
+  - input: "We decided to use SQLite instead of Postgres for the local store"
+    output: "log_decision({ decision: 'Use SQLite for local store', rationale: 'Zero-config, file-based, FTS5 built-in, no server process', alternatives: ['Postgres', 'Dolt'], confidence: 0.9 })"
+  - input: "What decisions were made in the last session?"
+    output: "recover_context({ scope: 'recent', filter: 'decision' })"
+instructions: instructions.md

package/scripts/claude-code-wrapper.sh

@@ -3,6 +3,17 @@
 # Claude Code wrapper with StackMemory integration
 # Usage: Add alias to ~/.zshrc: alias claude='~/Dev/stackmemory/scripts/claude-code-wrapper.sh'
 
+# Use Node version from .nvmrc
+export NVM_DIR="$HOME/.nvm"
+if [ -s "$NVM_DIR/nvm.sh" ]; then
+  . "$NVM_DIR/nvm.sh"
+  nvm use 2>/dev/null
+elif [ -d "$HOME/.nvm/versions/node" ]; then
+  NODE_VER=$(cat "$(dirname "$0")/../.nvmrc" 2>/dev/null || echo "20")
+  NODE_PATH=$(ls -d "$HOME/.nvm/versions/node/v${NODE_VER}"* 2>/dev/null | head -1)
+  [ -n "$NODE_PATH" ] && export PATH="$NODE_PATH/bin:$PATH"
+fi
+
 # Check for auto-sync flag and filter wrapper-specific args
 AUTO_SYNC=false
 SYNC_INTERVAL=5

package/scripts/claude-sm-setup.sh

@@ -5,6 +5,17 @@
 
 set -e
 
+# Use Node version from .nvmrc
+export NVM_DIR="$HOME/.nvm"
+if [ -s "$NVM_DIR/nvm.sh" ]; then
+  . "$NVM_DIR/nvm.sh"
+  nvm use 2>/dev/null
+elif [ -d "$HOME/.nvm/versions/node" ]; then
+  NODE_VER=$(cat "$(git rev-parse --show-toplevel)/.nvmrc" 2>/dev/null || echo "20")
+  NODE_PATH=$(ls -d "$HOME/.nvm/versions/node/v${NODE_VER}"* 2>/dev/null | head -1)
+  [ -n "$NODE_PATH" ] && export PATH="$NODE_PATH/bin:$PATH"
+fi
+
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 PROJECT_ROOT="$(dirname "$SCRIPT_DIR")"
 CLAUDE_CONFIG_DIR="${HOME}/.claude"
@@ -364,4 +375,4 @@ main() {
 }
 
 # Run main
-main "$@"
+main "$@"

package/scripts/codex-wrapper.sh

@@ -3,6 +3,17 @@
 # Codex CLI wrapper with StackMemory integration
 # Usage: Add alias to your shell: alias codex-sm='~/Dev/stackmemory/scripts/codex-wrapper.sh'
 
+# Use Node version from .nvmrc
+export NVM_DIR="$HOME/.nvm"
+if [ -s "$NVM_DIR/nvm.sh" ]; then
+  . "$NVM_DIR/nvm.sh"
+  nvm use 2>/dev/null
+elif [ -d "$HOME/.nvm/versions/node" ]; then
+  NODE_VER=$(cat "$(dirname "$0")/../.nvmrc" 2>/dev/null || echo "20")
+  NODE_PATH=$(ls -d "$HOME/.nvm/versions/node/v${NODE_VER}"* 2>/dev/null | head -1)
+  [ -n "$NODE_PATH" ] && export PATH="$NODE_PATH/bin:$PATH"
+fi
+
 # Check for auto-sync flag
 AUTO_SYNC=false
 SYNC_INTERVAL=5

package/scripts/git-hooks/branch-context-manager.sh

@@ -4,6 +4,17 @@
 
 set -e
 
+# Use Node version from .nvmrc
+export NVM_DIR="$HOME/.nvm"
+if [ -s "$NVM_DIR/nvm.sh" ]; then
+  . "$NVM_DIR/nvm.sh"
+  nvm use 2>/dev/null
+elif [ -d "$HOME/.nvm/versions/node" ]; then
+  NODE_VER=$(cat "$(git rev-parse --show-toplevel)/.nvmrc" 2>/dev/null || echo "20")
+  NODE_PATH=$(ls -d "$HOME/.nvm/versions/node/v${NODE_VER}"* 2>/dev/null | head -1)
+  [ -n "$NODE_PATH" ] && export PATH="$NODE_PATH/bin:$PATH"
+fi
+
 # Colors for output
 RED='\033[0;31m'
 GREEN='\033[0;32m'

package/scripts/git-hooks/post-checkout-stackmemory.sh

@@ -4,6 +4,17 @@
 
 set -e
 
+# Use Node version from .nvmrc
+export NVM_DIR="$HOME/.nvm"
+if [ -s "$NVM_DIR/nvm.sh" ]; then
+  . "$NVM_DIR/nvm.sh"
+  nvm use 2>/dev/null
+elif [ -d "$HOME/.nvm/versions/node" ]; then
+  NODE_VER=$(cat "$(git rev-parse --show-toplevel)/.nvmrc" 2>/dev/null || echo "20")
+  NODE_PATH=$(ls -d "$HOME/.nvm/versions/node/v${NODE_VER}"* 2>/dev/null | head -1)
+  [ -n "$NODE_PATH" ] && export PATH="$NODE_PATH/bin:$PATH"
+fi
+
 # Hook parameters from git
 prev_head="$1"
 new_head="$2"

package/scripts/git-hooks/post-commit-stackmemory.sh

@@ -4,6 +4,17 @@
 
 set -e
 
+# Use Node version from .nvmrc
+export NVM_DIR="$HOME/.nvm"
+if [ -s "$NVM_DIR/nvm.sh" ]; then
+  . "$NVM_DIR/nvm.sh"
+  nvm use 2>/dev/null
+elif [ -d "$HOME/.nvm/versions/node" ]; then
+  NODE_VER=$(cat "$(git rev-parse --show-toplevel)/.nvmrc" 2>/dev/null || echo "20")
+  NODE_PATH=$(ls -d "$HOME/.nvm/versions/node/v${NODE_VER}"* 2>/dev/null | head -1)
+  [ -n "$NODE_PATH" ] && export PATH="$NODE_PATH/bin:$PATH"
+fi
+
 # Colors for output
 RED='\033[0;31m'
 GREEN='\033[0;32m'

package/scripts/git-hooks/pre-commit-stackmemory.sh

@@ -4,6 +4,17 @@
 
 set -e
 
+# Use Node version from .nvmrc
+export NVM_DIR="$HOME/.nvm"
+if [ -s "$NVM_DIR/nvm.sh" ]; then
+  . "$NVM_DIR/nvm.sh"
+  nvm use 2>/dev/null
+elif [ -d "$HOME/.nvm/versions/node" ]; then
+  NODE_VER=$(cat "$(git rev-parse --show-toplevel)/.nvmrc" 2>/dev/null || echo "20")
+  NODE_PATH=$(ls -d "$HOME/.nvm/versions/node/v${NODE_VER}"* 2>/dev/null | head -1)
+  [ -n "$NODE_PATH" ] && export PATH="$NODE_PATH/bin:$PATH"
+fi
+
 # Colors for output
 RED='\033[0;31m'
 GREEN='\033[0;32m'

package/scripts/hooks/cleanup-shell.sh

@@ -1,5 +1,16 @@
 #!/bin/bash
 
+# Use Node version from .nvmrc
+export NVM_DIR="$HOME/.nvm"
+if [ -s "$NVM_DIR/nvm.sh" ]; then
+  . "$NVM_DIR/nvm.sh"
+  nvm use 2>/dev/null
+elif [ -d "$HOME/.nvm/versions/node" ]; then
+  NODE_VER=$(cat "$(git rev-parse --show-toplevel)/.nvmrc" 2>/dev/null || echo "20")
+  NODE_PATH=$(ls -d "$HOME/.nvm/versions/node/v${NODE_VER}"* 2>/dev/null | head -1)
+  [ -n "$NODE_PATH" ] && export PATH="$NODE_PATH/bin:$PATH"
+fi
+
 # Script to clean up and consolidate StackMemory shell configurations
 
 echo "🧹 Cleaning up shell configurations..."
@@ -127,4 +138,4 @@ if [[ "$response" == "y" || "$response" == "Y" ]]; then
     echo "   source ~/.bash_profile  (for bash)"
 else
     echo "Manual cleanup required. Please edit your shell configs."
-fi
+fi

package/scripts/hooks/task-complete.sh

@@ -1,5 +1,16 @@
 #!/bin/bash
 
+# Use Node version from .nvmrc
+export NVM_DIR="$HOME/.nvm"
+if [ -s "$NVM_DIR/nvm.sh" ]; then
+  . "$NVM_DIR/nvm.sh"
+  nvm use 2>/dev/null
+elif [ -d "$HOME/.nvm/versions/node" ]; then
+  NODE_VER=$(cat "$(git rev-parse --show-toplevel)/.nvmrc" 2>/dev/null || echo "20")
+  NODE_PATH=$(ls -d "$HOME/.nvm/versions/node/v${NODE_VER}"* 2>/dev/null | head -1)
+  [ -n "$NODE_PATH" ] && export PATH="$NODE_PATH/bin:$PATH"
+fi
+
 # Task Completion Hook for StackMemory
 # Integrates with Linear to prompt for next task when current task is completed
 
@@ -111,4 +122,4 @@ main() {
     esac
 }
 
-main "$@"
+main "$@"

package/scripts/install-code-execution-hooks.sh

@@ -4,6 +4,17 @@
 
 set -e
 
+# Use Node version from .nvmrc
+export NVM_DIR="$HOME/.nvm"
+if [ -s "$NVM_DIR/nvm.sh" ]; then
+  . "$NVM_DIR/nvm.sh"
+  nvm use 2>/dev/null
+elif [ -d "$HOME/.nvm/versions/node" ]; then
+  NODE_VER=$(cat "$(git rev-parse --show-toplevel)/.nvmrc" 2>/dev/null || echo "20")
+  NODE_PATH=$(ls -d "$HOME/.nvm/versions/node/v${NODE_VER}"* 2>/dev/null | head -1)
+  [ -n "$NODE_PATH" ] && export PATH="$NODE_PATH/bin:$PATH"
+fi
+
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 PROJECT_ROOT="$(dirname "$SCRIPT_DIR")"
 CLAUDE_HOOKS_DIR="$HOME/.claude/hooks"
@@ -93,4 +104,4 @@ echo ""
 echo "The code_only mode creates a restricted environment similar to"
 echo "execute_code_py, where Claude can only perform computations."
 echo ""
-echo "✨ Ready to use with Claude Code!"
+echo "✨ Ready to use with Claude Code!"

package/scripts/install-sweep-hook.sh

@@ -3,6 +3,17 @@
 
 set -e
 
+# Use Node version from .nvmrc
+export NVM_DIR="$HOME/.nvm"
+if [ -s "$NVM_DIR/nvm.sh" ]; then
+  . "$NVM_DIR/nvm.sh"
+  nvm use 2>/dev/null
+elif [ -d "$HOME/.nvm/versions/node" ]; then
+  NODE_VER=$(cat "$(git rev-parse --show-toplevel)/.nvmrc" 2>/dev/null || echo "20")
+  NODE_PATH=$(ls -d "$HOME/.nvm/versions/node/v${NODE_VER}"* 2>/dev/null | head -1)
+  [ -n "$NODE_PATH" ] && export PATH="$NODE_PATH/bin:$PATH"
+fi
+
 HOOK_DIR="$HOME/.claude/hooks"
 SWEEP_DIR="$HOME/.stackmemory/sweep"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
@@ -87,3 +98,4 @@ echo "  - Check status: node $HOOK_DIR/post-edit-sweep.js --status"
 echo "  - Clear state: node $HOOK_DIR/post-edit-sweep.js --clear"
 echo "  - Disable: export SWEEP_ENABLED=false"
 echo ""
+