Think Strategies

Instructions

Implementation Reference

• index.js:1875-2085 (handler)

  The handler function that implements the core logic of the 'think-session-manager' tool. It processes actions ('list', 'get', 'resume', 'search') by calling methods on the shared sessionStorage instance (ThinkingSessionStorage), handling pagination, filtering, searching, and resuming sessions.

  async (args) => {
    try {
      switch (args.action) {
        case "list":
          const listOptions = {
            limit: args.limit,
            offset: args.offset,
            strategy: args.strategy,
            includeTopics: args.includeTopics,
            sortBy: args.sortBy
          };
          
          const listResult = await sessionStorage.listSessions(listOptions);
          
          return {
            content: [{
              type: "text",
              text: JSON.stringify({
                action: "list",
                total: listResult.total,
                offset: listResult.offset,
                limit: listResult.limit,
                hasMore: listResult.hasMore,
                sessions: listResult.sessions.map(s => ({
                  sessionId: s.id.split('-').slice(-2).join('-'), // Extract timestamp portion  
                  description: s.sessionPurpose || s.topics?.[0]?.term + ' analysis' || 'General thinking session',
                  strategy: s.strategy,
                  quality: s.qualityRating ? Object.values(s.qualityRating).filter(v => typeof v === 'number').reduce((sum, val, _, arr) => sum + val / arr.length, 0).toFixed(1) : null,
                  duration: s.automaticMetrics?.duration || null,
                  thoughtCount: s.thoughtCount,
                  completion: s.completion,
                  complexity: s.complexity,
                  age: s.age
                }))
              }, null, 2)
            }]
          };
  
        case "get":
          if (!args.sessionId) {
            throw new Error("sessionId required for 'get' action");
          }
          
          // Handle both full session ID and shortened version
          let fullSessionId = args.sessionId;
          if (!args.sessionId.includes('session-')) {
            // If it's a shortened ID, we need to find the full ID
            const allSessions = await sessionStorage.listSessions({ limit: 1000 });
            const matchingSession = allSessions.sessions.find(s => 
              s.id.split('-').slice(-2).join('-') === args.sessionId
            );
            if (matchingSession) {
              fullSessionId = matchingSession.id;
            }
          }
          
          const session = await sessionStorage.getSession(fullSessionId);
          
          if (!session) {
            throw new Error(`Session not found: ${args.sessionId}`);
          }
          
          const sessionAnalysis = {
            id: session.id,
            strategy: session.strategy,
            timestamp: session.timestamp,
            thoughtHistory: session.thoughtHistory.map(t => ({
              thoughtNumber: t.thoughtNumber,
              absoluteNumber: t.absoluteNumber,
              sequenceNumber: t.sequenceNumber,
              thought: t.thought.substring(0, 150) + (t.thought.length > 150 ? '...' : ''),
              stage: t.currentStage,
              hasActions: t.plannedActions ? t.plannedActions.length > 0 : false,
              hasResults: t.actionResults ? t.actionResults.length > 0 : false
            })),
            branches: Object.keys(session.branches),
            topics: sessionStorage.extractTopics(session.thoughtHistory),
            complexity: sessionStorage.calculateComplexity(session.thoughtHistory, session.branches),
            completion: sessionStorage.getCompletionStatus(session.thoughtHistory),
            summary: {
              totalThoughts: session.thoughtHistory.length,
              totalBranches: Object.keys(session.branches).length,
              finalStage: session.thoughtHistory[session.thoughtHistory.length - 1]?.currentStage,
              completed: !session.thoughtHistory[session.thoughtHistory.length - 1]?.nextThoughtNeeded
            }
          };
          
          return {
            content: [{
              type: "text",
              text: JSON.stringify({
                action: "get",
                ...sessionAnalysis
              }, null, 2)
            }]
          };
  
        case "search":
          if (!args.query) {
            throw new Error("query required for 'search' action");
          }
          
          const searchOptions = {
            limit: args.limit,
            offset: args.offset,
            minScore: args.minScore,
            strategy: args.strategy,
            completionStatus: args.completionStatus
          };
          
          const searchResult = await sessionStorage.searchSessions(args.query, searchOptions);
          
          return {
            content: [{
              type: "text",
              text: JSON.stringify({
                action: "search",
                query: args.query,
                ...searchResult,
                sessions: searchResult.sessions.map(s => ({
                  sessionId: s.id.split('-').slice(-2).join('-'), // Extract timestamp portion for shorter ID
                  description: s.sessionPurpose || s.thoughtHistory[0]?.thought.substring(0, 100) + '...' || 'No description available',
                  strategy: s.strategy,
                  quality: s.qualityRating ? Object.values(s.qualityRating).filter(v => typeof v === 'number').reduce((sum, val, _, arr) => sum + val / arr.length, 0).toFixed(1) : null,
                  duration: s.automaticMetrics?.duration || null,
                  completion: s.completion,
                  searchScore: s.searchScore.toFixed(2),
                  matchedTerms: s.matchedTerms,
                  age: `${Math.round((Date.now() - new Date(s.timestamp)) / (1000 * 60))}m ago`
                }))
              }, null, 2)
            }]
          };
  
        case "resume":
          if (!args.sessionId) {
            throw new Error("sessionId required for 'resume' action");
          }
          
          // Handle both full session ID and shortened version
          let fullResumeSessionId = args.sessionId;
          if (!args.sessionId.includes('session-')) {
            // If it's a shortened ID, we need to find the full ID
            const allSessions = await sessionStorage.listSessions({ limit: 1000 });
            const matchingSession = allSessions.sessions.find(s => 
              s.id.split('-').slice(-2).join('-') === args.sessionId
            );
            if (matchingSession) {
              fullResumeSessionId = matchingSession.id;
            }
          }
          
          const resumeSession = await sessionStorage.getSession(fullResumeSessionId);
          
          if (!resumeSession) {
            throw new Error(`Session not found: ${args.sessionId}`);
          }
          
          // Restore session state
          thinkingServer.thoughtHistory = resumeSession.thoughtHistory;
          thinkingServer.branches = resumeSession.branches;
          thinkingServer.sessionId = resumeSession.id;
          thinkingServer.strategy = resumeSession.strategy;
          thinkingServer.stageManager = new StageManager(resumeSession.strategy);
          thinkingServer.isInitialized = true;
          
          // Reconstruct dual numbering from history
          const lastThought = resumeSession.thoughtHistory[resumeSession.thoughtHistory.length - 1];
          thinkingServer.absoluteThoughtNumber = lastThought?.absoluteNumber || 0;
          thinkingServer.sequenceThoughtNumber = lastThought?.sequenceNumber || 0;
          
          // Set stage to last known stage
          if (lastThought?.currentStage) {
            thinkingServer.stageManager.currentStage = lastThought.currentStage;
          }
          
          console.error(`📚 Resumed session: ${resumeSession.id} (${resumeSession.strategy})`);
          
          // Build semantic response for current state
          const semanticResponse = thinkingServer.parameterRouter.buildSemanticResponse(
            thinkingServer.strategy,
            thinkingServer.stageManager.getCurrentStage(),
            thinkingServer.thoughtHistory,
            thinkingServer.sessionId
          );
          
          return {
            content: [{
              type: "text",
              text: JSON.stringify({
                action: "resume",
                message: `Resumed session: ${resumeSession.id}`,
                strategy: resumeSession.strategy,
                thoughtCount: resumeSession.thoughtHistory.length,
                currentState: semanticResponse.currentState,
                absoluteThoughtNumber: thinkingServer.absoluteThoughtNumber,
                sequenceThoughtNumber: thinkingServer.sequenceThoughtNumber,
                availableActions: semanticResponse.availableActions,
                lastThought: lastThought?.thought?.substring(0, 200) + (lastThought?.thought?.length > 200 ? '...' : '')
              }, null, 2)
            }]
          };
  
        default:
          throw new Error(`Unknown action: ${args.action}`);
      }
    } catch (error) {
      console.error(`ERROR: Session manager action '${args.action}' failed:`, error);
      throw error;
    }
  }

