feat: archive sessions on /new instead of deleting + fix deepsearch test

- /new now archives the current session with a timestamped ID
  (tg-<chatID>-<YYYYMMDD>-<HHMMSS>) before starting fresh
- Old sessions are preserved on disk and visible via ID                     Turns Model                          Task
────────────────────────────────────────────────────────────────────────────────
20260526-09f2cd        1                                    say hello
tg-8592463065          8                                    tg-8592463065
20260526-c08a4b        1                                    say hello
20260526-2f29f7        1                                    say hello
20260526-7ada42        1                                    say hello
20260526-4733b2        1                                    say hello
20260526-227902        1                                    say hello
20260526-0d53d2        1                                    say hello
20260526-1033c9        1                                    use session_search to find ses…
20260526-8e91f1        1                                    use the session_search tool to…
20260526-bfe9b1        1                                    say hello
20260525-f02b9b        1                                    say hello
20260525-85e6a7        1                                    say hello
20260525-7ba97f        1                                    say hello
20260525-d2ddff        1                                    say hello
20260525-a52811        1                                    say hello
20260525-b56d2b        1                                    say hello
20260525-3176bc        1                                    say hello
20260525-045d89        1                                    say hello
20260525-17b966        1                                    say hello
- DeepSearch test rewritten to use isolated temp stores instead of
  depending on production ~/.odek/sessions/ data

Author: molty3000

cmd/odek/telegram.go

@@ -233,15 +233,19 @@ func telegramCmd(args []string) error {
 			return "🔄 *Restarting...*\n\nThe bot will restart momentarily. This may take a few seconds.", nil
 		}
 
