feat(telegram): auto-cleanup downloaded media files after agent turn

Adds CleanupMedia(maxAge) that removes media files older than maxAge
from ~/.odek/media/. Runs in background goroutine after each agent turn
with 1-hour max age, since files are only needed during the active turn.

5 tests: removes old, keeps recent, empty dir, missing dir, ignores subdirs

Author: molty3000

cmd/odek/telegram.go

@@ -964,6 +964,17 @@ func handleChatMessage(
 			log.Debug("skill suggestions suppressed by skip list", "count", skipped)
 		}
 	}
+
+	// ── Media cleanup ────────────────────────────────────────────────
+	// Remove downloaded media files older than 1 hour in the background.
+	// These are only needed during the agent turn for analysis/transcription.
+	go func() {
+		if removed, err := telegram.CleanupMedia(1 * time.Hour); err != nil {
+			fmt.Fprintf(os.Stderr, "odek telegram: media cleanup: %v\n", err)
+		} else if removed > 0 {
+			log.Debug("cleaned up old media files", "count", removed)
+		}
+	}()
 }
 
 // formatStats formats session statistics for the Telegram stats command.

internal/telegram/download.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"time"
 )
 
 // ── Media Directory ────────────────────────────────────────────────────────
@@ -119,3 +120,48 @@ func DownloadPhoto(bot *Bot, fileIDs []string) (string, error) {
 
 	return localPath, nil
 }
+
+// ── Media Cleanup ──────────────────────────────────────────────────────────
+
+// CleanupMedia removes media files older than maxAge from the downloaded
+// media directory (~/.odek/media/). Returns the number of files removed.
+// Non-existent directories and subdirectories are silently skipped.
+func CleanupMedia(maxAge time.Duration) (int, error) {
+	dir, err := MediaDir()
+	if err != nil {
+		return 0, err
+	}
+
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return 0, nil // nothing to clean
+		}
+		return 0, fmt.Errorf("telegram cleanup: read dir: %w", err)
+	}
+
+	cutoff := time.Now().Add(-maxAge)
+	var removed int
+
+	for _, e := range entries {
+		if e.IsDir() {
+			continue // skip subdirectories
+		}
+
+		info, err := e.Info()
+		if err != nil {
+			continue // skip unreadable entries
+		}
+
+		if info.ModTime().Before(cutoff) {
+			path := filepath.Join(dir, e.Name())
+			if err := os.Remove(path); err != nil {
+				// Log but don't fail — one bad file shouldn't block cleanup.
+				continue
+			}
+			removed++
+		}
+	}
+
+	return removed, nil
+}

internal/telegram/download_cleanup_test.go

