Commit dc85ed0

@@ -1,10 +1,10 @@
 # Sequential Thinking MCP Server
 
-A Model Context Protocol (MCP) server that provides structured thinking workflows for AI assistants to break down complex problems step-by-step.
+A Model Context Protocol (MCP) server that provides structured thinking workflows with persistent session management and branch tracking for AI assistants to break down complex problems step-by-step.
 
 ## Overview
 
-The Sequential Thinking MCP server enables AI assistants to engage in structured, step-by-step reasoning through a standardized protocol. It provides tools for organizing thoughts, breaking down complex problems, and maintaining logical flow in problem-solving processes.
+The Sequential Thinking MCP server enables AI assistants to engage in structured, step-by-step reasoning through a standardized protocol. It provides tools for organizing thoughts, breaking down complex problems, maintaining logical flow in problem-solving processes, and **persisting thought history across sessions** with full **branch tracking** for alternative reasoning paths.
 
 ## Installation
 
@@ -27,10 +27,21 @@ go build -o mcp-sequential-thinking ./cmd/sequential-thinking
 ### Command Line Arguments
 
 ```bash
-mcp-sequential-thinking
+mcp-sequential-thinking [--session-file <path>] [--help]
 ```
 
-**No arguments required** - The server provides thinking workflow utilities without any configuration.
+**Options:**
+- `--session-file <path>`: Optional file path for persisting thinking sessions across server restarts
+- `--help`: Show help message with usage information
+
+**Example:**
+```bash
+# Run without persistence (sessions lost on restart)
+mcp-sequential-thinking
+
+# Run with session persistence
+mcp-sequential-thinking --session-file /path/to/sessions.json
+```
 
 ### Examples
 
@@ -46,26 +57,54 @@ echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/list", "params": {}}' | timeo
 echo '{"jsonrpc": "2.0", "id": 3, "method": "tools/call", "params": {"name": "sequentialthinking", "arguments": {"problem": "How to design a scalable web application?"}}}' | timeout 5s mcp-sequential-thinking
 ```
 
-#### Structured Problem Solving
+#### Sequential Thinking Process
 ```bash
-# Break down a complex programming problem
-echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "sequentialthinking", "arguments": {"problem": "Design a distributed caching system", "steps": ["Identify requirements", "Choose architecture", "Design data model", "Plan implementation", "Consider scalability"]}}}' | timeout 5s mcp-sequential-thinking
+# Start a thinking session with first thought
+echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "sequentialthinking", "arguments": {"thought": "I need to analyze whether migrating to microservices makes sense for our current system", "nextThoughtNeeded": true, "thoughtNumber": 1, "totalThoughts": 5}}}' | timeout 5s mcp-sequential-thinking
 