-		// Handle /new — clear session and reset trust in the approver.
+		// Handle /new — archive the current session and start fresh.
+		// The current session is preserved as a timestamped archive file
+		// so it can be revisited via `odek session list`.
 		if cmdName == "new" {
-			sessionManager.Delete(chatID)
+			if err := sessionManager.ArchiveAndDelete(chatID); err != nil {
+				handlerLog.Warn("archive session", "chat_id", chatID, "error", err)
+			}
 			chatMu.Delete(chatID) // prevent mutex leak on session reset
 			if a := handler.GetApprover(chatID); a != nil {
 				a.ResetTrust()
 			}
 			var b strings.Builder
-			b.WriteString("🔄 *New session started*\n\n")
+			b.WriteString("🔄 *Session archived, starting fresh*\n\n")
 			b.WriteString(fmt.Sprintf("• Model: `%s`\n", resolved.Model))
 			if resolved.Sandbox {
 				b.WriteString("• Sandbox: enabled\n")

docs/CHANGELOG.md

@@ -1,6 +1,9 @@
 # Changelog
 <!-- NOTE: This file is auto-generated by generate-changelog.sh. Manual edits will be overwritten. -->
 
+## v0.58.8 (2026-05-26) — Release
+<!-- NOTE: This file is auto-generated by generate-changelog.sh. Manual edits will be overwritten. -->
+
 
 ## v0.58.7 (2026-05-26) — Replace hardcoded version badge with dynamic Shields.io release badge
 
@@ -1417,4 +1420,3 @@
 ### Infrastructure
 - docs: add README
 - chore: remove binary, add .gitignore
-

internal/session/deepsearch_test.go

@@ -0,0 +1,162 @@
+package session
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/BackendStack21/odek/internal/llm"
+)
+
+func TestDeepSearch_TokenMatch(t *testing.T) {
+	store := newTestStore(t)
+
+	// Create a session with content that should trigger token matches.
+	msgs := []llm.Message{
+		{Role: "user", Content: "what go-vector changes did you make to the modifications?"},
+		{Role: "assistant", Content: "I updated the vector index with new updates and modifications."},
+	}
+	_, err := store.Create(msgs, "test-model", "test go-vector changes")
+	if err != nil {
+		t.Fatalf("Create: %v", err)
+	}
+
+	// Token-based matching: simulate deepSearch logic
+	tokens := []string{"go-vector", "changes", "modifications", "updates"}
+	matchedTokens := make(map[string]bool, len(tokens))
+	sessions, err := store.List(0)
+	if err != nil {
+		t.Fatalf("List: %v", err)
+	}
+	if len(sessions) == 0 {
+		t.Fatal("no sessions found")
+	}
+	for _, s := range sessions {
+		full, err := store.Load(s.ID)
+		if err != nil {
+			continue
+		}
+		for _, msg := range full.Messages {
+			if msg.Role != "user" && msg.Role != "assistant" {
+				continue
+			}
+			lower := strings.ToLower(msg.Content)
+			for _, tok := range tokens {
+				if len(tok) < 2 || matchedTokens[tok] {
+					continue
+				}
+				if strings.Contains(lower, tok) {
+					matchedTokens[tok] = true
+				}
+			}
+		}
+	}
+
+	if len(matchedTokens) < 2 {
+		t.Errorf("deepSearch matched %d tokens (need >= 2)", len(matchedTokens))
+		for tok := range matchedTokens {
+			t.Logf("  matched: %s", tok)
+		}
+		for _, tok := range tokens {
+			if !matchedTokens[tok] {
+				t.Logf("  not matched: %s", tok)
+			}
+		}
+	}
+}
+
+func TestDeepSearch_NoMatch(t *testing.T) {
+	store := newTestStore(t)
+
+	// Create a session with unrelated content.
+	msgs := []llm.Message{
+		{Role: "user", Content: "hello, how are you today?"},
+		{Role: "assistant", Content: "I'm doing great, thanks for asking!"},
+	}
+	_, err := store.Create(msgs, "test-model", "greeting")
+	if err != nil {
+		t.Fatalf("Create: %v", err)
+	}
+
+	// Token-based matching with unrelated tokens.
+	tokens := []string{"database", "migration", "schema"}
+	matchedTokens := make(map[string]bool, len(tokens))
+	sessions, _ := store.List(0)
+	for _, s := range sessions {
+		full, _ := store.Load(s.ID)
+		for _, msg := range full.Messages {
+			if msg.Role != "user" && msg.Role != "assistant" {
+				continue
+			}
+			lower := strings.ToLower(msg.Content)
+			for _, tok := range tokens {
+				if len(tok) < 2 || matchedTokens[tok] {
+					continue
+				}
+				if strings.Contains(lower, tok) {
+					matchedTokens[tok] = true
+				}
+			}
+		}
+	}
+
+	if len(matchedTokens) >= 2 {
+		t.Errorf("deepSearch should NOT match unrelated tokens, got %d matches", len(matchedTokens))
+	}
+}
+
+func TestDeepSearch_MultiSession(t *testing.T) {
+	store := newTestStore(t)
+
+	// Create sessions with different content.
+	sessions := []struct {
+		msgs []llm.Message
+		task string
+	}{
+		{[]llm.Message{{Role: "user", Content: "fix the database migration script"}}, "db fix"},
+		{[]llm.Message{{Role: "user", Content: "add new API endpoint for users"}}, "api work"},
+		{[]llm.Message{{Role: "user", Content: "deploy the latest version to production"}}, "deploy"},
+	}
+	for _, s := range sessions {
+		_, err := store.Create(s.msgs, "test-model", s.task)
+		if err != nil {
+			t.Fatalf("Create: %v", err)
+		}
+	}
+
+	// Search for "database migration" — should match session 0.
+	tokens := []string{"database", "migration"}
+	matchedTokens := make(map[string]bool, len(tokens))
+	all, _ := store.List(0)
+	for _, s := range all {
+		full, _ := store.Load(s.ID)
+		for _, msg := range full.Messages {
+			lower := strings.ToLower(msg.Content)
+			for _, tok := range tokens {
+				if strings.Contains(lower, tok) {
+					matchedTokens[tok] = true
+				}
+			}
+		}
+	}
+	if len(matchedTokens) < 2 {
+		t.Errorf("expected to match 'database' and 'migration', got %d", len(matchedTokens))
+	}
+
+	// Search for "production deploy" — should match session 2.
+	tokens2 := []string{"production", "deploy"}
+	matchedTokens2 := make(map[string]bool, len(tokens2))
+	for _, s := range all {
+		full, _ := store.Load(s.ID)
+		for _, msg := range full.Messages {
+			lower := strings.ToLower(msg.Content)
+			for _, tok := range tokens2 {
+				if strings.Contains(lower, tok) {
+					matchedTokens2[tok] = true
+				}
+			}
+		}
+	}
+	if len(matchedTokens2) < 2 {
+		t.Errorf("expected to match 'production' and 'deploy', got %d", len(matchedTokens2))
+	}
+}

internal/telegram/session.go

@@ -195,6 +195,60 @@ func (sm *SessionManager) Delete(chatID int64) error {
 	return sm.Store.Delete(sessionID)
 }
 
+// ArchiveAndDelete archives the current session to a timestamped file,
+// then removes it from cache and store. This preserves the conversation
+// history for later reference while starting fresh on the next message.
+// The archived session is saved with an ID like "tg-<chatID>-<YYYYMMDD>-<HHMMSS>"
+// so it can be browsed via `odek session list`.
+func (sm *SessionManager) ArchiveAndDelete(chatID int64) error {
+	sessionID := fmt.Sprintf("tg-%d", chatID)
+
+	sm.Mu.Lock()
+	// Get session from cache if available, remove from cache
+	cs, ok := sm.Cache[chatID]
+	if ok {
+		delete(sm.Cache, chatID)
+	}
+	sm.Mu.Unlock()
+
+	// If we had cache data not yet persisted, persist directly to store
+	// (bypassing Save which would re-create a cache entry we just deleted)
+	if ok && cs != nil && len(cs.Messages) > 0 {
+		sess := &session.Session{
+			ID:        sessionID,
+			CreatedAt: cs.CreatedAt,
+			UpdatedAt: time.Now(),
+			Turns:     cs.TurnCount,
+			Task:      fmt.Sprintf("tg-%d", chatID),
+			Messages:  cs.Messages,
+		}
+		if err := sm.Store.Save(sess); err != nil {
+			return fmt.Errorf("archive: persist before archive: %w", err)
+		}
+	}
+
+	// Load current session from store
+	sess, err := sm.Store.Load(sessionID)
+	if err != nil {
+		if errors.Is(err, os.ErrNotExist) {
+			// No session on disk — nothing to archive
+			return nil
+		}
+		return fmt.Errorf("archive: load session: %w", err)
+	}
+
+	// Save as archive with timestamped ID
+	archiveID := fmt.Sprintf("tg-%d-%s", chatID, time.Now().UTC().Format("20060102-150405"))
+	archived := *sess
+	archived.ID = archiveID
+	if err := sm.Store.Save(&archived); err != nil {
+		return fmt.Errorf("archive: save archive: %w", err)
+	}
+
+	// Delete the old session (file + index + vector index)
+	return sm.Store.Delete(sessionID)
+}
+
 // AppendMessage adds a single message (role + content) to the chat
 // session's message list and saves the updated session. It uses
 // GetOrCreate to ensure the session exists.