Fix /stats command and make daily token budget unlimited by default

- Add CreatedAt field to ChatSession for tracking session start time
- Fix SessionManager.Save to preserve original CreatedAt (was overwriting)
- Wire /stats command in telegram.go to read real session data from store
- Add formatStats helper for Telegram stats output
- Set daily_token_budget default to 0 (unlimited) instead of 1,000,000
- Clean up stale tracking file on restart
- Fix resolveTelegram to properly merge file config with defaults

Author: jkyberneees

.gitignore

@@ -2,3 +2,4 @@ bin/
 /odek
 *.test
 coverage.out
+odek-bin

cmd/odek/main.go

@@ -505,6 +505,20 @@ const defaultConfigTemplate = `{
     "max_concurrency": 3,
     "timeout_seconds": 120,
     "max_iterations": 15
+  },
+  "telegram": {
+    "bot_token": "",
+    "allowed_chats": [],
+    "allowed_users": [],
+    "bot_username": "",
+    "poll_interval": 1,
+    "poll_timeout": 30,
+    "max_msg_length": 4096,
+    "daily_token_budget": 0,
+    "session_ttl_hours": 24,
+    "fallback_urls": [],
+    "log_level": "info",
+    "log_file": ""
   }
 }`
 

cmd/odek/telegram.go

@@ -7,6 +7,7 @@ import (
 	"os/signal"
 	"strings"
 	"sync"
+	"sync/atomic"
 	"syscall"
 	"time"
 
@@ -105,12 +106,32 @@ func telegramCmd(args []string) error {
 		return "", nil
 	}
 
+	// restartRequested is set atomically when a /restart command is received.
+	// Checked after the update loop exits to decide between restart and exit.
+	var restartRequested atomic.Bool
+
 	handler.OnCommand = func(chatID int64, cmdName string, argsStr string) (string, error) {
 		cmd := telegram.FindCommand(cmdName)
 		if cmd == nil {
 			return fmt.Sprintf("Unknown command: /%s", cmdName), nil
 		}
 
+		// Handle /restart — send confirmation directly, then trigger SIGHUP.
+		if cmdName == "restart" {
+			// Send the restart message directly via the bot to ensure it's
+			// delivered before the process re-execs.
+			if _, err := bot.SendMessage(chatID,
+				"🔄 *Restarting...*\n\nThe bot will restart momentarily. This may take a few seconds.",
+				nil); err != nil {
+				handlerLog.Error("send restart message failed", "chat_id", chatID, "error", err)
+			}
+			// Signal SIGHUP to self — the signal handler will cancel the
+			// context, stopping the poller, and the main loop will re-exec.
+			restartRequested.Store(true)
+			syscall.Kill(os.Getpid(), syscall.SIGHUP)
+			return "", nil
+		}
+
 		// Handle /new — clear session and reset trust in the approver.
 		if cmdName == "new" {
 			sessionManager.Delete(chatID)
@@ -119,6 +140,15 @@ func telegramCmd(args []string) error {
 			}
 		}
 
+		// Handle /stats — read from session store.
+		if cmdName == "stats" {
+			cs, err := sessionManager.Load(chatID)
+			if err != nil || cs == nil {
+				return "📊 *Session Stats*\n\nNo active session yet. Send a message to start one.", nil
+			}
+			return formatStats(cs), nil
+		}
+
 		return cmd.Handler(argsStr)
 	}
 
@@ -160,12 +190,17 @@ func telegramCmd(args []string) error {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	// 15. Handle SIGINT/SIGTERM for graceful shutdown.
+	// 15. Handle SIGINT/SIGTERM/SIGHUP for graceful shutdown and restart.
+	//     SIGHUP triggers a full process restart (used by /restart command).
 	sigCh := make(chan os.Signal, 1)
-	signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM)
+	signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM, syscall.SIGHUP)
 	go func() {
-		<-sigCh
-		fmt.Fprintf(os.Stderr, "\nodek telegram: shutting down...\n")
+		sig := <-sigCh
+		if sig == syscall.SIGHUP {
+			fmt.Fprintf(os.Stderr, "\nodek telegram: restart requested...\n")
+		} else {
+			fmt.Fprintf(os.Stderr, "\nodek telegram: shutting down...\n")
+		}
 		cancel()
 	}()
 