-# Analyze a business decision
-echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "sequentialthinking", "arguments": {"problem": "Should we migrate to microservices?", "context": "Current monolith serves 10M users, team of 50 developers"}}}' | timeout 5s mcp-sequential-thinking
+# Continue with second thought (sessionId will be returned from first call)
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "sequentialthinking", "arguments": {"thought": "Let me first evaluate our current monolith - it serves 10M users with a team of 50 developers", "nextThoughtNeeded": true, "thoughtNumber": 2, "totalThoughts": 5, "sessionId": "session_123456789"}}}' | timeout 5s mcp-sequential-thinking
+
+# Create a branch for alternative reasoning
+echo '{"jsonrpc": "2.0", "id": 3, "method": "tools/call", "params": {"name": "sequentialthinking", "arguments": {"thought": "What if we consider a hybrid approach instead of full microservices?", "nextThoughtNeeded": true, "thoughtNumber": 3, "totalThoughts": 4, "branchFromThought": 2, "branchId": "hybrid-approach", "sessionId": "session_123456789"}}}' | timeout 5s mcp-sequential-thinking
 ```
 
 ## Available Tools
 
-### Structured Thinking
-- **`sequentialthinking`**: Engage in step-by-step problem analysis
+### Core Thinking Tool
+- **`sequentialthinking`**: Engage in step-by-step problem analysis with session persistence
+  - **Parameters:**
+    - `thought` (required): Your current thinking step
+    - `nextThoughtNeeded` (required): Whether another thought step is needed
+    - `thoughtNumber` (required): Current thought number (1-based)
+    - `totalThoughts` (required): Estimated total thoughts needed
+    - `isRevision` (optional): Whether this revises previous thinking
+    - `revisesThought` (optional): Which thought number is being reconsidered
+    - `branchFromThought` (optional): Branching point thought number
+    - `branchId` (optional): Branch identifier for alternative reasoning paths
+    - `needsMoreThoughts` (optional): If more thoughts are needed beyond initial estimate
+    - `sessionId` (optional): Session ID for thought continuity (auto-generated if not provided)
+  - **Returns:** Structured thinking process with session context and persistence
+
+### Session Management Tools
+- **`get_session_history`**: Get the complete thought history for a thinking session
+  - **Parameters:**
+    - `sessionId` (required): Session ID to get history for
+  - **Returns:** Complete session data with all thoughts and metadata
+
+- **`list_sessions`**: List all active thinking sessions
+  - **Parameters:** None
+  - **Returns:** Array of all sessions with summary information
+
+- **`get_branch_history`**: Get the thought history for a specific reasoning branch
+  - **Parameters:**
+    - `branchId` (required): Branch ID to get history for
+  - **Returns:** Complete branch data with all thoughts and metadata
+
+- **`clear_session`**: Clear a thinking session and all its branches
   - **Parameters:**
-    - `problem` (required): The problem or question to analyze
-    - `context` (optional): Additional context or background information
-    - `steps` (optional): Predefined steps to follow in the analysis
-    - `depth` (optional): Level of analysis depth (1-5, default: 3)
-    - `focus` (optional): Specific aspect to focus on ("technical", "business", "creative", "analytical")
-  - **Returns:** Structured thinking process with step-by-step analysis
+    - `sessionId` (required): Session ID to clear
+  - **Returns:** Confirmation message with cleared session details
 
 ## Thinking Frameworks
 
@@ -94,19 +133,20 @@ echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "se
 ```json
 {
   "mcpServers": {
-    "thinking": {
+    "sequential-thinking": {
       "command": "/usr/local/bin/mcp-sequential-thinking"
     }
   }
 }
 ```
 
-### Multiple Thinking Services
+### With Session Persistence
 ```json
 {
   "mcpServers": {
-    "structured-thinking": {
-      "command": "/usr/local/bin/mcp-sequential-thinking"
+    "sequential-thinking": {
+      "command": "/usr/local/bin/mcp-sequential-thinking",
+      "args": ["--session-file", "/home/user/.mcp/thinking-sessions.json"]
     }
   }
 }
@@ -114,61 +154,67 @@ echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "se
 
 ## Example Workflows
 
-### Software Architecture Design
+### Basic Sequential Thinking
 ```bash
-# Analyze microservices migration
-echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "sequentialthinking", "arguments": {"problem": "Should we break our monolith into microservices?", "context": "E-commerce platform, 50 developers, 1M daily users", "focus": "technical", "depth": 4}}}' | mcp-sequential-thinking
+# Start a new thinking session
+echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "sequentialthinking", "arguments": {"thought": "I need to decide whether to implement caching for our API", "nextThoughtNeeded": true, "thoughtNumber": 1, "totalThoughts": 4}}}' | mcp-sequential-thinking
 
-# Database selection process
-echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "sequentialthinking", "arguments": {"problem": "Choose between PostgreSQL, MongoDB, and DynamoDB for our new project", "context": "Real-time analytics dashboard, 100K concurrent users", "steps": ["Define requirements", "Compare capabilities", "Evaluate performance", "Consider costs", "Assess team expertise"]}}}' | mcp-sequential-thinking
+# Continue the thinking process
+echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "sequentialthinking", "arguments": {"thought": "Current performance metrics show 500ms average response time with 10K requests/min", "nextThoughtNeeded": true, "thoughtNumber": 2, "totalThoughts": 4, "sessionId": "session_1735056789"}}}' | mcp-sequential-thinking
+
+# Revise a previous thought
+echo '{"jsonrpc": "2.0", "id": 3, "method": "tools/call", "params": {"name": "sequentialthinking", "arguments": {"thought": "Actually, let me reconsider - the 500ms includes database queries, not just API processing", "nextThoughtNeeded": true, "thoughtNumber": 3, "totalThoughts": 4, "isRevision": true, "revisesThought": 2, "sessionId": "session_1735056789"}}}' | mcp-sequential-thinking
 ```
 
-### Business Decision Making
+### Branching Alternative Approaches
 ```bash
-# Product feature prioritization
-echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "sequentialthinking", "arguments": {"problem": "Which features should we build next quarter?", "context": "SaaS product, limited engineering resources, competitive pressure", "focus": "business", "depth": 3}}}' | mcp-sequential-thinking
+# Create a branch for alternative reasoning
+echo '{"jsonrpc": "2.0", "id": 4, "method": "tools/call", "params": {"name": "sequentialthinking", "arguments": {"thought": "What if we optimize the database queries instead of adding caching?", "nextThoughtNeeded": true, "thoughtNumber": 1, "totalThoughts": 3, "branchFromThought": 2, "branchId": "db-optimization", "sessionId": "session_1735056789"}}}' | mcp-sequential-thinking
 
-# Market expansion strategy
-echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "sequentialthinking", "arguments": {"problem": "Should we expand to European markets?", "context": "US-based startup, $2M ARR, 20 employees", "focus": "business"}}}' | mcp-sequential-thinking
+# Continue in the branch
+echo '{"jsonrpc": "2.0", "id": 5, "method": "tools/call", "params": {"name": "sequentialthinking", "arguments": {"thought": "Database optimization would require indexing and query restructuring", "nextThoughtNeeded": false, "thoughtNumber": 2, "totalThoughts": 3, "branchId": "db-optimization", "sessionId": "session_1735056789"}}}' | mcp-sequential-thinking
 ```
 
-### Creative Problem Solving
+### Session Management
 ```bash
-# User experience improvement
-echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "sequentialthinking", "arguments": {"problem": "How can we improve user onboarding experience?", "context": "Complex B2B software, high drop-off rates", "focus": "creative", "depth": 3}}}' | mcp-sequential-thinking
+# List all active sessions
+echo '{"jsonrpc": "2.0", "id": 6, "method": "tools/call", "params": {"name": "list_sessions", "arguments": {}}}' | mcp-sequential-thinking
 
-# Innovation brainstorming
-echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "sequentialthinking", "arguments": {"problem": "What new AI features could differentiate our product?", "context": "Project management tool, growing AI competition", "focus": "creative"}}}' | mcp-sequential-thinking
-```
+# Get complete history of a session
+echo '{"jsonrpc": "2.0", "id": 7, "method": "tools/call", "params": {"name": "get_session_history", "arguments": {"sessionId": "session_1735056789"}}}' | mcp-sequential-thinking
 
-### Research and Analysis
-```bash
-# Technology evaluation
-echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "sequentialthinking", "arguments": {"problem": "Evaluate the impact of implementing GraphQL", "context": "REST API currently serves mobile and web clients", "focus": "analytical", "depth": 4}}}' | mcp-sequential-thinking
+# Get history of a specific branch
+echo '{"jsonrpc": "2.0", "id": 8, "method": "tools/call", "params": {"name": "get_branch_history", "arguments": {"branchId": "db-optimization"}}}' | mcp-sequential-thinking
 
-# Performance optimization
-echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "sequentialthinking", "arguments": {"problem": "Why is our application slow and how can we fix it?", "context": "Web app with 2-second load times, user complaints increasing", "steps": ["Identify bottlenecks", "Measure current performance", "Analyze root causes", "Propose solutions", "Plan implementation"]}}}' | mcp-sequential-thinking
+# Clear a completed session
+echo '{"jsonrpc": "2.0", "id": 9, "method": "tools/call", "params": {"name": "clear_session", "arguments": {"sessionId": "session_1735056789"}}}' | mcp-sequential-thinking
 ```
 
 ## Advanced Features
 
-### Structured Output
-- **Step-by-Step Breakdown**: Clear progression through thinking process
-- **Logical Flow**: Each step builds on previous conclusions
-- **Alternative Perspectives**: Consideration of multiple viewpoints
-- **Risk Assessment**: Identification of potential issues and mitigation strategies
-
-### Contextual Adaptation
-- **Domain Awareness**: Adapts reasoning style to problem domain
-- **Complexity Scaling**: Adjusts depth based on problem complexity
-- **Stakeholder Consideration**: Includes relevant stakeholder perspectives
-- **Implementation Focus**: Balances theoretical analysis with practical considerations
-
-### Thinking Patterns
-- **Analytical**: Systematic breakdown and evaluation
-- **Creative**: Divergent thinking and innovation
-- **Critical**: Questioning assumptions and finding flaws
-- **Systems**: Understanding interconnections and dependencies
+### Session Persistence
+- **Cross-Session Continuity**: Thinking sessions persist across server restarts
+- **JSON File Storage**: Sessions stored in human-readable JSON format
+- **Automatic Session IDs**: Unique session identifiers generated automatically
+- **Thread-Safe Operations**: Concurrent access to sessions handled safely
+
+### Branch Tracking
+- **Alternative Reasoning Paths**: Create branches from any thought in the main sequence
+- **Branch Isolation**: Each branch maintains its own thought sequence
+- **Branch Relationships**: Track which thought each branch originated from
+- **Cross-Branch Navigation**: Access both main session and branch histories
+
+### Enhanced Output Format
+- **Rich Visual Formatting**: Progress bars, emojis, and structured sections
+- **Session Context**: Always shows current session ID and branch information
+- **Structured JSON Data**: Programmatic access to all thinking data
+- **Solution Extraction**: Automatic extraction of solutions from final thoughts
+
+### Revision Support
+- **Thought Revision**: Mark thoughts as revisions of previous thoughts
+- **Revision Tracking**: Keep track of which thoughts were revised
+- **Context Preservation**: Revisions maintain context of original reasoning
+- **Dynamic Estimation**: Adjust total thought count as thinking evolves
 
 ## Use Cases
 
@@ -202,66 +248,108 @@ echo '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "se
 
 ## Performance
 
-- **Startup Time**: ~1ms
-- **Memory Usage**: <5MB
-- **Response Time**: Varies by problem complexity (typically 1-10 seconds)
-- **Scalability**: Handles complex multi-step problems efficiently
+- **Startup Time**: <100ms (with session loading)
+- **Memory Usage**: <5MB (scales with session count)
+- **Response Time**: <50ms per tool call (excluding thinking time)
+- **Persistence**: Efficient JSON serialization for session storage
+- **Scalability**: Handles hundreds of concurrent sessions with branch tracking
 
 ## Best Practices
 
-### Problem Definition
-1. **Be Specific**: Clearly define the problem or question
-2. **Provide Context**: Include relevant background information
-3. **Set Boundaries**: Define scope and constraints
-4. **Specify Outcomes**: Clarify desired results or decisions
+### Session Management
+1. **Plan Thought Sequence**: Estimate total thoughts needed at the start
+2. **Use Descriptive Thoughts**: Each thought should be self-contained and clear
+3. **Leverage Sessions**: Keep related thoughts in the same session
+4. **Clean Up Sessions**: Clear completed sessions to manage memory
 
-### Using Parameters Effectively
-1. **Context is Key**: Always provide relevant context for better analysis
-2. **Choose Appropriate Depth**: Match depth to problem complexity
-3. **Select Right Focus**: Align focus area with problem type
-4. **Guide with Steps**: Use predefined steps for structured domains
+### Branch Strategy
+1. **Branch Strategically**: Create branches for major alternative approaches
+2. **Name Branches Clearly**: Use descriptive branch IDs like "cost-analysis" or "tech-alternative"
+3. **Track Branch Origins**: Note which thought triggered the need for branching
+4. **Compare Branches**: Use branch history to compare different reasoning paths
 
-### Interpreting Results
-1. **Follow the Logic**: Understand the reasoning chain
-2. **Question Assumptions**: Validate underlying assumptions
-3. **Consider Alternatives**: Look for alternative approaches mentioned
-4. **Plan Next Steps**: Use conclusions to guide action plans
+### Revision Best Practices
+1. **Mark Revisions Clearly**: Always use `isRevision: true` when reconsidering
+2. **Reference Original**: Specify which thought is being revised
+3. **Explain Changes**: Make the revision reasoning explicit
+4. **Update Estimates**: Adjust total thoughts if revision changes the scope
 
-## Example Output Structure
+## Data Structures
 
-A typical sequential thinking response includes:
+### Session Data
+```json
+{
+  "id": "session_1735056789",
+  "thoughts": [
+    {
+      "number": 1,
+      "content": "Initial thought content",
+      "isRevision": false,
+      "needsMoreThoughts": false
+    }
+  ],
+  "currentThought": 3,
+  "totalThoughts": 5,
+  "status": "active",
+  "createdAt": "2024-12-25T10:30:00Z",
+  "lastActivity": "2024-12-25T10:35:00Z",
+  "activeBranches": ["branch-1", "branch-2"]
+}
+```
 
-1. **Problem Understanding**: Restated problem with key aspects identified
-2. **Context Analysis**: Relevant factors and constraints
-3. **Step-by-Step Reasoning**: Logical progression through the problem
-4. **Alternative Considerations**: Different perspectives and approaches
-5. **Risk Assessment**: Potential issues and mitigation strategies
-6. **Recommendations**: Actionable conclusions and next steps
-7. **Implementation Considerations**: Practical aspects of executing solutions
+### Branch Data
+```json
+{
+  "id": "optimization-branch",
+  "sessionId": "session_1735056789",
+  "fromThought": 2,
+  "thoughts": [
+    {
+      "number": 1,
+      "content": "Alternative approach thought",
+      "branchFromThought": 2,
+      "branchId": "optimization-branch"
+    }
+  ],
+  "createdAt": "2024-12-25T10:32:00Z",
+  "lastActivity": "2024-12-25T10:34:00Z"
+}
+```
 
 ## Troubleshooting
 
 ### Common Issues
 
-1. **Vague problem statements**
+1. **Session not persisting**
+   ```bash
+   # Ensure session file is specified and writable
+   mcp-sequential-thinking --session-file /writable/path/sessions.json
+   
+   # Check file permissions
+   ls -la /path/to/sessions.json
+   ```
+
+2. **Missing required parameters**
    ```bash
-   # Instead of: "What should I do?"
-   # Use: "Should I implement caching to improve API response times?"
-   echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "sequentialthinking", "arguments": {"problem": "Should I implement Redis caching for our user profile API?", "context": "Currently serves 10K requests/min, 500ms average response time"}}}' | mcp-sequential-thinking
+   # All these parameters are required for sequentialthinking tool:
+   echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "sequentialthinking", "arguments": {"thought": "My analysis of the problem", "nextThoughtNeeded": true, "thoughtNumber": 1, "totalThoughts": 3}}}' | mcp-sequential-thinking
    ```
 
-2. **Missing context**
+3. **Branch creation without sessionId**
    ```bash
-   # Provide relevant background information
-   echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "sequentialthinking", "arguments": {"problem": "Choose between React and Vue", "context": "Team of 5 developers, all experienced with JavaScript, building customer portal, 6-month timeline"}}}' | mcp-sequential-thinking
+   # Branches require an existing session
+   # First create/continue a session, get the sessionId from response
+   # Then use that sessionId for branch creation
+   echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "sequentialthinking", "arguments": {"thought": "Alternative approach", "nextThoughtNeeded": true, "thoughtNumber": 1, "totalThoughts": 2, "branchFromThought": 3, "branchId": "alt-approach", "sessionId": "session_123456789"}}}' | mcp-sequential-thinking
    ```
 
-3. **Wrong depth level**
+4. **Session ID not found**
    ```bash
-   # Adjust depth based on problem complexity
-   # Simple decisions: depth 1-2
-   # Complex strategic decisions: depth 4-5
-   echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "sequentialthinking", "arguments": {"problem": "Company acquisition strategy", "depth": 5}}}' | mcp-sequential-thinking
+   # List sessions to find correct ID
+   echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "list_sessions", "arguments": {}}}' | mcp-sequential-thinking
+   
+   # Or check if persistence file exists and is readable
+   cat /path/to/sessions.json
    ```
 
 ## Contributing

@@ -702,13 +702,17 @@ Servers can implement any combination of:
 ## 5. Sequential Thinking Server (`mcp-server-sequential-thinking`)
 
 ### Dependencies
-- State management for thought sequences
-- Dynamic thought process tracking
+- JSON file storage for session persistence
+- State management for thought sequences and branches
+- Thread-safe concurrent access controls
+
+### Configuration
+- Command line argument: `--session-file <path>` for persistent session storage
 
 ### Tools
 
 #### `sequentialthinking`
-- **Description**: Dynamic and reflective problem-solving through thought sequences
+- **Description**: Dynamic problem-solving through structured thought sequences with session persistence
 - **Input Schema**:
   ```json
   {
@@ -722,17 +726,72 @@ Servers can implement any combination of:
       "revisesThought": {"type": "integer", "description": "Which thought is being reconsidered", "minimum": 1},
       "branchFromThought": {"type": "integer", "description": "Branching point thought number", "minimum": 1},
       "branchId": {"type": "string", "description": "Branch identifier"},
-      "needsMoreThoughts": {"type": "boolean", "description": "If more thoughts are needed"}
+      "needsMoreThoughts": {"type": "boolean", "description": "If more thoughts are needed"},
+      "sessionId": {"type": "string", "description": "Session ID for thought continuity (auto-generated if not provided)"}
     },
     "required": ["thought", "nextThoughtNeeded", "thoughtNumber", "totalThoughts"]
   }
   ```
 - **Implementation**:
-  - Track thought sequences and branching
+  - Track thought sequences with persistent sessions
+  - Support branching for alternative reasoning paths
   - Support revision and refinement of previous thoughts
-  - Maintain context across thought progression
-  - Generate and verify solution hypotheses
-- **Output**: TextContent with thought processing results
+  - Thread-safe concurrent session access
+  - JSON file persistence across server restarts
+- **Output**: TextContent with thought processing results and session context
+
+#### `get_session_history`
+- **Description**: Retrieve complete thought history for a thinking session
+- **Input Schema**:
+  ```json
+  {
+    "type": "object",
+    "properties": {
+      "sessionId": {"type": "string", "description": "Session ID to get history for"}
+    },
+    "required": ["sessionId"]
+  }
+  ```
+- **Output**: JSON TextContent with complete session data and thoughts
+
+#### `list_sessions`
+- **Description**: List all active thinking sessions
+- **Input Schema**:
+  ```json
+  {
+    "type": "object",
+    "properties": {}
+  }
+  ```
+- **Output**: JSON TextContent with array of session summaries
+
+#### `get_branch_history`
+- **Description**: Get thought history for a specific reasoning branch
+- **Input Schema**:
+  ```json
+  {
+    "type": "object",
+    "properties": {
+      "branchId": {"type": "string", "description": "Branch ID to get history for"}
+    },
+    "required": ["branchId"]
+  }
+  ```
+- **Output**: JSON TextContent with complete branch data and thoughts
+
+#### `clear_session`
+- **Description**: Clear a thinking session and all its branches
+- **Input Schema**:
+  ```json
+  {
+    "type": "object",
+    "properties": {
+      "sessionId": {"type": "string", "description": "Session ID to clear"}
+    },
+    "required": ["sessionId"]
+  }
+  ```
+- **Output**: JSON TextContent with confirmation message and details
 
 ## 6. Time Server (`mcp-server-time`)
 

@@ -8,11 +8,12 @@ This is a **production-ready** Go-based MCP (Model Context Protocol) server impl
 
 ## 🎉 Current Status: COMPLETE
 
-**All 4 enhancement phases have been successfully implemented:**
+**All enhancement phases have been successfully implemented:**
 - ✅ Phase 1: Advanced HTML Processing (goquery + html-to-markdown) 
 - ✅ Phase 2: Interactive Prompts Support (user/assistant conversations)
 - ✅ Phase 3: Resources Support (file://, git://, memory:// URI schemes)
 - ✅ Phase 4: Roots Support (automatic capability discovery)
+- ✅ Advanced: Sequential Thinking Enhancements (persistent sessions, branch tracking)
 
 ## Architecture
 
@@ -24,7 +25,7 @@ Each server is a standalone binary in `/usr/local/bin/`:
 3. **mcp-memory** - Knowledge graph management with entities/relations
 4. **mcp-fetch** - Web content fetching with advanced HTML processing
 5. **mcp-time** - Time and date utilities
-6. **mcp-sequential-thinking** - Structured thinking workflows
+6. **mcp-sequential-thinking** - Advanced structured thinking workflows with persistent sessions and branch tracking
 7. **mcp-maildir** - Email management through Maildir format with search and analysis
 
 ### Protocol Implementation
@@ -68,7 +69,7 @@ mcp-fetch
 mcp-time
 
 # Sequential thinking server
-mcp-sequential-thinking
+mcp-sequential-thinking --session-file /path/to/sessions.json
 
 # Maildir server
 mcp-maildir --maildir-path /path/to/maildir
@@ -100,6 +101,27 @@ mcp-maildir --maildir-path /path/to/maildir
 - **Dynamic updates**: Root information updates when underlying data changes
 - **User-friendly names**: Descriptive root names with context (e.g., "Git Repository: mcp (branch: main)")
 
+### 5. Sequential Thinking Enhancements (Advanced)
+- **Persistent session management**: Multi-session support with unique IDs and file-based persistence
+- **Complete thought history**: Full tracking of thoughts across server invocations
+- **Cross-call branch tracking**: Create and manage reasoning branches with lifecycle management
+- **Enhanced tools**: 5 total tools including session/branch history and management
+- **Thread-safe operations**: Concurrent session access with proper mutex locking
+- **Rich visual output**: Progress bars, session context, and branch information
+
+**Available Tools:**
+- `sequentialthinking`: Enhanced core tool with session continuity support
+- `get_session_history`: Retrieve complete thought history for any session
+- `list_sessions`: List all active thinking sessions with metadata
+- `get_branch_history`: Get detailed branch history and thoughts
+- `clear_session`: Clean up sessions and associated branches
+
+**Persistence Features:**
+- Optional `--session-file` flag for cross-invocation session persistence
+- Automatic session creation with unique IDs when not specified
+- JSON-based storage of sessions, branches, and complete thought history
+- Graceful handling of missing or corrupted persistence files
+
 ## Testing Integration
 
 ### Quick Capability Test
@@ -124,6 +146,9 @@ echo '{"jsonrpc": "2.0", "id": 4, "method": "roots/list"}' | mcp-filesystem --al
 
 # Test enhanced HTML processing
 echo '{"jsonrpc": "2.0", "id": 5, "method": "tools/call", "params": {"name": "fetch", "arguments": {"url": "https://example.com"}}}' | mcp-fetch
+
+# Test sequential thinking with persistence
+echo '{"jsonrpc": "2.0", "id": 6, "method": "tools/call", "params": {"name": "sequentialthinking", "arguments": {"thought": "Testing persistent sessions", "nextThoughtNeeded": true, "thoughtNumber": 1, "totalThoughts": 3, "sessionId": "test_session"}}}' | mcp-sequential-thinking --session-file /tmp/sessions.json
 ```
 
 ## Dependencies
@@ -225,7 +250,7 @@ Created comprehensive test suite (`test/integration_test.go`):
 - ✅ Memory: 9 tools, <2ms resource discovery
 - ✅ Fetch: 1 tool, optimal (already efficient)
 - ✅ Time: 2 tools, optimal (already efficient)
-- ✅ Sequential-thinking: 1 tool, optimal (already efficient) 
+- ✅ Sequential-thinking: 5 tools, persistent sessions with file-based storage
 - ✅ Maildir: 7 tools, <2ms resource discovery
 
 ### **⚙️ Configuration Updated**
@@ -246,7 +271,8 @@ Created comprehensive test suite (`test/integration_test.go`):
       "command": "/usr/local/bin/mcp-memory"
     }, 
     "sequential-thinking": {
-      "command": "/usr/local/bin/mcp-sequential-thinking"
+      "command": "/usr/local/bin/mcp-sequential-thinking",
+      "args": ["--session-file", "/tmp/thinking_sessions.json"]
     },
     "time": {
       "command": "/usr/local/bin/mcp-time"

@@ -19,7 +19,7 @@ A pure Go implementation of Model Context Protocol (MCP) servers, providing drop
 | **fetch**               | Web content fetching with HTML to Markdown conversion      | Complete |
 | **filesystem**          | Secure file operations with access controls                | Complete |
 | **git**                 | Git repository operations (status, add, commit, log, etc.) | Complete |
-| **maildir**             | Email archive analysis for maildir format                 | Design   |
+| **maildir**             | Email archive analysis for maildir format                 | Complete |
 | **memory**              | Knowledge graph persistent memory system                   | Complete |
 | **sequential-thinking** | Dynamic problem-solving with thought sequences             | Complete |
 | **time**                | Time and timezone conversion utilities                     | Complete |
@@ -158,21 +158,30 @@ MEMORY_FILE=/path/to/memory.json mcp-memory
 
 ### Sequential Thinking Server (`mcp-sequential-thinking`)
 
-Dynamic problem-solving through structured thought sequences.
+Dynamic problem-solving through structured thought sequences with persistent session management.
 
 **Tools:**
-- `sequentialthinking` - Process thoughts with context and branching
+- `sequentialthinking` - Process thoughts with session persistence and branching
+- `get_session_history` - Retrieve complete session thought history
+- `list_sessions` - List all active thinking sessions  
+- `get_branch_history` - Get thought history for specific branches
+- `clear_session` - Clear completed sessions and branches
 
 **Features:**
-- Thought sequence tracking
-- Revision and branching support
-- Progress indicators
-- Solution extraction
-- Context management
+- **Session Persistence**: Sessions survive server restarts with JSON storage
+- **Branch Tracking**: Create alternative reasoning paths from any thought
+- **Revision Support**: Mark and track thought revisions with context
+- **Progress Indicators**: Visual progress bars and status tracking
+- **Solution Extraction**: Automatic extraction from final thoughts
+- **Thread-Safe Operations**: Concurrent access to sessions and branches
 
 **Usage:**
 ```bash
+# Without persistence (sessions lost on restart)
 mcp-sequential-thinking
+
+# With session persistence
+mcp-sequential-thinking --session-file /path/to/sessions.json
 ```
 
 ### Time Server (`mcp-time`)