telegram: add session management commands (/sessions, /resume, /prune)

- SessionManager: ListSessions, ResumeSession(id), PruneSessions(days)
- GetOrCreate now falls back to disk store on cache miss — sessions
  survive bot restarts without explicit /resume
- /sessions lists recent sessions with turn count, age, task preview
- /resume <id> switches to a session by ID or task prefix match
- /prune [days] removes sessions older than N days (default: 30)
- Updated /start to list new commands

Author: jkyberneees

cmd/odek/telegram.go

@@ -6,6 +6,7 @@ import (
 	"os"
 	"os/signal"
 	"sort"
+	"strconv"
 	"strings"
 	"sync"
 	"sync/atomic"
@@ -150,6 +151,72 @@ func telegramCmd(args []string) error {
 			return formatStats(cs), nil
 		}
 
+		// Handle /sessions — list recent sessions from the store.
+		if cmdName == "sessions" {
+			infos, err := sessionManager.ListSessions(10)
+			if err != nil {
+				return fmt.Sprintf("❌ Failed to list sessions: %v", err), nil
+			}
+			if len(infos) == 0 {
+				return "📋 *Sessions*\n\nNo sessions found. Start a conversation first.", nil
+			}
+			var b strings.Builder
+			b.WriteString("📋 *Sessions*\n\n")
+			for _, s := range infos {
+				ago := time.Since(s.UpdatedAt).Round(time.Minute)
+				fmt.Fprintf(&b, "`%s` — %d turns, %s ago\n", s.ID, s.Turns, ago)
+				if s.Task != "" {
+					taskPreview := s.Task
+					if len(taskPreview) > 50 {
+						taskPreview = taskPreview[:50] + "…"
+					}
+					fmt.Fprintf(&b, "  _%s_\n", taskPreview)
+				}
+			}
+			b.WriteString("\nUse `/resume <id>` to continue a session.")
+			return b.String(), nil
+		}
+
+		// Handle /resume <id> — switch to a different session.
+		if cmdName == "resume" {
+			sessionID := strings.TrimSpace(argsStr)
+			if sessionID == "" {
+				return "❗ Usage: `/resume <session-id>`\n\nUse `/sessions` to see available sessions.", nil
+			}
+			cs, err := sessionManager.ResumeSession(chatID, sessionID)
+			if err != nil {
+				return fmt.Sprintf("❌ %v", err), nil
+			}
+			taskPreview := cs.Messages[0].Content
+			if len(taskPreview) > 80 {
+				taskPreview = taskPreview[:80] + "…"
+			}
+			return fmt.Sprintf(
+				"✅ *Session resumed*: `%s`\n\n%d turns • %d messages\n_%s_\n\nSend a message to continue.",
+				cs.SessionID, cs.TurnCount, len(cs.Messages), taskPreview,
+			), nil
+		}
+
+		// Handle /prune [days] — clean up old sessions.
+		if cmdName == "prune" {
+			days := 30
+			if strings.TrimSpace(argsStr) != "" {
+				if d, err := strconv.Atoi(strings.TrimSpace(argsStr)); err == nil && d > 0 {
+					days = d
+				} else {
+					return "❗ Usage: `/prune [days]`\n\nExample: `/prune 7` to remove sessions older than 7 days.", nil
+				}
+			}
+			removed, err := sessionManager.PruneSessions(days)
+			if err != nil {
+				return fmt.Sprintf("❌ Failed to prune sessions: %v", err), nil
+			}
+			if removed == 0 {
+				return fmt.Sprintf("📋 *Prune* — No sessions older than %d days found.", days), nil
+			}
+			return fmt.Sprintf("🧹 *Pruned* — Removed %d session(s) older than %d days.", removed, days), nil
+		}
+
 		return cmd.Handler(argsStr)
 	}
 

internal/telegram/commands.go

@@ -54,6 +54,21 @@ func init() {
 			Description: "Restart the bot process gracefully",
 			Handler:     restartHandler,
 		},
+		{
+			Command:     "sessions",
+			Description: "List recent conversation sessions",
+			Handler:     sessionsHandler,
+		},
+		{
+			Command:     "resume",
+			Description: "Resume a previous session by ID",
+			Handler:     resumeHandler,
+		},
+		{
+			Command:     "prune",
+			Description: "Clean up old sessions (default: 30 days)",
+			Handler:     pruneHandler,
+		},
 	}
 }
 
@@ -64,6 +79,9 @@ func startHandler(args string) (string, error) {
 		"/help — Show available commands\n" +
 		"/new — Reset conversation\n" +
 		"/stats — Show session statistics\n" +
+		"/sessions — List recent sessions\n" +
+		"/resume <id> — Resume a previous session\n" +
+		"/prune [days] — Clean up old sessions\n" +
 		"/stop — Cancel running task\n\n" +
 		"Send me a message and I will help!", nil
 }
@@ -104,6 +122,18 @@ func restartHandler(args string) (string, error) {
 	return "🔄 *Restarting...*\n\nThe bot will restart momentarily. This may take a few seconds.", nil
 }
 
