Session Management

Save, load, and manage development sessions effectively

Session Management Guide

GemBoost provides persistent session management through the Serena MCP server, enabling true context preservation across Gemini Cli conversations and long-term project continuity.

Core Session Commands with Persistent Memory

/gb:load - Context Loading with Persistent Memory

Purpose: Initialize session with project context and persistent memory from previous sessions

MCP Integration: Triggers Serena MCP to read stored project memories

Syntax: /gb:load [project_path]

What Happens:

  • • Serena MCP reads persistent memory files from previous sessions
  • • Project context is restored from stored memories
  • • Previous decisions, patterns, and progress are loaded
  • • Session state is initialized with historical context

Use Cases:

# Load existing project context from persistent memory
/gb:load src/

# Resume specific project work with full history
/gb:load "authentication-system"

# Initialize with codebase analysis and previous insights
/gb:load . --analyze

/gb:save - Session Persistence to Memory

Purpose: Save current session state and decisions to persistent memory

MCP Integration: Triggers Serena MCP to write memory files

Syntax: /gb:save "session_description"

What Happens:

  • • Current context and decisions are written to Serena memory
  • • Project state and progress are persisted across conversations
  • • Key insights and patterns are stored for future sessions
  • • Session summary is created with timestamp for retrieval

Use Cases:

# Save completed feature work for future reference
/gb:save "user authentication implemented with JWT"

# Checkpoint during complex work
/gb:save "API design phase complete, ready for implementation"

# Store architectural decisions permanently
/gb:save "microservices architecture decided, service boundaries defined"

/gb:reflect - Progress Assessment with Memory Context

Purpose: Analyze current progress against stored memories and validate session completeness

MCP Integration: Uses Serena MCP to compare current state against stored memories

Syntax: /gb:reflect [--scope project|session]

What Happens:

  • • Serena MCP reads previous memories and current context
  • • Progress is assessed against stored goals and milestones
  • • Gaps and next steps are identified using historical context
  • • Session completeness is validated against project memory

Use Cases:

# Assess project progress against stored milestones
/gb:reflect --scope project

# Validate current session completeness
/gb:reflect

# Check if ready to move to next phase based on memory
/gb:reflect --scope session

Persistent Memory Architecture

How Serena MCP Enables True Persistence

Memory Storage:

  • • Session contexts stored as structured memory files
  • • Project decisions and architectural patterns preserved permanently
  • • Code analysis results and insights retained across conversations
  • • Progress tracking and milestone data maintained long-term

Cross-Session Continuity:

  • • Previous session context automatically available in new conversations
  • • Decisions and rationale preserved and accessible across conversations
  • • Learning from past patterns and solutions maintained
  • • Consistent project understanding maintained indefinitely

Memory Types:

  • Project Memories: Long-term project context and architecture
  • Session Memories: Specific conversation outcomes and decisions
  • Pattern Memories: Reusable solutions and architectural patterns
  • Progress Memories: Milestone tracking and completion status

Session Lifecycle Patterns with Persistence

New Project Initialization

# 1. Start fresh project
/gb:brainstorm "e-commerce platform requirements"

# 2. Save initial decisions to persistent memory
/gb:save "project scope and requirements defined"

# 3. Begin implementation planning
/gb:workflow "user authentication system"

# 4. Save architectural decisions permanently
/gb:save "auth architecture: JWT + refresh tokens + rate limiting"

Resuming Existing Work (Cross-Conversation)

# 1. Load previous context from persistent memory
/gb:load "e-commerce-project"

# 2. Assess current state against stored progress
/gb:reflect --scope project

# 3. Continue with next phase using stored context
/gb:implement "payment processing integration"

# 4. Save progress checkpoint to memory
/gb:save "payment system integrated with Stripe API"

Long-Term Project Management

# Weekly checkpoint pattern with persistence
/gb:load project-name
/gb:reflect --scope project
# ... work on features ...
/gb:save "week N progress: features X, Y, Z completed"

# Phase completion pattern with memory
/gb:reflect --scope project
/gb:save "Phase 1 complete: core authentication and user management"
/gb:workflow "Phase 2: payment and order processing"

Cross-Conversation Continuity

Starting New Conversations with Persistence

When starting a new Gemini Cli conversation, the persistent memory system allows:

1. Automatic Context Restoration

/gb:load project-name
# Automatically restores all previous context, decisions, and progress

2. Progress Continuation

  • • Previous session decisions are immediately available
  • • Architectural patterns and code insights are preserved
  • • Project history and rationale are maintained

3. Intelligent Context Building

  • • Serena MCP provides relevant memories based on current work
  • • Past solutions and patterns inform new implementations
  • • Project evolution is tracked and understood