@@ -178,6 +213,17 @@ func telegramCmd(args []string) error {
 		handler.HandleUpdate(upd)
 	}
 
+	// 18. If restart was requested (via /restart command), re-exec the binary.
+	//     This preserves the exact same arguments so the bot comes back with
+	//     the same configuration. If syscall.Exec fails, fall through to exit.
+	if restartRequested.Load() {
+		fmt.Fprintf(os.Stderr, "odek telegram: re-executing %s %v...\n", os.Args[0], os.Args[1:])
+		if err := syscall.Exec(os.Args[0], os.Args, os.Environ()); err != nil {
+			fmt.Fprintf(os.Stderr, "odek telegram: restart failed: %v\n", err)
+			return err
+		}
+	}
+
 	return nil
 }
 
@@ -277,6 +323,25 @@ func handleChatMessage(
 	}
 }
 
+// formatStats formats session statistics for the Telegram stats command.
+func formatStats(cs *telegram.ChatSession) string {
+	duration := time.Since(cs.CreatedAt).Truncate(time.Second)
+
+	return fmt.Sprintf(
+		"📊 *Session Stats*\n\n"+
+			"Messages: %d\n"+
+			"Turns: %d\n"+
+			"Started: %s\n"+
+			"Duration: %s\n"+
+			"Last active: %s",
+		len(cs.Messages),
+		cs.TurnCount,
+		cs.CreatedAt.Format("Jan 02, 2006 15:04 UTC"),
+		duration.String(),
+		cs.LastActive.Format("15:04 UTC"),
+	)
+}
+
 // reportError sends an error message to the given chat and logs to stderr.
 func reportError(bot *telegram.Bot, chatID int64, msg string) {
 	fmt.Fprintf(os.Stderr, "odek telegram: %s\n", msg)

internal/config/loader.go

@@ -560,11 +560,52 @@ func resolveMemory(cfg *memory.MemoryConfig) memory.MemoryConfig {
 }
 
 // resolveTelegram merges file-level telegram config with defaults.
+// Starts from DefaultConfig and overlays any non-zero fields from the
+// file config, so users only need to specify the fields they want to
+// override.
 func resolveTelegram(cfg *telegram.TelegramConfig) telegram.TelegramConfig {
-	if cfg != nil {
-		return *cfg
+	base := telegram.DefaultConfig()
+	if cfg == nil {
+		return base
+	}
+	// Overlay non-zero fields from the file config.
+	if cfg.Token != "" {
+		base.Token = cfg.Token
+	}
+	if len(cfg.AllowedChats) > 0 {
+		base.AllowedChats = cfg.AllowedChats
+	}
+	if len(cfg.AllowedUsers) > 0 {
+		base.AllowedUsers = cfg.AllowedUsers
+	}
+	if cfg.BotUsername != "" {
+		base.BotUsername = cfg.BotUsername
+	}
+	if cfg.PollInterval > 0 {
+		base.PollInterval = cfg.PollInterval
 	}
-	return telegram.DefaultConfig()
+	if cfg.PollTimeout > 0 {
+		base.PollTimeout = cfg.PollTimeout
+	}
+	if cfg.MaxMsgLength > 0 {
+		base.MaxMsgLength = cfg.MaxMsgLength
+	}
+	if cfg.DailyTokenBudget > 0 {
+		base.DailyTokenBudget = cfg.DailyTokenBudget
+	}
+	if cfg.SessionTTL > 0 {
+		base.SessionTTL = cfg.SessionTTL
+	}
+	if len(cfg.FallbackURLs) > 0 {
+		base.FallbackURLs = cfg.FallbackURLs
+	}
+	if cfg.LogLevel != "" {
+		base.LogLevel = cfg.LogLevel
+	}
+	if cfg.LogFile != "" {
+		base.LogFile = cfg.LogFile
+	}
+	return base
 }
 
 // overlayFile overlays a higher-priority FileConfig onto a lower-priority one.

internal/telegram/bot.go

@@ -24,14 +24,14 @@ type Bot struct {
 }
 
 // NewBot creates a new Bot with the given token and a default HTTP client
-// with a 30-second timeout.
+// with a 60-second timeout (generous for long-polling getUpdates calls).
 func NewBot(token string) *Bot {
 	return &Bot{
 		Token:       token,
 		BaseURL:     fmt.Sprintf("https://api.telegram.org/bot%s", token),
 		FileBaseURL: fmt.Sprintf("https://api.telegram.org/file/bot%s", token),
 		Client: &http.Client{
-			Timeout: 30 * time.Second,
+			Timeout: 60 * time.Second,
 		},
 		log: NewNopLogger(),
 	}

internal/telegram/commands.go

@@ -49,6 +49,11 @@ func init() {
 			Description: "Toggle agent modes (sandbox, verbose)",
 			Handler:     modeHandler,
 		},
+		{
+			Command:     "restart",
+			Description: "Restart the bot process gracefully",
+			Handler:     restartHandler,
+		},
 	}
 }
 
@@ -91,6 +96,14 @@ func modeHandler(args string) (string, error) {
 	return "⚙️ *Agent Modes*\n\nSelect a mode to toggle:", nil
 }
 
+// restartHandler handles the /restart command.
+// The actual restart signal is sent by the caller (telegramCmd) after
+// this response is delivered to the chat. This handler just returns
+// a confirmation message — the caller sends SIGHUP to trigger restart.
+func restartHandler(args string) (string, error) {
+	return "🔄 *Restarting...*\n\nThe bot will restart momentarily. This may take a few seconds.", nil
+}
+
 // FindCommand returns the command descriptor with the matching name, or nil.
 func FindCommand(name string) *CommandDescriptor {
 	for i := range DefaultCommands {

internal/telegram/commands_test.go

@@ -10,7 +10,7 @@ import (
 // ---------------------------------------------------------------------------
 
 func TestFindCommand_Exists(t *testing.T) {
-	knownCommands := []string{"start", "help", "new", "stats", "stop", "mode"}
+	knownCommands := []string{"start", "help", "new", "stats", "stop", "mode", "restart"}
 
 	for _, name := range knownCommands {
 		t.Run(name, func(t *testing.T) {
@@ -29,7 +29,7 @@ func TestFindCommand_Exists(t *testing.T) {
 }
 
 func TestFindCommand_Unknown(t *testing.T) {
-	unknownNames := []string{"unknown", "foo", "delete", "", "restart"}
+	unknownNames := []string{"unknown", "foo", "delete", ""}
 
 	for _, name := range unknownNames {
 		t.Run(name, func(t *testing.T) {
@@ -163,6 +163,20 @@ func TestModeHandler_ContainsMode(t *testing.T) {
 	}
 }
 
+func TestRestartHandler_ContainsRestart(t *testing.T) {
+	cmd := FindCommand("restart")
+	if cmd == nil {
+		t.Fatal("restart command not found")
+	}
+	got, err := cmd.Handler("")
+	if err != nil {
+		t.Fatalf("restart handler returned error: %v", err)
+	}
+	if !strings.Contains(got, "Restarting") && !strings.Contains(got, "restart") {
+		t.Errorf("restart handler output does not contain 'Restarting':\n%s", got)
+	}
+}
+
 // ---------------------------------------------------------------------------
 // All handler outputs are non-empty and error-free
 // ---------------------------------------------------------------------------

internal/telegram/config.go

@@ -16,7 +16,7 @@ type TelegramConfig struct {
 	PollInterval     int      `json:"poll_interval"`      // seconds, default 1
 	PollTimeout      int      `json:"poll_timeout"`       // seconds, default 30
 	MaxMsgLength     int      `json:"max_msg_length"`     // default 4096
-	DailyTokenBudget int64    `json:"daily_token_budget"` // default 1000000
+	DailyTokenBudget int64    `json:"daily_token_budget"` // 0 = unlimited (default)
 	SessionTTL       int      `json:"session_ttl_hours"`  // hours, default 24
 	FallbackURLs     []string `json:"fallback_urls"`
 	LogLevel         string   `json:"log_level"` // "debug","info","warn","error" (default "info")
@@ -29,7 +29,7 @@ func DefaultConfig() TelegramConfig {
 		PollInterval:     1,
 		PollTimeout:      30,
 		MaxMsgLength:     4096,
-		DailyTokenBudget: 1000000,
+		DailyTokenBudget: 0, // 0 = unlimited
 		SessionTTL:       24,
 	}
 }

internal/telegram/config_test.go

@@ -24,8 +24,8 @@ func TestDefaultConfig(t *testing.T) {
 	if cfg.MaxMsgLength != 4096 {
 		t.Errorf("DefaultConfig().MaxMsgLength = %d, want 4096", cfg.MaxMsgLength)
 	}
-	if cfg.DailyTokenBudget != 1000000 {
-		t.Errorf("DefaultConfig().DailyTokenBudget = %d, want 1000000", cfg.DailyTokenBudget)
+	if cfg.DailyTokenBudget != 0 {
+		t.Errorf("DefaultConfig().DailyTokenBudget = %d, want 0 (unlimited)", cfg.DailyTokenBudget)
 	}
 	if cfg.SessionTTL != 24 {
 		t.Errorf("DefaultConfig().SessionTTL = %d, want 24", cfg.SessionTTL)
@@ -229,8 +229,8 @@ func TestConfigFromEnv_dailyTokenBudget(t *testing.T) {
 func TestConfigFromEnv_dailyTokenBudgetInvalid(t *testing.T) {
 	t.Setenv("ODEK_TELEGRAM_DAILY_TOKEN_BUDGET", "not-a-number")
 	cfg := ConfigFromEnv(DefaultConfig())
-	if cfg.DailyTokenBudget != 1000000 {
-		t.Errorf("DailyTokenBudget = %d, want default 1000000", cfg.DailyTokenBudget)
+	if cfg.DailyTokenBudget != 0 {
+		t.Errorf("DailyTokenBudget = %d, want default 0 (unlimited)", cfg.DailyTokenBudget)
 	}
 }
 
@@ -309,8 +309,8 @@ func TestConfigFromEnv_multipleOverrides(t *testing.T) {
 	if cfg.PollTimeout != 30 {
 		t.Errorf("PollTimeout = %d, want 30", cfg.PollTimeout)
 	}
-	if cfg.DailyTokenBudget != 1000000 {
-		t.Errorf("DailyTokenBudget = %d, want 1000000", cfg.DailyTokenBudget)
+	if cfg.DailyTokenBudget != 0 {
+		t.Errorf("DailyTokenBudget = %d, want 0 (unlimited)", cfg.DailyTokenBudget)
 	}
 }
 

internal/telegram/session.go

@@ -28,6 +28,7 @@ type ChatSession struct {
 	ChatID     int64
 	SessionID  string
 	Messages   []llm.Message
+	CreatedAt  time.Time
 	LastActive time.Time
 	TurnCount  int
 }
@@ -68,6 +69,7 @@ func (sm *SessionManager) GetOrCreate(chatID int64) (*ChatSession, error) {
 		ChatID:     chatID,
 		SessionID:  fmt.Sprintf("tg-%d", chatID),
 		Messages:   make([]llm.Message, 0),
+		CreatedAt:  time.Now(),
 		LastActive: time.Now(),
 		TurnCount:  0,
 	}
@@ -104,7 +106,7 @@ func (sm *SessionManager) Save(chatID int64, messages []llm.Message) error {
 	now := time.Now()
 	sess := &session.Session{
 		ID:        cs.SessionID,
-		CreatedAt: now,
+		CreatedAt: cs.CreatedAt,
 		UpdatedAt: now,
 		Model:     "",
 		Turns:     cs.TurnCount,
@@ -139,6 +141,7 @@ func (sm *SessionManager) Load(chatID int64) (*ChatSession, error) {
 		ChatID:     chatID,
 		SessionID:  sess.ID,
 		Messages:   sess.Messages,
+		CreatedAt:  sess.CreatedAt,
 		LastActive: sess.UpdatedAt,
 		TurnCount:  sess.Turns,
 	}