+func sessionsHandler(args string) (string, error) {
+	return "📋 *Sessions* — Listing sessions is handled inline.", nil
+}
+
+func resumeHandler(args string) (string, error) {
+	return "✅ *Resume* — Session resume is handled inline.", nil
+}
+
+func pruneHandler(args string) (string, error) {
+	return "🧹 *Prune* — Session cleanup is handled inline.", nil
+}
+
 // FindCommand returns the command descriptor with the matching name, or nil.
 func FindCommand(name string) *CommandDescriptor {
 	for i := range DefaultCommands {

internal/telegram/session.go

@@ -3,6 +3,7 @@ package telegram
 
 import (
 	"fmt"
+	"strings"
 	"sync"
 	"time"
 
@@ -53,9 +54,10 @@ func NewSessionManager(store *session.Store, ttl time.Duration) *SessionManager
 // ── Methods ────────────────────────────────────────────────────────────
 
 // GetOrCreate returns the ChatSession for the given chatID.
-// It checks the in-memory cache first; if the entry exists and hasn't
-// expired (24h), it is returned directly. Otherwise a new ChatSession
-// is created with a "tg-<chatID>" session ID, cached, and returned.
+// Checks the in-memory cache first, then the backing session store,
+// and only creates a new empty session as a last resort. This ensures
+// conversations survive bot restarts without the user needing to ask
+// for resume explicitly.
 func (sm *SessionManager) GetOrCreate(chatID int64) (*ChatSession, error) {
 	sm.Mu.RLock()
 	cs, ok := sm.Cache[chatID]
@@ -65,6 +67,11 @@ func (sm *SessionManager) GetOrCreate(chatID int64) (*ChatSession, error) {
 		return cs, nil
 	}
 
+	// Missed cache — try the backing store before creating fresh.
+	if loaded, _ := sm.Load(chatID); loaded != nil {
+		return loaded, nil
+	}
+
 	cs = &ChatSession{
 		ChatID:     chatID,
 		SessionID:  fmt.Sprintf("tg-%d", chatID),
@@ -177,3 +184,93 @@ func (sm *SessionManager) AppendMessage(chatID int64, role string, content strin
 	cs.Messages = append(cs.Messages, llm.Message{Role: role, Content: content})
 	return sm.Save(chatID, cs.Messages)
 }
+
+// ── Session Management ─────────────────────────────────────────────────
+
+// SessionInfo is a lightweight summary of a session for listing.
+type SessionInfo struct {
+	ID        string    // session ID (e.g. "tg-12345")
+	Task      string    // first user message or label
+	CreatedAt time.Time // when the session started
+	UpdatedAt time.Time // last activity
+	Turns     int       // number of user turns
+}
+
+// ListSessions returns metadata for all sessions in the backing store,
+// sorted by most-recent-first, limited to `limit` entries. If limit <= 0,
+// all sessions are returned.
+func (sm *SessionManager) ListSessions(limit int) ([]SessionInfo, error) {
+	sessions, err := sm.Store.List(limit)
+	if err != nil {
+		return nil, fmt.Errorf("list sessions: %w", err)
+	}
+	infos := make([]SessionInfo, len(sessions))
+	for i, s := range sessions {
+		infos[i] = SessionInfo{
+			ID:        s.ID,
+			Task:      s.Task,
+			CreatedAt: s.CreatedAt,
+			UpdatedAt: s.UpdatedAt,
+			Turns:     s.Turns,
+		}
+	}
+	return infos, nil
+}
+
+// ResumeSession loads a session from the backing store and binds it to
+// the given chatID. This replaces any existing session for that chat.
+// sessionID can be a partial prefix match — the first matching session
+// (by ID prefix or task contains) is used. Returns the new ChatSession
+// or an error if no matching session is found.
+func (sm *SessionManager) ResumeSession(chatID int64, sessionID string) (*ChatSession, error) {
+	if sessionID == "" {
+		return nil, fmt.Errorf("session ID required — use /sessions to list")
+	}
+
+	// Try direct load first.
+	sess, err := sm.Store.Load(sessionID)
+	if err != nil || sess == nil {
+		// Prefix match: search all sessions for a match.
+		all, listErr := sm.Store.List(0)
+		if listErr != nil {
+			return nil, fmt.Errorf("list sessions: %w", listErr)
+		}
+		for _, s := range all {
+			if strings.HasPrefix(s.ID, sessionID) ||
+				strings.Contains(strings.ToLower(s.Task), strings.ToLower(sessionID)) {
+				sess = &s
+				break
+			}
+		}
+	}
+
+	if sess == nil {
+		return nil, fmt.Errorf("no session found matching %q", sessionID)
+	}
+
+	// Build ChatSession and cache it.
+	cs := &ChatSession{
+		ChatID:     chatID,
+		SessionID:  sess.ID,
+		Messages:   sess.Messages,
+		CreatedAt:  sess.CreatedAt,
+		LastActive: time.Now(),
+		TurnCount:  sess.Turns,
+	}
+
+	sm.Mu.Lock()
+	sm.Cache[chatID] = cs
+	sm.Mu.Unlock()
+
+	return cs, nil
+}
+
+// PruneSessions deletes sessions that haven't been updated in `days` days
+// or more. Returns the number of sessions removed.
+func (sm *SessionManager) PruneSessions(days int) (int, error) {
+	if days <= 0 {
+		days = 30
+	}
+	before := time.Now().Add(-time.Duration(days) * 24 * time.Hour)
+	return sm.Store.Cleanup(before)
+}