Effective Memory Usage:

  • • Use descriptive, searchable memory names
  • • Include project phase and timestamp context
  • • Reference specific features or architectural decisions
  • • Make future retrieval intuitive

Memory Content Strategy:

  • • Store decisions and rationale, not just outcomes
  • • Include alternative approaches considered
  • • Document integration patterns and dependencies
  • • Preserve learning and insights for future reference

Memory Lifecycle Management:

  • • Regular cleanup of outdated memories
  • • Consolidation of related session memories
  • • Archiving of completed project phases
  • • Pruning of obsolete architectural decisions

Best Practices for Persistent Sessions

Session Start Protocol

  1. Always begin with /gb:load for existing projects
  2. Use /gb:reflect to understand current state from memory
  3. Plan work based on persistent context and stored patterns
  4. Build on previous decisions and architectural choices

Session End Protocol

  1. Use /gb:reflect to assess completeness against stored goals
  2. Save key decisions with /gb:save for future sessions
  3. Document next steps and open questions in memory
  4. Preserve context for seamless future continuation

Memory Quality Maintenance

  • • Use clear, descriptive memory names for easy retrieval
  • • Include context about decisions and alternative approaches
  • • Reference specific code locations and patterns
  • • Maintain consistency in memory structure across sessions

Integration with Other GemBoost Features

MCP Server Coordination

  • Serena MCP: Provides the persistent memory infrastructure
  • Sequential MCP: Uses stored memories for enhanced complex analysis
  • Context7 MCP: References stored patterns and documentation approaches
  • Morphllm MCP: Applies stored refactoring patterns consistently

Agent Collaboration with Memory

  • • Agents access persistent memories for enhanced context
  • • Previous specialist decisions are preserved and referenced
  • • Cross-session agent coordination through shared memory
  • • Consistent specialist recommendations based on project history

Command Integration with Persistence

  • • All /gb: commands can reference and build on persistent context
  • • Previous command outputs and decisions are available across sessions
  • • Workflow patterns are stored and reusable
  • • Implementation history guides future command decisions

Troubleshooting Persistent Sessions

Common Issues

Memory Not Loading:

  • • Verify Serena MCP is configured and running properly
  • • Check memory file permissions and accessibility
  • • Ensure consistent project naming conventions
  • • Validate memory file integrity and format

Context Loss Between Sessions:

  • • Always use /gb:save before ending sessions
  • • Use descriptive memory names for easy retrieval
  • • Regular /gb:reflect to validate memory completeness
  • • Backup important memory files periodically

Memory Conflicts:

  • • Use timestamped memory names for version control
  • • Regular cleanup of obsolete memories
  • • Clear separation between project and session memories
  • • Consistent memory naming conventions across sessions

Quick Fixes

Reset Session State:

/gb:load --fresh  # Start without previous context
/gb:reflect       # Assess current state

Memory Cleanup:

/gb:reflect --cleanup  # Remove obsolete memories
/gb:save --consolidate # Merge related memories

Context Recovery:

/gb:load --recent     # Load most recent memories
/gb:reflect --repair  # Identify and fix context gaps

Advanced Persistent Session Patterns

Multi-Phase Projects

  • • Use phase-specific memory naming for organization
  • • Maintain architectural decision continuity across phases
  • • Cross-phase dependency tracking through persistent memory
  • • Progressive complexity management with historical context

Team Collaboration

  • • Shared memory conventions and naming standards
  • • Decision rationale preservation for team context
  • • Integration pattern documentation accessible to all team members
  • • Consistent code style and architecture enforcement through memory

Long-Term Maintenance

  • • Memory archiving strategies for completed projects
  • • Pattern library development through accumulated memories
  • • Reusable solution documentation built over time
  • • Knowledge base building through persistent memory accumulation

Key Benefits of Persistent Session Management

Project Continuity

  • • Seamless work continuation across multiple conversations
  • • No context loss between Gemini Cli sessions
  • • Preserved architectural decisions and technical rationale
  • • Long-term project evolution tracking

Enhanced Productivity

  • • Reduced need to re-explain project context
  • • Faster startup time for continued work
  • • Building on previous insights and patterns
  • • Cumulative project knowledge growth

Quality Consistency

  • • Consistent architectural patterns across sessions
  • • Preserved code quality decisions and standards
  • • Reusable solutions and best practices
  • • Maintained technical debt awareness

Key Takeaway

Session management through Serena MCP transforms GemBoost from single-conversation assistance to persistent project partnership, maintaining context, decisions, and learning across all development phases and Gemini Cli conversations.