@@ -0,0 +1,150 @@
+package telegram
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+)
+
+func TestCleanupMedia_RemovesOldFiles(t *testing.T) {
+	tmp := t.TempDir()
+	mediaDir := filepath.Join(tmp, ".odek", "media")
+	if err := os.MkdirAll(mediaDir, 0700); err != nil {
+		t.Fatalf("mkdir: %v", err)
+	}
+	t.Setenv("HOME", tmp)
+
+	// Create an old file (2 hours ago).
+	oldPath := filepath.Join(mediaDir, "voice_oldfile.oga")
+	if err := os.WriteFile(oldPath, []byte("old-data"), 0600); err != nil {
+		t.Fatalf("write old: %v", err)
+	}
+	oldTime := time.Now().Add(-2 * time.Hour)
+	if err := os.Chtimes(oldPath, oldTime, oldTime); err != nil {
+		t.Fatalf("chtimes old: %v", err)
+	}
+
+	// Create a recent file (10 minutes ago).
+	recentPath := filepath.Join(mediaDir, "photo_newfile.jpg")
+	if err := os.WriteFile(recentPath, []byte("new-data"), 0600); err != nil {
+		t.Fatalf("write new: %v", err)
+	}
+	recentTime := time.Now().Add(-10 * time.Minute)
+	if err := os.Chtimes(recentPath, recentTime, recentTime); err != nil {
+		t.Fatalf("chtimes new: %v", err)
+	}
+
+	// Clean up files older than 1 hour.
+	removed, err := CleanupMedia(1 * time.Hour)
+	if err != nil {
+		t.Fatalf("CleanupMedia: %v", err)
+	}
+	if removed != 1 {
+		t.Errorf("expected 1 removed file, got %d", removed)
+	}
+
+	// Old file should be gone.
+	if _, err := os.Stat(oldPath); !os.IsNotExist(err) {
+		t.Error("old file should have been removed")
+	}
+
+	// Recent file should still exist.
+	if _, err := os.Stat(recentPath); err != nil {
+		t.Error("recent file should still exist")
+	}
+}
+
+func TestCleanupMedia_EmptyDir(t *testing.T) {
+	tmp := t.TempDir()
+	mediaDir := filepath.Join(tmp, ".odek", "media")
+	if err := os.MkdirAll(mediaDir, 0700); err != nil {
+		t.Fatalf("mkdir: %v", err)
+	}
+	t.Setenv("HOME", tmp)
+
+	removed, err := CleanupMedia(1 * time.Hour)
+	if err != nil {
+		t.Fatalf("CleanupMedia on empty dir: %v", err)
+	}
+	if removed != 0 {
+		t.Errorf("expected 0 removed from empty dir, got %d", removed)
+	}
+}
+
+func TestCleanupMedia_DirNotExist(t *testing.T) {
+	tmp := t.TempDir()
+	t.Setenv("HOME", tmp)
+
+	// Media dir doesn't exist yet — should not error.
+	removed, err := CleanupMedia(1 * time.Hour)
+	if err != nil {
+		t.Fatalf("CleanupMedia on non-existent dir: %v", err)
+	}
+	if removed != 0 {
+		t.Errorf("expected 0 removed, got %d", removed)
+	}
+}
+
+func TestCleanupMedia_AllFilesRecent(t *testing.T) {
+	tmp := t.TempDir()
+	mediaDir := filepath.Join(tmp, ".odek", "media")
+	if err := os.MkdirAll(mediaDir, 0700); err != nil {
+		t.Fatalf("mkdir: %v", err)
+	}
+	t.Setenv("HOME", tmp)
+
+	// Create 3 recent files.
+	for i := 0; i < 3; i++ {
+		name := filepath.Join(mediaDir, "recent_"+string(rune('a'+i))+".ogg")
+		if err := os.WriteFile(name, []byte("data"), 0600); err != nil {
+			t.Fatalf("write: %v", err)
+		}
+	}
+
+	removed, err := CleanupMedia(1 * time.Hour)
+	if err != nil {
+		t.Fatalf("CleanupMedia: %v", err)
+	}
+	if removed != 0 {
+		t.Errorf("expected 0 removed (all recent), got %d", removed)
+	}
+}
+
+func TestCleanupMedia_NonMediaFilesIgnored(t *testing.T) {
+	tmp := t.TempDir()
+	mediaDir := filepath.Join(tmp, ".odek", "media")
+	if err := os.MkdirAll(mediaDir, 0700); err != nil {
+		t.Fatalf("mkdir: %v", err)
+	}
+	t.Setenv("HOME", tmp)
+
+	// Create a subdirectory — should be skipped.
+	subDir := filepath.Join(mediaDir, "subdir")
+	if err := os.MkdirAll(subDir, 0700); err != nil {
+		t.Fatalf("mkdir subdir: %v", err)
+	}
+
+	// Create an old file.
+	oldPath := filepath.Join(mediaDir, "old.oga")
+	if err := os.WriteFile(oldPath, []byte("data"), 0600); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+	oldTime := time.Now().Add(-3 * time.Hour)
+	if err := os.Chtimes(oldPath, oldTime, oldTime); err != nil {
+		t.Fatalf("chtimes: %v", err)
+	}
+
+	removed, err := CleanupMedia(1 * time.Hour)
+	if err != nil {
+		t.Fatalf("CleanupMedia: %v", err)
+	}
+	if removed != 1 {
+		t.Errorf("expected 1 removed, got %d", removed)
+	}
+
+	// Subdirectory should still exist.
+	if _, err := os.Stat(subDir); err != nil {
+		t.Error("subdirectory should not have been removed")
+	}
+}