• index.js:1864-1874 (schema)

  Zod schema for input validation of the think-session-manager tool, defining parameters for different actions like listing, searching, and filtering sessions.

    action: z.enum(["list", "get", "resume", "search"]),
    sessionId: z.string().optional(),
    limit: z.number().optional().default(10),
    offset: z.number().optional().default(0),
    query: z.string().optional(),
    strategy: z.string().optional(),
    includeTopics: z.boolean().optional().default(false),
    sortBy: z.enum(["timestamp", "thoughtCount", "complexity", "quality", "duration"]).optional().default("timestamp"),
    completionStatus: z.enum(["empty", "started", "in-progress", "completed"]).optional(),
    minScore: z.number().optional().default(0.1)
  },

• index.js:1861-2087 (registration)

  MCP server tool registration for 'think-session-manager', including name, description, schema, and handler reference.

    "think-session-manager",
    "Manage thinking sessions: list with pagination/filtering, search by content, get detailed analysis, or resume previous sessions",
    {
      action: z.enum(["list", "get", "resume", "search"]),
      sessionId: z.string().optional(),
      limit: z.number().optional().default(10),
      offset: z.number().optional().default(0),
      query: z.string().optional(),
      strategy: z.string().optional(),
      includeTopics: z.boolean().optional().default(false),
      sortBy: z.enum(["timestamp", "thoughtCount", "complexity", "quality", "duration"]).optional().default("timestamp"),
      completionStatus: z.enum(["empty", "started", "in-progress", "completed"]).optional(),
      minScore: z.number().optional().default(0.1)
    },
    async (args) => {
      try {
        switch (args.action) {
          case "list":
            const listOptions = {
              limit: args.limit,
              offset: args.offset,
              strategy: args.strategy,
              includeTopics: args.includeTopics,
              sortBy: args.sortBy
            };
            
            const listResult = await sessionStorage.listSessions(listOptions);
            
            return {
              content: [{
                type: "text",
                text: JSON.stringify({
                  action: "list",
                  total: listResult.total,
                  offset: listResult.offset,
                  limit: listResult.limit,
                  hasMore: listResult.hasMore,
                  sessions: listResult.sessions.map(s => ({
                    sessionId: s.id.split('-').slice(-2).join('-'), // Extract timestamp portion  
                    description: s.sessionPurpose || s.topics?.[0]?.term + ' analysis' || 'General thinking session',
                    strategy: s.strategy,
                    quality: s.qualityRating ? Object.values(s.qualityRating).filter(v => typeof v === 'number').reduce((sum, val, _, arr) => sum + val / arr.length, 0).toFixed(1) : null,
                    duration: s.automaticMetrics?.duration || null,
                    thoughtCount: s.thoughtCount,
                    completion: s.completion,
                    complexity: s.complexity,
                    age: s.age
                  }))
                }, null, 2)
              }]
            };
  
          case "get":
            if (!args.sessionId) {
              throw new Error("sessionId required for 'get' action");
            }
            
            // Handle both full session ID and shortened version
            let fullSessionId = args.sessionId;
            if (!args.sessionId.includes('session-')) {
              // If it's a shortened ID, we need to find the full ID
              const allSessions = await sessionStorage.listSessions({ limit: 1000 });
              const matchingSession = allSessions.sessions.find(s => 
                s.id.split('-').slice(-2).join('-') === args.sessionId
              );
              if (matchingSession) {
                fullSessionId = matchingSession.id;
              }
            }
            
            const session = await sessionStorage.getSession(fullSessionId);
            
            if (!session) {
              throw new Error(`Session not found: ${args.sessionId}`);
            }
            
            const sessionAnalysis = {
              id: session.id,
              strategy: session.strategy,
              timestamp: session.timestamp,
              thoughtHistory: session.thoughtHistory.map(t => ({
                thoughtNumber: t.thoughtNumber,
                absoluteNumber: t.absoluteNumber,
                sequenceNumber: t.sequenceNumber,
                thought: t.thought.substring(0, 150) + (t.thought.length > 150 ? '...' : ''),
                stage: t.currentStage,
                hasActions: t.plannedActions ? t.plannedActions.length > 0 : false,
                hasResults: t.actionResults ? t.actionResults.length > 0 : false
              })),
              branches: Object.keys(session.branches),
              topics: sessionStorage.extractTopics(session.thoughtHistory),
              complexity: sessionStorage.calculateComplexity(session.thoughtHistory, session.branches),
              completion: sessionStorage.getCompletionStatus(session.thoughtHistory),
              summary: {
                totalThoughts: session.thoughtHistory.length,
                totalBranches: Object.keys(session.branches).length,
                finalStage: session.thoughtHistory[session.thoughtHistory.length - 1]?.currentStage,
                completed: !session.thoughtHistory[session.thoughtHistory.length - 1]?.nextThoughtNeeded
              }
            };
            
            return {
              content: [{
                type: "text",
                text: JSON.stringify({
                  action: "get",
                  ...sessionAnalysis
                }, null, 2)
              }]
            };
  
          case "search":
            if (!args.query) {
              throw new Error("query required for 'search' action");
            }
            
            const searchOptions = {
              limit: args.limit,
              offset: args.offset,
              minScore: args.minScore,
              strategy: args.strategy,
              completionStatus: args.completionStatus
            };
            
            const searchResult = await sessionStorage.searchSessions(args.query, searchOptions);
            
            return {
              content: [{
                type: "text",
                text: JSON.stringify({
                  action: "search",
                  query: args.query,
                  ...searchResult,
                  sessions: searchResult.sessions.map(s => ({
                    sessionId: s.id.split('-').slice(-2).join('-'), // Extract timestamp portion for shorter ID
                    description: s.sessionPurpose || s.thoughtHistory[0]?.thought.substring(0, 100) + '...' || 'No description available',
                    strategy: s.strategy,
                    quality: s.qualityRating ? Object.values(s.qualityRating).filter(v => typeof v === 'number').reduce((sum, val, _, arr) => sum + val / arr.length, 0).toFixed(1) : null,
                    duration: s.automaticMetrics?.duration || null,
                    completion: s.completion,
                    searchScore: s.searchScore.toFixed(2),
                    matchedTerms: s.matchedTerms,
                    age: `${Math.round((Date.now() - new Date(s.timestamp)) / (1000 * 60))}m ago`
                  }))
                }, null, 2)
              }]
            };
  
          case "resume":
            if (!args.sessionId) {
              throw new Error("sessionId required for 'resume' action");
            }
            
            // Handle both full session ID and shortened version
            let fullResumeSessionId = args.sessionId;
            if (!args.sessionId.includes('session-')) {
              // If it's a shortened ID, we need to find the full ID
              const allSessions = await sessionStorage.listSessions({ limit: 1000 });
              const matchingSession = allSessions.sessions.find(s => 
                s.id.split('-').slice(-2).join('-') === args.sessionId
              );
              if (matchingSession) {
                fullResumeSessionId = matchingSession.id;
              }
            }
            
            const resumeSession = await sessionStorage.getSession(fullResumeSessionId);
            
            if (!resumeSession) {
              throw new Error(`Session not found: ${args.sessionId}`);
            }
            
            // Restore session state
            thinkingServer.thoughtHistory = resumeSession.thoughtHistory;
            thinkingServer.branches = resumeSession.branches;
            thinkingServer.sessionId = resumeSession.id;
            thinkingServer.strategy = resumeSession.strategy;
            thinkingServer.stageManager = new StageManager(resumeSession.strategy);
            thinkingServer.isInitialized = true;
            
            // Reconstruct dual numbering from history
            const lastThought = resumeSession.thoughtHistory[resumeSession.thoughtHistory.length - 1];
            thinkingServer.absoluteThoughtNumber = lastThought?.absoluteNumber || 0;
            thinkingServer.sequenceThoughtNumber = lastThought?.sequenceNumber || 0;
            
            // Set stage to last known stage
            if (lastThought?.currentStage) {
              thinkingServer.stageManager.currentStage = lastThought.currentStage;
            }
            
            console.error(`📚 Resumed session: ${resumeSession.id} (${resumeSession.strategy})`);
            
            // Build semantic response for current state
            const semanticResponse = thinkingServer.parameterRouter.buildSemanticResponse(
              thinkingServer.strategy,
              thinkingServer.stageManager.getCurrentStage(),
              thinkingServer.thoughtHistory,
              thinkingServer.sessionId
            );
            
            return {
              content: [{
                type: "text",
                text: JSON.stringify({
                  action: "resume",
                  message: `Resumed session: ${resumeSession.id}`,
                  strategy: resumeSession.strategy,
                  thoughtCount: resumeSession.thoughtHistory.length,
                  currentState: semanticResponse.currentState,
                  absoluteThoughtNumber: thinkingServer.absoluteThoughtNumber,
                  sequenceThoughtNumber: thinkingServer.sequenceThoughtNumber,
                  availableActions: semanticResponse.availableActions,
                  lastThought: lastThought?.thought?.substring(0, 200) + (lastThought?.thought?.length > 200 ? '...' : '')
                }, null, 2)
              }]
            };
  
          default:
            throw new Error(`Unknown action: ${args.action}`);
        }
      } catch (error) {
        console.error(`ERROR: Session manager action '${args.action}' failed:`, error);
        throw error;
      }
    }
  );

