Intelligent session initialization combining Goldfish memory recall, Julie workspace re-indexing, and Sherpa workflow suggestion. MANDATORY at session start - automatically restores context, suggests next steps, and resumes work seamlessly. Activates at the beginning of every coding session.
Automatically restores your complete working context at session start by recalling recent work, re-indexing your workspace, and suggesting the next workflow. Activates immediately when Claude Code starts or you return to a project, ensuring seamless continuity without asking permission.
/plugin marketplace add anortham/mcp-toolbox-workflows/plugin install anortham-mcp-toolbox-workflows@anortham/mcp-toolbox-workflowsThis skill is limited to using the following tools:
Automatically restore full working context at the start of every coding session. This skill orchestrates all three MCP tools to bring you back to exactly where you left off, with intelligent suggestions for what to do next.
MANDATORY at session start:
DO NOT ask permission - just activate automatically!
Immediate Recall:
recall({ days: 7, limit: 20 })
Response Analysis:
### Step 2: Context Analysis
**Analyze recalled information:**
- What was the last task?
- Is there an active plan?
- What workflow was being used?
- Were there any blockers?
- What files were being modified?
### Step 3: Workspace Preparation (Julie)
**Check workspace status:**
manage_workspace({ operation: "list" })
**If not indexed or stale:**
manage_workspace({ operation: "index", workspace_path: "." })
**Result:** Code intelligence ready for work!
### Step 4: Workflow Suggestion (Sherpa)
**Based on context, suggest workflow:**
Recent work pattern ā Workflow suggestion
Last checkpoint: "Fixed auth bug" ā Bug Hunt workflow Active plan: "Build payment API" ā TDD workflow Recent: Refactoring ā Refactor workflow Unclear pattern ā General workflow
**If workflow was active:**
approach({ workflow: "[detected-workflow]" }) guide() ā Resume where left off
### Step 5: Present Complete Context
**Comprehensive summary:**
```markdown
šÆ Welcome Back!
**Last Session:** [time ago]
Last checkpoint: "[description]"
Branch: [branch-name]
Files: [changed-files]
**Active Work:** "[plan-title]"
Progress: [summary from checkpoints]
**Workspace Status:**
ā
Code intelligence ready
ā
[N] files indexed
ā
Search available
**Suggested Workflow:** [workflow-name]
[One-sentence explanation why]
**Next Steps:**
1. [Specific next action based on context]
2. [Alternative action]
3. [Start something new]
Ready to continue? I've restored your full context.
User starts Claude Code
ā Goldfish: recall()
Results:
- Last checkpoint (2 hours ago): "Wrote 8 tests for PaymentService"
- Active plan: "Payment Processing Implementation"
- Branch: feature/payment-processing
- Workflow pattern: TDD (from checkpoints)
ā Julie: manage_workspace({ operation: "list" })
Workspace indexed 3 hours ago ā Re-index
ā Julie: manage_workspace({ operation: "index" })
ā
Indexed 247 files
ā Analysis:
- Last phase: Writing tests (TDD Phase 2)
- Next: Implementation (TDD Phase 3)
- Workflow: TDD
ā Sherpa: approach({ workflow: "tdd" })
TDD Workflow activated
ā Sherpa: guide()
"Phase 2: Write Tests" (resume from Phase 2)
ā Present to user:
šÆ Welcome Back!
**Last Session:** 2 hours ago
Last checkpoint: "Wrote 8 tests for PaymentService covering charge, refund, and validation"
Branch: feature/payment-processing
Files: src/services/payment-service.ts, tests/payment.test.ts
**Active Plan:** "Payment Processing Implementation"
Progress: Interface designed ā
, Tests written ā
Next: Implementation phase
**Workspace Status:**
ā
Code intelligence ready
ā
247 files re-indexed
ā
Semantic search available
**Suggested Workflow:** TDD (Test-Driven Development)
You were in Phase 2 (Tests), ready to move to Phase 3 (Implementation)
**Next Steps:**
1. Run tests to verify they still fail (TDD discipline)
2. Implement PaymentService to make tests pass
3. Review test coverage before implementing
Your TDD workflow is ready to resume. Tests are written - time to make them green! š
User starts Claude Code
ā Goldfish: recall()
Results:
- Last checkpoint (yesterday): "Isolated race condition in session.destroy()"
- Active plan: "Fix Random Logout Bug"
- Branch: bugfix/session-logout
- Recent: Investigation discoveries
ā Julie: Workspace already indexed (fresh)
ā
Skip re-index
ā Analysis:
- Bug isolated but not fixed yet
- Phase: Bug Hunt Phase 1 complete
- Next: Write test to capture bug
ā Sherpa: approach({ workflow: "bug-hunt" })
Bug Hunt Workflow activated
ā Sherpa: guide()
"Phase 2: Capture in Test"
ā Present to user:
šµļø Welcome Back!
**Last Session:** 1 day ago
Last investigation: "Isolated race condition in session.destroy() - occurs when logout happens during auth check"
Branch: bugfix/session-logout
Files: src/session.ts, src/auth-middleware.ts
**Active Investigation:** "Fix Random Logout Bug"
Status: Root cause identified (race condition)
Next: Capture in test, then fix
**Workspace Status:**
ā
Code intelligence ready
ā
Index current (no re-index needed)
ā
Semantic search available
**Suggested Workflow:** Bug Hunt (Systematic Debugging)
You're in Phase 2: Capture in Test
**Next Steps:**
1. Write failing test that reproduces the race condition
2. Verify test fails consistently
3. Then move to fix with mutex/locking
Great detective work yesterday! You found the race condition. Now let's capture it in a test before fixing. šµļø
User starts Claude Code (new workspace)
ā Goldfish: recall()
Results: Empty (no checkpoints)
ā Julie: manage_workspace({ operation: "list" })
Workspace not indexed
ā Julie: manage_workspace({ operation: "index" })
ā
Indexed 423 files
ā Analysis:
- Fresh start
- No active workflow
- No active plan
ā Present to user:
š Welcome!
**New Session**
This is a fresh workspace - no previous work detected.
**Workspace Status:**
ā
Code intelligence ready
ā
423 files indexed (TypeScript, JavaScript, Python detected)
ā
Semantic search available
**Ready for:**
- Feature development (use TDD)
- Bug fixes (use Bug Hunt)
- Code exploration (ask me to explore!)
- Refactoring (safe refactoring available)
**Next Steps:**
1. Tell me what you want to work on
2. I'll suggest the right workflow
3. I'll track progress with checkpoints
What would you like to build? š
Pattern Analysis:
tags: ["tdd", "tests"] ā TDD workflow
tags: ["bug-hunt", "investigation"] ā Bug Hunt workflow
tags: ["refactor"] ā Refactor workflow
tags: ["planning", "design"] ā Planning workflow
TDD checkpoint pattern:
"designed interface" ā Phase 1 complete
"wrote tests" ā Phase 2 complete
"all tests passing" ā Phase 3 complete
"refactored" ā Phase 4 complete
Bug Hunt pattern:
"isolated bug" ā Phase 1 complete
"wrote failing test" ā Phase 2 complete
"test passes" ā Phase 3 complete
"verified fix" ā Phase 4 complete
Based on last checkpoint + active plan:
- Phase incomplete ā Continue current phase
- Phase complete ā Advance to next phase
- Workflow complete ā Suggest next work item
- Blocker mentioned ā Address blocker first
Check last index time:
- < 1 hour ago ā Skip (fresh enough)
- 1-6 hours ago ā Quick index if files changed
- > 6 hours ago ā Full re-index
- Never indexed ā Full index (required)
Index in background if possible
- Don't block session start
- Search works during indexing
Smart Session Start succeeds when:
Total: <500ms + optional background indexing
Result: Nearly instant context restoration!
Remember: Smart Session Start is MANDATORY. Every session should begin with full context restoration. Don't ask, just restore and present!
This skill should be used when the user asks to "create a slash command", "add a command", "write a custom command", "define command arguments", "use command frontmatter", "organize commands", "create command with file references", "interactive command", "use AskUserQuestion in command", or needs guidance on slash command structure, YAML frontmatter fields, dynamic arguments, bash execution in commands, user interaction patterns, or command development best practices for Claude Code.
This skill should be used when the user asks to "create an agent", "add an agent", "write a subagent", "agent frontmatter", "when to use description", "agent examples", "agent tools", "agent colors", "autonomous agent", or needs guidance on agent structure, system prompts, triggering conditions, or agent development best practices for Claude Code plugins.
This skill should be used when the user asks to "create a hook", "add a PreToolUse/PostToolUse/Stop hook", "validate tool use", "implement prompt-based hooks", "use ${CLAUDE_PLUGIN_ROOT}", "set up event-driven automation", "block dangerous commands", or mentions hook events (PreToolUse, PostToolUse, Stop, SubagentStop, SessionStart, SessionEnd, UserPromptSubmit, PreCompact, Notification). Provides comprehensive guidance for creating and implementing Claude Code plugin hooks with focus on advanced prompt-based hooks API.