• index.js:1383-1655 (helper)

  ThinkingSessionStorage class providing helper methods for session persistence, listing, searching, analysis (topics, complexity, completion status), and resumption. Used by the tool handler for all session operations.

  class ThinkingSessionStorage {
      constructor(storagePath) {
          this.storagePath = storagePath;
      }
  
      calculateAutomaticMetrics(thoughtHistory, sessionStartTime, hasActions) {
          const sessionEndTime = new Date().toISOString();
          const durationMs = new Date(sessionEndTime) - new Date(sessionStartTime);
          const durationMinutes = Math.round(durationMs / (1000 * 60));
          
          // Calculate iteration ratio (revisions / total thoughts)
          const revisionCount = thoughtHistory.filter(t => t.isRevision).length;
          const iterationRatio = thoughtHistory.length > 0 ? revisionCount / thoughtHistory.length : 0;
          
          return {
              duration: durationMinutes,
              iterationRatio: Math.round(iterationRatio * 100) / 100, // Round to 2 decimals
              toolIntegration: hasActions
          };
      }
  
      async saveSession(sessionId, thoughtHistory, branches, sessionPurpose = null, qualityRating = null, sessionStartTime = null) {
          const sessionDir = path.join(this.storagePath, sessionId);
          await fs.ensureDir(sessionDir);
          
          // Calculate automatic metrics
          const hasActions = thoughtHistory.some(t => t.plannedActions || t.actionResults);
          const automaticMetrics = sessionStartTime ? 
              this.calculateAutomaticMetrics(thoughtHistory, sessionStartTime, hasActions) : 
              null;
          
          const sessionData = {
              id: sessionId,
              timestamp: new Date().toISOString(),
              strategy: sessionId.split('-')[0], // Extract strategy from sessionId
              sessionPurpose,
              qualityRating,
              automaticMetrics,
              thoughtHistory,
              branches
          };
          
          const filePath = path.join(sessionDir, 'session.json');
          await fs.writeJson(filePath, sessionData, { spaces: 2 });
          
          return filePath;
      }
  
      // Extract key topics and terms from thought content
      extractTopics(thoughtHistory) {
          const allText = thoughtHistory.map(t => t.thought).join(' ');
          
          // Simple topic extraction - remove common words and get meaningful terms
          const stopWords = new Set(['the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with', 'by', 'from', 'up', 'about', 'into', 'through', 'during', 'before', 'after', 'above', 'below', 'between', 'among', 'this', 'that', 'these', 'those', 'i', 'you', 'he', 'she', 'it', 'we', 'they', 'me', 'him', 'her', 'us', 'them', 'my', 'your', 'his', 'her', 'its', 'our', 'their', 'am', 'is', 'are', 'was', 'were', 'be', 'been', 'being', 'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could', 'should', 'may', 'might', 'must', 'can', 'shall']);
          
          const words = allText.toLowerCase()
              .replace(/[^\w\s]/g, ' ')
              .split(/\s+/)
              .filter(word => word.length > 2 && !stopWords.has(word));
          
          // Count word frequency
          const wordCounts = {};
          words.forEach(word => {
              wordCounts[word] = (wordCounts[word] || 0) + 1;
          });
          
          // Get top terms
          const topTerms = Object.entries(wordCounts)
              .sort(([,a], [,b]) => b - a)
              .slice(0, 8)
              .map(([word, count]) => ({ term: word, frequency: count }));
          
          return topTerms;
      }
  
      // Calculate session complexity based on branching, actions, and thought depth
      calculateComplexity(thoughtHistory, branches) {
          const thoughtComplexity = thoughtHistory.length;
          const branchComplexity = Object.keys(branches).length * 2;
          const actionComplexity = thoughtHistory.filter(t => t.plannedActions || t.actionResults).length;
          
          const totalComplexity = thoughtComplexity + branchComplexity + actionComplexity;
          
          if (totalComplexity < 5) return 'simple';
          if (totalComplexity < 15) return 'moderate';
          if (totalComplexity < 30) return 'complex';
          return 'very-complex';
      }
  
      // Determine completion status
      getCompletionStatus(thoughtHistory) {
          if (thoughtHistory.length === 0) return 'empty';
          
          const lastThought = thoughtHistory[thoughtHistory.length - 1];
          const hasConclusion = lastThought.finalAnswer || !lastThought.nextThoughtNeeded;
          const hasSignificantProgress = thoughtHistory.length >= 3;
          
          if (hasConclusion && hasSignificantProgress) return 'completed';
          if (hasSignificantProgress) return 'in-progress';
          return 'started';
      }
  
      // Search sessions by content with term scoring
      async searchSessions(query, options = {}) {
          const {
              limit = 10,
              offset = 0,
              minScore = 0.1,
              strategy = null,
              completionStatus = null
          } = options;
          
          const sessions = await this.getAllSessions();
          const queryTerms = query.toLowerCase().split(/\s+/).filter(term => term.length > 2);
          
          const scoredSessions = sessions.map(session => {
              const sessionText = session.thoughtHistory.map(t => t.thought).join(' ').toLowerCase();
              
              // Calculate relevance score
              let score = 0;
              queryTerms.forEach(term => {
                  const regex = new RegExp(term, 'gi');
                  const matches = sessionText.match(regex) || [];
                  score += matches.length;
              });
              
              // Normalize by session length
              const normalizedScore = score / Math.max(sessionText.length / 1000, 1);
              
              return {
                  ...session,
                  searchScore: normalizedScore,
                  matchedTerms: queryTerms.filter(term => sessionText.includes(term))
              };
          });
          
          // Filter and sort by relevance
          let filteredSessions = scoredSessions
              .filter(s => s.searchScore >= minScore)
              .filter(s => !strategy || s.strategy === strategy)
              .filter(s => !completionStatus || s.completion === completionStatus)
              .sort((a, b) => b.searchScore - a.searchScore);
          
          const total = filteredSessions.length;
          filteredSessions = filteredSessions.slice(offset, offset + limit);
          
          return {
              sessions: filteredSessions,
              total,
              offset,
              limit,
              hasMore: offset + limit < total
          };
      }
  
      async listSessions(options = {}) {
          const {
              limit = 10,
              offset = 0,
              strategy = null,
              includeTopics = false,
              sortBy = 'timestamp' // timestamp, thoughtCount, complexity
          } = options;
          
          await fs.ensureDir(this.storagePath);
          const dirs = await fs.readdir(this.storagePath);
          
          const sessions = [];
          for (const dir of dirs) {
              const sessionPath = path.join(this.storagePath, dir, 'session.json');
              if (await fs.pathExists(sessionPath)) {
                  try {
                      const sessionData = await fs.readJson(sessionPath);
                      
                      const sessionInfo = {
                          id: sessionData.id,
                          timestamp: sessionData.timestamp,
                          strategy: sessionData.strategy || "unknown",
                          sessionPurpose: sessionData.sessionPurpose,
                          qualityRating: sessionData.qualityRating,
                          automaticMetrics: sessionData.automaticMetrics,
                          thoughtCount: sessionData.thoughtHistory.length,
                          branchCount: Object.keys(sessionData.branches).length,
                          completion: this.getCompletionStatus(sessionData.thoughtHistory),
                          complexity: this.calculateComplexity(sessionData.thoughtHistory, sessionData.branches),
                          age: `${Math.round((Date.now() - new Date(sessionData.timestamp)) / (1000 * 60))} minutes ago`
                      };
                      
                      if (includeTopics) {
                          sessionInfo.topics = this.extractTopics(sessionData.thoughtHistory);
                      }
                      
                      sessions.push(sessionInfo);
                  } catch (error) {
                      console.error(`Error reading session ${dir}:`, error);
                  }
              }
          }
          
          // Filter by strategy if specified
          const filteredSessions = strategy ? 
              sessions.filter(s => s.strategy === strategy) : 
              sessions;
          
          // Sort sessions
          filteredSessions.sort((a, b) => {
              switch (sortBy) {
                  case 'thoughtCount':
                      return b.thoughtCount - a.thoughtCount;
                  case 'complexity':
                      const complexityOrder = { 'simple': 1, 'moderate': 2, 'complex': 3, 'very-complex': 4 };
                      return complexityOrder[b.complexity] - complexityOrder[a.complexity];
                  case 'quality':
                      // Calculate average quality score
                      const getAvgQuality = (session) => {
                          if (!session.qualityRating) return 0;
                          const ratings = Object.values(session.qualityRating).filter(v => typeof v === 'number');
                          return ratings.length > 0 ? ratings.reduce((sum, val) => sum + val, 0) / ratings.length : 0;
                      };
                      return getAvgQuality(b) - getAvgQuality(a);
                  case 'duration':
                      const getDuration = (session) => session.automaticMetrics?.duration || 0;
                      return getDuration(a) - getDuration(b); // Shorter duration first (more efficient)
                  case 'timestamp':
                  default:
                      return new Date(b.timestamp) - new Date(a.timestamp);
              }
          });
          
          const total = filteredSessions.length;
          const paginatedSessions = filteredSessions.slice(offset, offset + limit);
          
          return {
              sessions: paginatedSessions,
              total,
              offset,
              limit,
              hasMore: offset + limit < total
          };
      }
  
      async getAllSessions() {
          await fs.ensureDir(this.storagePath);
          const dirs = await fs.readdir(this.storagePath);
          
          const sessions = [];
          for (const dir of dirs) {
              const sessionPath = path.join(this.storagePath, dir, 'session.json');
              if (await fs.pathExists(sessionPath)) {
                  try {
                      const sessionData = await fs.readJson(sessionPath);
                      sessions.push({
                          ...sessionData,
                          completion: this.getCompletionStatus(sessionData.thoughtHistory),
                          complexity: this.calculateComplexity(sessionData.thoughtHistory, sessionData.branches)
                      });
                  } catch (error) {
                      console.error(`Error reading session ${dir}:`, error);
                  }
              }
          }
          
          return sessions;
      }
  
      async getSession(sessionId) {
          const sessionPath = path.join(this.storagePath, sessionId, 'session.json');
          if (await fs.pathExists(sessionPath)) {
              return await fs.readJson(sessionPath);
          }
          return null;
      }
  }