diff --git a/PolyPilot.Tests/PolyPilot.Tests.csproj b/PolyPilot.Tests/PolyPilot.Tests.csproj
index 1ec6dde9..c2c8e8dc 100644
--- a/PolyPilot.Tests/PolyPilot.Tests.csproj
+++ b/PolyPilot.Tests/PolyPilot.Tests.csproj
@@ -92,6 +92,8 @@
     <Compile Include="../PolyPilot/Services/PluginFileLogger.cs" Link="Shared/PluginFileLogger.cs" />
     <Compile Include="../PolyPilot/Services/ProviderHostContext.cs" Link="Shared/ProviderHostContext.cs" />
     <Compile Include="../PolyPilot/Models/PluginSettings.cs" Link="Shared/PluginSettings.cs" />
+    <Compile Include="../PolyPilot/Models/ScheduledTask.cs" Link="Shared/ScheduledTask.cs" />
+    <Compile Include="../PolyPilot/Services/ScheduledTaskService.cs" Link="Shared/ScheduledTaskService.cs" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/PolyPilot.Tests/ScheduledTaskTests.cs b/PolyPilot.Tests/ScheduledTaskTests.cs
new file mode 100644
index 00000000..7b562541
--- /dev/null
+++ b/PolyPilot.Tests/ScheduledTaskTests.cs
@@ -0,0 +1,522 @@
+using System.Text.Json;
+using Microsoft.Extensions.DependencyInjection;
+using PolyPilot.Models;
+using PolyPilot.Services;
+
+namespace PolyPilot.Tests;
+
+public class ScheduledTaskTests
+{
+    private readonly StubChatDatabase _chatDb = new();
+    private readonly StubServerManager _serverManager = new();
+    private readonly StubWsBridgeClient _bridgeClient = new();
+    private readonly StubDemoService _demoService = new();
+    private readonly RepoManager _repoManager = new();
+    private readonly IServiceProvider _serviceProvider;
+
+    public ScheduledTaskTests()
+    {
+        var services = new ServiceCollection();
+        _serviceProvider = services.BuildServiceProvider();
+    }
+
+    private CopilotService CreateCopilotService() =>
+        new CopilotService(_chatDb, _serverManager, _bridgeClient, _repoManager, _serviceProvider, _demoService);
+
+    private ScheduledTaskService CreateService()
+    {
+        return new ScheduledTaskService(CreateCopilotService());
+    }
+
+    // ── Model tests ─────────────────────────────────────────────
+
+    [Fact]
+    public void ScheduledTask_DefaultValues()
+    {
+        var task = new ScheduledTask();
+
+        Assert.False(string.IsNullOrEmpty(task.Id));
+        Assert.Equal("", task.Name);
+        Assert.Equal("", task.Prompt);
+        Assert.Null(task.SessionName);
+        Assert.Equal(ScheduleType.Daily, task.Schedule);
+        Assert.Equal(60, task.IntervalMinutes);
+        Assert.Equal("09:00", task.TimeOfDay);
+        Assert.Equal(new List<int> { 1, 2, 3, 4, 5 }, task.DaysOfWeek);
+        Assert.True(task.IsEnabled);
+        Assert.Null(task.LastRunAt);
+        Assert.Empty(task.RecentRuns);
+    }
+
+    [Fact]
+    public void ScheduledTask_JsonRoundTrip()
+    {
+        var original = new ScheduledTask
+        {
+            Name = "Daily Standup",
+            Prompt = "Give me a summary of yesterday's changes",
+            Schedule = ScheduleType.Daily,
+            TimeOfDay = "10:30",
+            IsEnabled = true,
+            SessionName = "my-session",
+            Model = "claude-opus-4.6"
+        };
+
+        var json = JsonSerializer.Serialize(original);
+        var deserialized = JsonSerializer.Deserialize<ScheduledTask>(json);
+
+        Assert.NotNull(deserialized);
+        Assert.Equal(original.Id, deserialized!.Id);
+        Assert.Equal("Daily Standup", deserialized.Name);
+        Assert.Equal("Give me a summary of yesterday's changes", deserialized.Prompt);
+        Assert.Equal(ScheduleType.Daily, deserialized.Schedule);
+        Assert.Equal("10:30", deserialized.TimeOfDay);
+        Assert.True(deserialized.IsEnabled);
+        Assert.Equal("my-session", deserialized.SessionName);
+        Assert.Equal("claude-opus-4.6", deserialized.Model);
+    }
+
+    [Fact]
+    public void ScheduledTask_JsonRoundTrip_List()
+    {
+        var tasks = new List<ScheduledTask>
+        {
+            new() { Name = "Task 1", Prompt = "Prompt 1", Schedule = ScheduleType.Interval, IntervalMinutes = 30 },
+            new() { Name = "Task 2", Prompt = "Prompt 2", Schedule = ScheduleType.Weekly, DaysOfWeek = new() { 1, 3, 5 } }
+        };
+
+        var json = JsonSerializer.Serialize(tasks, new JsonSerializerOptions { WriteIndented = true });
+        var deserialized = JsonSerializer.Deserialize<List<ScheduledTask>>(json);
+
+        Assert.NotNull(deserialized);
+        Assert.Equal(2, deserialized!.Count);
+        Assert.Equal("Task 1", deserialized[0].Name);
+        Assert.Equal(30, deserialized[0].IntervalMinutes);
+        Assert.Equal("Task 2", deserialized[1].Name);
+        Assert.Equal(new List<int> { 1, 3, 5 }, deserialized[1].DaysOfWeek);
+    }
+
+    // ── Schedule description ────────────────────────────────────
+
+    [Fact]
+    public void ScheduleDescription_Interval()
+    {
+        var task = new ScheduledTask { Schedule = ScheduleType.Interval, IntervalMinutes = 30 };
+        Assert.Equal("Every 30 minutes", task.ScheduleDescription);
+    }
+
+    [Fact]
+    public void ScheduleDescription_Interval_Singular()
+    {
+        var task = new ScheduledTask { Schedule = ScheduleType.Interval, IntervalMinutes = 1 };
+        Assert.Equal("Every 1 minute", task.ScheduleDescription);
+    }
+
+    [Fact]
+    public void ScheduleDescription_Daily()
+    {
+        var task = new ScheduledTask { Schedule = ScheduleType.Daily, TimeOfDay = "14:00" };
+        Assert.Equal("Daily at 14:00", task.ScheduleDescription);
+    }
+
+    [Fact]
+    public void ScheduleDescription_Weekly()
+    {
+        var task = new ScheduledTask { Schedule = ScheduleType.Weekly, TimeOfDay = "09:00", DaysOfWeek = new() { 1, 3, 5 } };
+        Assert.Equal("Weekly (Mon, Wed, Fri) at 09:00", task.ScheduleDescription);
+    }
+
+    // ── ParseTimeOfDay ──────────────────────────────────────────
+
+    [Theory]
+    [InlineData("09:00", 9, 0)]
+    [InlineData("14:30", 14, 30)]
+    [InlineData("00:00", 0, 0)]
+    [InlineData("23:59", 23, 59)]
+    public void ParseTimeOfDay_ValidInputs(string input, int expectedHours, int expectedMinutes)
+    {
+        var task = new ScheduledTask { TimeOfDay = input };
+        var (h, m) = task.ParseTimeOfDay();
+        Assert.Equal(expectedHours, h);
+        Assert.Equal(expectedMinutes, m);
+    }
+
+    [Fact]
+    public void ParseTimeOfDay_InvalidInput_ReturnsDefault()
+    {
+        var task = new ScheduledTask { TimeOfDay = "not-a-time" };
+        var (h, m) = task.ParseTimeOfDay();
+        Assert.Equal(9, h);
+        Assert.Equal(0, m);
+    }
+
+    // ── IsDue ───────────────────────────────────────────────────
+
+    [Fact]
+    public void IsDue_DisabledTask_ReturnsFalse()
+    {
+        var task = new ScheduledTask
+        {
+            Schedule = ScheduleType.Interval,
+            IntervalMinutes = 1,
+            IsEnabled = false
+        };
+        Assert.False(task.IsDue(DateTime.UtcNow));
+    }
+
+    [Fact]
+    public void IsDue_IntervalTask_NeverRun_ReturnsTrue()
+    {
+        var task = new ScheduledTask
+        {
+            Schedule = ScheduleType.Interval,
+            IntervalMinutes = 60,
+            IsEnabled = true,
+            LastRunAt = null
+        };
+        Assert.True(task.IsDue(DateTime.UtcNow));
+    }
+
+    [Fact]
+    public void IsDue_IntervalTask_RecentlyRun_ReturnsFalse()
+    {
+        var now = DateTime.UtcNow;
+        var task = new ScheduledTask
+        {
+            Schedule = ScheduleType.Interval,
+            IntervalMinutes = 60,
+            IsEnabled = true,
+            LastRunAt = now.AddMinutes(-10) // ran 10 min ago, interval is 60
+        };
+        Assert.False(task.IsDue(now));
+    }
+
+    [Fact]
+    public void IsDue_IntervalTask_PastDue_ReturnsTrue()
+    {
+        var now = DateTime.UtcNow;
+        var task = new ScheduledTask
+        {
+            Schedule = ScheduleType.Interval,
+            IntervalMinutes = 60,
+            IsEnabled = true,
+            LastRunAt = now.AddMinutes(-65) // ran 65 min ago, interval is 60
+        };
+        Assert.True(task.IsDue(now));
+    }
+
+    // ── RecordRun ───────────────────────────────────────────────
+
+    [Fact]
+    public void RecordRun_AddsRunAndUpdatesLastRunAt()
+    {
+        var task = new ScheduledTask { Name = "test" };
+        var run = new ScheduledTaskRun { StartedAt = DateTime.UtcNow, Success = true };
+
+        task.RecordRun(run);
+
+        Assert.Single(task.RecentRuns);
+        Assert.Equal(run.StartedAt, task.LastRunAt);
+    }
+
+    [Fact]
+    public void RecordRun_TrimsToTenEntries()
+    {
+        var task = new ScheduledTask { Name = "test" };
+        for (int i = 0; i < 15; i++)
+        {
+            task.RecordRun(new ScheduledTaskRun
+            {
+                StartedAt = DateTime.UtcNow.AddMinutes(i),
+                Success = true
+            });
+        }
+
+        Assert.Equal(10, task.RecentRuns.Count);
+    }
+
+    // ── GetNextRunTimeUtc ───────────────────────────────────────
+
+    [Fact]
+    public void GetNextRunTimeUtc_IntervalZero_ReturnsNull()
+    {
+        var task = new ScheduledTask { Schedule = ScheduleType.Interval, IntervalMinutes = 0 };
+        Assert.Null(task.GetNextRunTimeUtc(DateTime.UtcNow));
+    }
+
+    [Fact]
+    public void GetNextRunTimeUtc_WeeklyNoDays_ReturnsNull()
+    {
+        var task = new ScheduledTask { Schedule = ScheduleType.Weekly, DaysOfWeek = new() };
+        Assert.Null(task.GetNextRunTimeUtc(DateTime.UtcNow));
+    }
+
+    [Fact]
+    public void GetNextRunTimeUtc_IntervalNeverRun_ReturnsNow()
+    {
+        var now = DateTime.UtcNow;
+        var task = new ScheduledTask
+        {
+            Schedule = ScheduleType.Interval,
+            IntervalMinutes = 60,
+            LastRunAt = null
+        };
+        var next = task.GetNextRunTimeUtc(now);
+        Assert.NotNull(next);
+        Assert.Equal(now, next!.Value);
+    }
+
+    [Fact]
+    public void GetNextRunTimeUtc_IntervalAfterRun_ReturnsLastPlusInterval()
+    {
+        var now = DateTime.UtcNow;
+        var lastRun = now.AddMinutes(-30);
+        var task = new ScheduledTask
+        {
+            Schedule = ScheduleType.Interval,
+            IntervalMinutes = 60,
+            LastRunAt = lastRun
+        };
+        var next = task.GetNextRunTimeUtc(now);
+        Assert.NotNull(next);
+        Assert.Equal(lastRun.AddMinutes(60), next!.Value);
+    }
+
+    // ── ScheduleType enum ───────────────────────────────────────
+
+    [Fact]
+    public void ScheduleType_HasExpectedValues()
+    {
+        Assert.Equal(0, (int)ScheduleType.Interval);
+        Assert.Equal(1, (int)ScheduleType.Daily);
+        Assert.Equal(2, (int)ScheduleType.Weekly);
+    }
+
+    // ── Service persistence tests ───────────────────────────────
+
+    [Fact]
+    public void Service_SaveAndLoad_RoundTrips()
+    {
+        var tempFile = Path.Combine(Path.GetTempPath(), $"polypilot-sched-test-{Guid.NewGuid():N}.json");
+        ScheduledTaskService.SetTasksFilePathForTesting(tempFile);
+
+        try
+        {
+            var svc = CreateService();
+            svc.AddTask(new ScheduledTask { Name = "Test Task", Prompt = "Do something" });
+
+            // Create a new service instance to verify it loads from disk
+            var svc2 = CreateService();
+            var loaded = svc2.GetTasks();
+
+            Assert.Single(loaded);
+            Assert.Equal("Test Task", loaded[0].Name);
+            Assert.Equal("Do something", loaded[0].Prompt);
+        }
+        finally
+        {
+            try { File.Delete(tempFile); } catch { }
+            // Reset to test path
+            ScheduledTaskService.SetTasksFilePathForTesting(
+                Path.Combine(TestSetup.TestBaseDir, "scheduled-tasks.json"));
+        }
+    }
+
+    [Fact]
+    public void Service_DeleteTask_RemovesFromList()
+    {
+        var tempFile = Path.Combine(Path.GetTempPath(), $"polypilot-sched-test-{Guid.NewGuid():N}.json");
+        ScheduledTaskService.SetTasksFilePathForTesting(tempFile);
+
+        try
+        {
+            var svc = CreateService();
+            var task = new ScheduledTask { Name = "To Delete", Prompt = "test" };
+            svc.AddTask(task);
+            Assert.Single(svc.GetTasks());
+
+            var result = svc.DeleteTask(task.Id);
+            Assert.True(result);
+            Assert.Empty(svc.GetTasks());
+        }
+        finally
+        {
+            try { File.Delete(tempFile); } catch { }
+            ScheduledTaskService.SetTasksFilePathForTesting(
+                Path.Combine(TestSetup.TestBaseDir, "scheduled-tasks.json"));
+        }
+    }
+
+    [Fact]
+    public void Service_SetEnabled_TogglesState()
+    {
+        var tempFile = Path.Combine(Path.GetTempPath(), $"polypilot-sched-test-{Guid.NewGuid():N}.json");
+        ScheduledTaskService.SetTasksFilePathForTesting(tempFile);
+
+        try
+        {
+            var svc = CreateService();
+            var task = new ScheduledTask { Name = "Toggle", Prompt = "test", IsEnabled = true };
+            svc.AddTask(task);
+
+            svc.SetEnabled(task.Id, false);
+            Assert.False(svc.GetTask(task.Id)!.IsEnabled);
+
+            svc.SetEnabled(task.Id, true);
+            Assert.True(svc.GetTask(task.Id)!.IsEnabled);
+        }
+        finally
+        {
+            try { File.Delete(tempFile); } catch { }
+            ScheduledTaskService.SetTasksFilePathForTesting(
+                Path.Combine(TestSetup.TestBaseDir, "scheduled-tasks.json"));
+        }
+    }
+
+    [Fact]
+    public void Service_UpdateTask_ModifiesExistingTask()
+    {
+        var tempFile = Path.Combine(Path.GetTempPath(), $"polypilot-sched-test-{Guid.NewGuid():N}.json");
+        ScheduledTaskService.SetTasksFilePathForTesting(tempFile);
+
+        try
+        {
+            var svc = CreateService();
+            var task = new ScheduledTask { Name = "Original", Prompt = "original" };
+            svc.AddTask(task);
+
+            task.Name = "Updated";
+            task.Prompt = "updated";
+            svc.UpdateTask(task);
+
+            var loaded = svc.GetTask(task.Id);
+            Assert.NotNull(loaded);
+            Assert.Equal("Updated", loaded!.Name);
+            Assert.Equal("updated", loaded.Prompt);
+        }
+        finally
+        {
+            try { File.Delete(tempFile); } catch { }
+            ScheduledTaskService.SetTasksFilePathForTesting(
+                Path.Combine(TestSetup.TestBaseDir, "scheduled-tasks.json"));
+        }
+    }
+
+    [Fact]
+    public async Task Service_EvaluateTasksAsync_ExecutesDueTasks()
+    {
+        var tempFile = Path.Combine(Path.GetTempPath(), $"polypilot-sched-test-{Guid.NewGuid():N}.json");
+        ScheduledTaskService.SetTasksFilePathForTesting(tempFile);
+
+        try
+        {
+            var copilot = CreateCopilotService();
+            var svc = new ScheduledTaskService(copilot);
+            // Initialize CopilotService in demo mode so it can accept prompts
+            await copilot.ReconnectAsync(new ConnectionSettings { Mode = ConnectionMode.Demo });
+            await copilot.CreateSessionAsync("test-session");
+
+            var task = new ScheduledTask
+            {
+                Name = "Due Task",
+                Prompt = "Hello",
+                Schedule = ScheduleType.Interval,
+                IntervalMinutes = 1,
+                IsEnabled = true,
+                LastRunAt = DateTime.UtcNow.AddMinutes(-5),
+                SessionName = "test-session"
+            };
+            svc.AddTask(task);
+
+            await svc.EvaluateTasksAsync();
+
+            var updated = svc.GetTask(task.Id);
+            Assert.NotNull(updated);
+            Assert.Single(updated!.RecentRuns);
+            Assert.True(updated.RecentRuns[0].Success);
+        }
+        finally
+        {
+            try { File.Delete(tempFile); } catch { }
+            ScheduledTaskService.SetTasksFilePathForTesting(
+                Path.Combine(TestSetup.TestBaseDir, "scheduled-tasks.json"));
+        }
+    }
+
+    [Fact]
+    public async Task Service_ExecuteTask_RecordsErrorWhenNotInitialized()
+    {
+        var tempFile = Path.Combine(Path.GetTempPath(), $"polypilot-sched-test-{Guid.NewGuid():N}.json");
+        ScheduledTaskService.SetTasksFilePathForTesting(tempFile);
+
+        try
+        {
+            var svc = CreateService();
+            // Do NOT initialize CopilotService
+            var task = new ScheduledTask { Name = "Fail", Prompt = "test" };
+            svc.AddTask(task);
+
+            await svc.ExecuteTaskAsync(task, DateTime.UtcNow);
+
+            var updated = svc.GetTask(task.Id);
+            Assert.NotNull(updated);
+            Assert.Single(updated!.RecentRuns);
+            Assert.False(updated.RecentRuns[0].Success);
+            Assert.Contains("not initialized", updated.RecentRuns[0].Error);
+        }
+        finally
+        {
+            try { File.Delete(tempFile); } catch { }
+            ScheduledTaskService.SetTasksFilePathForTesting(
+                Path.Combine(TestSetup.TestBaseDir, "scheduled-tasks.json"));
+        }
+    }
+
+    [Fact]
+    public void Service_EvaluationIntervalSeconds_IsReasonable()
+    {
+        // Evaluation interval should be frequent enough to be useful but not too aggressive
+        Assert.InRange(ScheduledTaskService.EvaluationIntervalSeconds, 10, 120);
+    }
+
+    [Fact]
+    public void Service_LoadTasks_HandlesCorruptFile()
+    {
+        var tempFile = Path.Combine(Path.GetTempPath(), $"polypilot-sched-test-{Guid.NewGuid():N}.json");
+        ScheduledTaskService.SetTasksFilePathForTesting(tempFile);
+
+        try
+        {
+            // Write corrupt JSON
+            Directory.CreateDirectory(Path.GetDirectoryName(tempFile)!);
+            File.WriteAllText(tempFile, "{{not json}}");
+
+            var svc = CreateService();
+            Assert.Empty(svc.GetTasks());
+        }
+        finally
+        {
+            try { File.Delete(tempFile); } catch { }
+            ScheduledTaskService.SetTasksFilePathForTesting(
+                Path.Combine(TestSetup.TestBaseDir, "scheduled-tasks.json"));
+        }
+    }
+
+    [Fact]
+    public void Service_LoadTasks_HandlesNonexistentFile()
+    {
+        var tempFile = Path.Combine(Path.GetTempPath(), $"polypilot-sched-test-{Guid.NewGuid():N}.json");
+        ScheduledTaskService.SetTasksFilePathForTesting(tempFile);
+
+        try
+        {
+            var svc = CreateService();
+            Assert.Empty(svc.GetTasks());
+        }
+        finally
+        {
+            ScheduledTaskService.SetTasksFilePathForTesting(
+                Path.Combine(TestSetup.TestBaseDir, "scheduled-tasks.json"));
+        }
+    }
+}
diff --git a/PolyPilot.Tests/TestSetup.cs b/PolyPilot.Tests/TestSetup.cs
index 2a65dfca..fbc44f1f 100644
--- a/PolyPilot.Tests/TestSetup.cs
+++ b/PolyPilot.Tests/TestSetup.cs
@@ -29,5 +29,6 @@ internal static void Initialize()
         RepoManager.SetBaseDirForTesting(TestBaseDir);
         AuditLogService.SetLogDirForTesting(Path.Combine(TestBaseDir, "audit_logs"));
         PromptLibraryService.SetUserPromptsDirForTesting(Path.Combine(TestBaseDir, "prompts"));
+        ScheduledTaskService.SetTasksFilePathForTesting(Path.Combine(TestBaseDir, "scheduled-tasks.json"));
     }
 }
diff --git a/PolyPilot/Components/Layout/SessionSidebar.razor b/PolyPilot/Components/Layout/SessionSidebar.razor
index 877bd261..aa1ef7de 100644
--- a/PolyPilot/Components/Layout/SessionSidebar.razor
+++ b/PolyPilot/Components/Layout/SessionSidebar.razor
@@ -56,6 +56,7 @@ else
                     <a href="/" class="header-icon-btn @(currentPage == "/" || currentPage == "/dashboard" ? "active" : "")" title="Dashboard" @onclick="DashboardClicked" @onclick:preventDefault="true"><svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect x="3" y="3" width="7" height="9"/><rect x="14" y="3" width="7" height="5"/><rect x="14" y="12" width="7" height="9"/><rect x="3" y="16" width="7" height="5"/></svg></a>
                     <a href="/settings" class="header-icon-btn @(currentPage == "/settings" ? "active" : "")" title="Settings" @onclick='() => { CopilotService.SaveUiState("/settings"); currentPage = "/settings"; }'><svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="3"/><path d="M19.4 15a1.65 1.65 0 0 0 .33 1.82l.06.06a2 2 0 0 1 0 2.83 2 2 0 0 1-2.83 0l-.06-.06a1.65 1.65 0 0 0-1.82-.33 1.65 1.65 0 0 0-1 1.51V21a2 2 0 0 1-2 2 2 2 0 0 1-2-2v-.09A1.65 1.65 0 0 0 9 19.4a1.65 1.65 0 0 0-1.82.33l-.06.06a2 2 0 0 1-2.83 0 2 2 0 0 1 0-2.83l.06-.06A1.65 1.65 0 0 0 4.68 15a1.65 1.65 0 0 0-1.51-1H3a2 2 0 0 1-2-2 2 2 0 0 1 2-2h.09A1.65 1.65 0 0 0 4.6 9a1.65 1.65 0 0 0-.33-1.82l-.06-.06a2 2 0 0 1 0-2.83 2 2 0 0 1 2.83 0l.06.06A1.65 1.65 0 0 0 9 4.68a1.65 1.65 0 0 0 1-1.51V3a2 2 0 0 1 2-2 2 2 0 0 1 2 2v.09a1.65 1.65 0 0 0 1 1.51 1.65 1.65 0 0 0 1.82-.33l.06-.06a2 2 0 0 1 2.83 0 2 2 0 0 1 0 2.83l-.06.06A1.65 1.65 0 0 0 19.4 9a1.65 1.65 0 0 0 1.51 1H21a2 2 0 0 1 2 2 2 2 0 0 1-2 2h-.09a1.65 1.65 0 0 0-1.51 1z"/></svg></a>
                     <a href="/tutorial" class="header-icon-btn @(currentPage == "/tutorial" ? "active" : "")" title="Tutorial" @onclick='() => { CopilotService.SaveUiState("/tutorial"); currentPage = "/tutorial"; }'><svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><path d="M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3"/><line x1="12" y1="17" x2="12.01" y2="17"/></svg></a>
+                    <a href="/scheduled-tasks" class="header-icon-btn @(currentPage == "/scheduled-tasks" ? "active" : "")" title="Scheduled Tasks" @onclick='() => { CopilotService.SaveUiState("/scheduled-tasks"); currentPage = "/scheduled-tasks"; }'><svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><polyline points="12 6 12 12 16 14"/></svg></a>
                     <div class="info-popover">
                         <span class="info-trigger" title="Connection & shortcuts">
                             <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><line x1="12" y1="16" x2="12" y2="12"/><line x1="12" y1="8" x2="12.01" y2="8"/></svg>
diff --git a/PolyPilot/Components/Pages/ScheduledTasks.razor b/PolyPilot/Components/Pages/ScheduledTasks.razor
new file mode 100644
index 00000000..2fb9f3ff
--- /dev/null
+++ b/PolyPilot/Components/Pages/ScheduledTasks.razor
@@ -0,0 +1,373 @@
+@page "/scheduled-tasks"
+@using PolyPilot.Services
+@using PolyPilot.Models
+@inject CopilotService CopilotService
+@inject ScheduledTaskService TaskService
+@inject NavigationManager Nav
+@implements IDisposable
+
+<div class="scheduled-tasks-page">
+    <div class="scheduled-tasks-header">
+        <div class="header-row">
+            <h2>⏰ Scheduled Tasks</h2>
+            <button class="add-task-btn" @onclick="ShowCreateForm">+ New Task</button>
+        </div>
+        <p class="header-subtitle">Create recurring tasks that automatically send prompts on a schedule — ideal for daily stand-ups, periodic reviews, and repetitive executions.</p>
+    </div>
+
+    <div class="scheduled-tasks-body">
+        @if (showForm)
+        {
+            <div class="task-form-card">
+                <div class="form-header">
+                    <h3>@(editingTask != null ? "Edit Task" : "New Scheduled Task")</h3>
+                    <button class="form-close-btn" @onclick="CancelForm">✕</button>
+                </div>
+
+                <div class="form-group">
+                    <label>Name</label>
+                    <input type="text" class="form-input" @bind="formName" placeholder="e.g., Daily Stand-up" />
+                </div>
+
+                <div class="form-group">
+                    <label>Prompt</label>
+                    <textarea class="form-textarea" @bind="formPrompt" rows="4" placeholder="The prompt to send when this task runs..."></textarea>
+                </div>
+
+                <div class="form-group">
+                    <label>Schedule</label>
+                    <select class="form-select" @bind="formSchedule">
+                        <option value="@ScheduleType.Interval">Interval (every N minutes)</option>
+                        <option value="@ScheduleType.Daily">Daily</option>
+                        <option value="@ScheduleType.Weekly">Weekly</option>
+                    </select>
+                </div>
+
+                @if (formSchedule == ScheduleType.Interval)
+                {
+                    <div class="form-group">
+                        <label>Every (minutes)</label>
+                        <input type="number" class="form-input short-input" @bind="formIntervalMinutes" min="1" max="10080" />
+                    </div>
+                }
+                else
+                {
+                    <div class="form-group">
+                        <label>Time of day</label>
+                        <input type="time" class="form-input short-input" @bind="formTimeOfDay" />
+                    </div>
+                }
+
+                @if (formSchedule == ScheduleType.Weekly)
+                {
+                    <div class="form-group">
+                        <label>Days</label>
+                        <div class="day-picker">
+                            @foreach (var (idx, name) in dayNames)
+                            {
+                                <button class="day-btn @(formDays.Contains(idx) ? "selected" : "")"
+                                        @onclick="() => ToggleDay(idx)">@name</button>
+                            }
+                        </div>
+                    </div>
+                }
+
+                <div class="form-group">
+                    <label>Target Session (optional)</label>
+                    <select class="form-select" @bind="formSessionName">
+                        <option value="">Create new session each run</option>
+                        @foreach (var s in CopilotService.GetAllSessions())
+                        {
+                            <option value="@s.Name">@s.Name</option>
+                        }
+                    </select>
+                </div>
+
+                @if (string.IsNullOrEmpty(formSessionName))
+                {
+                    <div class="form-group">
+                        <label>Model (for new sessions)</label>
+                        <input type="text" class="form-input" @bind="formModel" placeholder="e.g., claude-opus-4.6 (leave empty for default)" />
+                    </div>
+                }
+
+                @if (!string.IsNullOrEmpty(formError))
+                {
+                    <div class="form-error">@formError</div>
+                }
+
+                <div class="form-actions">
+                    <button class="btn-secondary" @onclick="CancelForm">Cancel</button>
+                    <button class="btn-primary" @onclick="SaveTask">@(editingTask != null ? "Save Changes" : "Create Task")</button>
+                </div>
+            </div>
+        }
+
+        @if (!tasks.Any() && !showForm)
+        {
+            <div class="empty-state">
+                <div class="empty-icon">⏰</div>
+                <p class="empty-title">No scheduled tasks yet</p>
+                <p class="empty-desc">Create a recurring task to automatically send prompts on a schedule.</p>
+                <button class="btn-primary" @onclick="ShowCreateForm">Create Your First Task</button>
+            </div>
+        }
+        else if (tasks.Any())
+        {
+            <div class="task-list">
+                @foreach (var task in tasks)
+                {
+                    var nextRunTime = task.IsEnabled ? task.GetNextRunTimeUtc(DateTime.UtcNow) : null;
+                    <div class="task-card @(!task.IsEnabled ? "disabled" : "")">
+                        <div class="task-card-header">
+                            <div class="task-info">
+                                <span class="task-name">@task.Name</span>
+                                <span class="task-schedule">@task.ScheduleDescription</span>
+                            </div>
+                            <div class="task-actions">
+                                <label class="toggle-switch" title="@(task.IsEnabled ? "Disable" : "Enable")">
+                                    <input type="checkbox" checked="@task.IsEnabled" @onchange="e => ToggleEnabled(task, e)" />
+                                    <span class="toggle-slider"></span>
+                                </label>
+                                <button class="icon-btn" title="Edit" @onclick="() => EditTask(task)">
+                                    <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M11 4H4a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7"/><path d="M18.5 2.5a2.121 2.121 0 0 1 3 3L12 15l-4 1 1-4 9.5-9.5z"/></svg>
+                                </button>
+                                <button class="icon-btn" title="Run now" @onclick="() => RunNow(task)">
+                                    <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polygon points="5 3 19 12 5 21 5 3"/></svg>
+                                </button>
+                                <button class="icon-btn danger" title="Delete" @onclick="() => DeleteTask(task)">
+                                    <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polyline points="3 6 5 6 21 6"/><path d="M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2"/></svg>
+                                </button>
+                            </div>
+                        </div>
+                        <div class="task-card-body">
+                            <div class="task-prompt-preview">@TruncatePrompt(task.Prompt, 120)</div>
+                            @if (!string.IsNullOrEmpty(task.SessionName))
+                            {
+                                <span class="task-tag">Session: @task.SessionName</span>
+                            }
+                            else
+                            {
+                                <span class="task-tag">New session each run</span>
+                            }
+                        </div>
+                        @if (task.RecentRuns.Any())
+                        {
+                            <div class="task-card-footer">
+                                <span class="last-run">
+                                    Last run: @FormatTimeAgo(task.RecentRuns.Last().StartedAt)
+                                    @if (task.RecentRuns.Last().Success)
+                                    {
+                                        <span class="run-status success">✓</span>
+                                    }
+                                    else
+                                    {
+                                        <span class="run-status error" title="@task.RecentRuns.Last().Error">✗</span>
+                                    }
+                                </span>
+                                @if (nextRunTime != null)
+                                {
+                                    <span class="next-run">Next: @FormatTimeAgo(nextRunTime.Value)</span>
+                                }
+                            </div>
+                        }
+                        else if (nextRunTime != null)
+                        {
+                            <div class="task-card-footer">
+                                <span class="next-run">Next: @FormatTimeAgo(nextRunTime.Value)</span>
+                            </div>
+                        }
+                    </div>
+                }
+            </div>
+        }
+    </div>
+</div>
+
+@code {
+    private List<ScheduledTask> tasks = new();
+    private bool showForm;
+    private ScheduledTask? editingTask;
+
+    // Form fields
+    private string formName = "";
+    private string formPrompt = "";
+    private ScheduleType formSchedule = ScheduleType.Daily;
+    private int formIntervalMinutes = 60;
+    private string formTimeOfDay = "09:00";
+    private List<int> formDays = new() { 1, 2, 3, 4, 5 };
+    private string formSessionName = "";
+    private string formModel = "";
+    private string? formError;
+
+    private static readonly (int idx, string name)[] dayNames = new[]
+    {
+        (0, "Sun"), (1, "Mon"), (2, "Tue"), (3, "Wed"), (4, "Thu"), (5, "Fri"), (6, "Sat")
+    };
+
+    protected override void OnInitialized()
+    {
+        tasks = TaskService.GetTasks().ToList();
+        TaskService.OnTasksChanged += RefreshTasks;
+    }
+
+    private void RefreshTasks()
+    {
+        tasks = TaskService.GetTasks().ToList();
+        InvokeAsync(StateHasChanged);
+    }
+
+    private void ShowCreateForm()
+    {
+        editingTask = null;
+        formName = "";
+        formPrompt = "";
+        formSchedule = ScheduleType.Daily;
+        formIntervalMinutes = 60;
+        formTimeOfDay = "09:00";
+        formDays = new List<int> { 1, 2, 3, 4, 5 };
+        formSessionName = "";
+        formModel = "";
+        formError = null;
+        showForm = true;
+    }
+
+    private void EditTask(ScheduledTask task)
+    {
+        editingTask = task;
+        formName = task.Name;
+        formPrompt = task.Prompt;
+        formSchedule = task.Schedule;
+        formIntervalMinutes = task.IntervalMinutes;
+        formTimeOfDay = task.TimeOfDay;
+        formDays = task.DaysOfWeek.ToList();
+        formSessionName = task.SessionName ?? "";
+        formModel = task.Model ?? "";
+        formError = null;
+        showForm = true;
+    }
+
+    private void CancelForm()
+    {
+        showForm = false;
+        editingTask = null;
+        formError = null;
+    }
+
+    private void SaveTask()
+    {
+        formError = null;
+
+        if (string.IsNullOrWhiteSpace(formName))
+        {
+            formError = "Name is required.";
+            return;
+        }
+        if (string.IsNullOrWhiteSpace(formPrompt))
+        {
+            formError = "Prompt is required.";
+            return;
+        }
+        if (formSchedule == ScheduleType.Interval && formIntervalMinutes < 1)
+        {
+            formError = "Interval must be at least 1 minute.";
+            return;
+        }
+        if (formSchedule == ScheduleType.Weekly && !formDays.Any())
+        {
+            formError = "Select at least one day.";
+            return;
+        }
+
+        if (editingTask != null)
+        {
+            editingTask.Name = formName.Trim();
+            editingTask.Prompt = formPrompt.Trim();
+            editingTask.Schedule = formSchedule;
+            editingTask.IntervalMinutes = formIntervalMinutes;
+            editingTask.TimeOfDay = formTimeOfDay;
+            editingTask.DaysOfWeek = formDays.ToList();
+            editingTask.SessionName = string.IsNullOrWhiteSpace(formSessionName) ? null : formSessionName;
+            editingTask.Model = string.IsNullOrWhiteSpace(formModel) ? null : formModel;
+            TaskService.UpdateTask(editingTask);
+        }
+        else
+        {
+            var task = new ScheduledTask
+            {
+                Name = formName.Trim(),
+                Prompt = formPrompt.Trim(),
+                Schedule = formSchedule,
+                IntervalMinutes = formIntervalMinutes,
+                TimeOfDay = formTimeOfDay,
+                DaysOfWeek = formDays.ToList(),
+                SessionName = string.IsNullOrWhiteSpace(formSessionName) ? null : formSessionName,
+                Model = string.IsNullOrWhiteSpace(formModel) ? null : formModel
+            };
+            TaskService.AddTask(task);
+        }
+
+        showForm = false;
+        editingTask = null;
+        tasks = TaskService.GetTasks().ToList();
+    }
+
+    private void DeleteTask(ScheduledTask task)
+    {
+        TaskService.DeleteTask(task.Id);
+        tasks = TaskService.GetTasks().ToList();
+    }
+
+    private void ToggleEnabled(ScheduledTask task, ChangeEventArgs e)
+    {
+        var enabled = (bool)(e.Value ?? false);
+        TaskService.SetEnabled(task.Id, enabled);
+        tasks = TaskService.GetTasks().ToList();
+    }
+
+    private void ToggleDay(int day)
+    {
+        if (formDays.Contains(day))
+            formDays.Remove(day);
+        else
+            formDays.Add(day);
+    }
+
+    private async Task RunNow(ScheduledTask task)
+    {
+        await TaskService.ExecuteTaskAsync(task, DateTime.UtcNow);
+        tasks = TaskService.GetTasks().ToList();
+    }
+
+    private static string TruncatePrompt(string prompt, int maxLen)
+    {
+        if (string.IsNullOrEmpty(prompt)) return "";
+        return prompt.Length <= maxLen ? prompt : prompt[..maxLen] + "…";
+    }
+
+    private static string FormatTimeAgo(DateTime utcTime)
+    {
+        var now = DateTime.UtcNow;
+        if (utcTime > now)
+        {
+            var diff = utcTime - now;
+            if (diff.TotalMinutes < 1) return "in <1 min";
+            if (diff.TotalMinutes < 60) return $"in {(int)diff.TotalMinutes} min";
+            if (diff.TotalHours < 24) return $"in {(int)diff.TotalHours}h {diff.Minutes}m";
+            return utcTime.ToLocalTime().ToString("MMM d, h:mm tt");
+        }
+        else
+        {
+            var diff = now - utcTime;
+            if (diff.TotalMinutes < 1) return "<1 min ago";
+            if (diff.TotalMinutes < 60) return $"{(int)diff.TotalMinutes} min ago";
+            if (diff.TotalHours < 24) return $"{(int)diff.TotalHours}h ago";
+            return utcTime.ToLocalTime().ToString("MMM d, h:mm tt");
+        }
+    }
+
+    public void Dispose()
+    {
+        TaskService.OnTasksChanged -= RefreshTasks;
+    }
+}
diff --git a/PolyPilot/Components/Pages/ScheduledTasks.razor.css b/PolyPilot/Components/Pages/ScheduledTasks.razor.css
new file mode 100644
index 00000000..efa8be79
--- /dev/null
+++ b/PolyPilot/Components/Pages/ScheduledTasks.razor.css
@@ -0,0 +1,419 @@
+.scheduled-tasks-page {
+    padding: 1.5rem;
+    color: var(--text-primary);
+    background: var(--bg-primary);
+    height: 100%;
+    overflow-y: auto;
+    max-width: 800px;
+    box-sizing: border-box;
+}
+
+.scheduled-tasks-header {
+    margin-bottom: 1.5rem;
+}
+
+.scheduled-tasks-header h2 {
+    margin: 0;
+    font-size: var(--type-title2);
+}
+
+.header-row {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 1rem;
+}
+
+.header-subtitle {
+    margin: 0.5rem 0 0;
+    color: var(--text-dim);
+    font-size: var(--type-callout);
+}
+
+.add-task-btn {
+    padding: 0.5rem 1rem;
+    background: var(--accent-primary, #7c5cfc);
+    color: #fff;
+    border: none;
+    border-radius: 6px;
+    font-size: var(--type-callout);
+    cursor: pointer;
+    white-space: nowrap;
+    transition: opacity 0.15s;
+}
+
+.add-task-btn:hover {
+    opacity: 0.9;
+}
+
+/* ── Form ─────────────────────────────────────────── */
+
+.task-form-card {
+    background: var(--bg-secondary, var(--bg-primary));
+    border: 1px solid var(--control-border);
+    border-radius: 10px;
+    padding: 1.25rem;
+    margin-bottom: 1.5rem;
+}
+
+.form-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    margin-bottom: 1rem;
+}
+
+.form-header h3 {
+    margin: 0;
+    font-size: var(--type-title3);
+}
+
+.form-close-btn {
+    background: none;
+    border: none;
+    color: var(--text-dim);
+    font-size: var(--type-title3);
+    cursor: pointer;
+    padding: 0.2rem 0.4rem;
+}
+
+.form-group {
+    margin-bottom: 0.9rem;
+}
+
+.form-group label {
+    display: block;
+    margin-bottom: 0.3rem;
+    font-size: var(--type-callout);
+    color: var(--text-dim);
+    font-weight: 500;
+}
+
+.form-input,
+.form-select,
+.form-textarea {
+    width: 100%;
+    padding: 0.5rem 0.65rem;
+    border: 1px solid var(--control-border);
+    border-radius: 6px;
+    background: var(--bg-input, var(--bg-primary));
+    color: var(--text-primary);
+    font-size: var(--type-body);
+    box-sizing: border-box;
+    outline: none;
+    transition: border-color 0.2s;
+}
+
+.form-input:focus,
+.form-select:focus,
+.form-textarea:focus {
+    border-color: var(--accent-primary, #7c5cfc);
+}
+
+.short-input {
+    max-width: 200px;
+}
+
+.form-textarea {
+    resize: vertical;
+    font-family: inherit;
+    min-height: 80px;
+}
+
+.form-error {
+    color: #e74c3c;
+    font-size: var(--type-callout);
+    margin-bottom: 0.75rem;
+    padding: 0.4rem 0.6rem;
+    background: rgba(231, 76, 60, 0.08);
+    border-radius: 6px;
+}
+
+.form-actions {
+    display: flex;
+    gap: 0.5rem;
+    justify-content: flex-end;
+    margin-top: 0.5rem;
+}
+
+.btn-primary {
+    padding: 0.5rem 1rem;
+    background: var(--accent-primary, #7c5cfc);
+    color: #fff;
+    border: none;
+    border-radius: 6px;
+    font-size: var(--type-callout);
+    cursor: pointer;
+    transition: opacity 0.15s;
+}
+
+.btn-primary:hover {
+    opacity: 0.9;
+}
+
+.btn-secondary {
+    padding: 0.5rem 1rem;
+    background: transparent;
+    color: var(--text-dim);
+    border: 1px solid var(--control-border);
+    border-radius: 6px;
+    font-size: var(--type-callout);
+    cursor: pointer;
+    transition: background 0.15s;
+}
+
+.btn-secondary:hover {
+    background: var(--hover-bg);
+}
+
+/* ── Day picker ───────────────────────────────────── */
+
+.day-picker {
+    display: flex;
+    gap: 0.35rem;
+}
+
+.day-btn {
+    padding: 0.35rem 0.55rem;
+    border: 1px solid var(--control-border);
+    background: transparent;
+    color: var(--text-dim);
+    border-radius: 6px;
+    font-size: var(--type-callout);
+    cursor: pointer;
+    transition: all 0.15s;
+}
+
+.day-btn.selected {
+    background: var(--accent-primary, #7c5cfc);
+    color: #fff;
+    border-color: var(--accent-primary, #7c5cfc);
+}
+
+.day-btn:hover:not(.selected) {
+    background: var(--hover-bg);
+}
+
+/* ── Task list ────────────────────────────────────── */
+
+.task-list {
+    display: flex;
+    flex-direction: column;
+    gap: 0.75rem;
+}
+
+.task-card {
+    background: var(--bg-secondary, var(--bg-primary));
+    border: 1px solid var(--control-border);
+    border-radius: 10px;
+    padding: 1rem;
+    transition: border-color 0.15s;
+}
+
+.task-card:hover {
+    border-color: var(--accent-primary, #7c5cfc);
+}
+
+.task-card.disabled {
+    opacity: 0.55;
+}
+
+.task-card-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 0.75rem;
+}
+
+.task-info {
+    display: flex;
+    flex-direction: column;
+    min-width: 0;
+}
+
+.task-name {
+    font-weight: 600;
+    font-size: var(--type-body);
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+.task-schedule {
+    font-size: var(--type-callout);
+    color: var(--text-dim);
+    margin-top: 0.15rem;
+}
+
+.task-actions {
+    display: flex;
+    align-items: center;
+    gap: 0.35rem;
+    flex-shrink: 0;
+}
+
+.icon-btn {
+    background: none;
+    border: none;
+    color: var(--text-dim);
+    cursor: pointer;
+    padding: 0.3rem;
+    border-radius: 4px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    transition: color 0.15s, background 0.15s;
+}
+
+.icon-btn:hover {
+    color: var(--text-primary);
+    background: var(--hover-bg);
+}
+
+.icon-btn.danger:hover {
+    color: #e74c3c;
+}
+
+/* ── Toggle switch ────────────────────────────────── */
+
+.toggle-switch {
+    position: relative;
+    display: inline-block;
+    width: 36px;
+    height: 20px;
+    cursor: pointer;
+}
+
+.toggle-switch input {
+    opacity: 0;
+    width: 0;
+    height: 0;
+}
+
+.toggle-slider {
+    position: absolute;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    background: var(--control-border);
+    border-radius: 10px;
+    transition: background 0.2s;
+}
+
+.toggle-slider::before {
+    content: "";
+    position: absolute;
+    height: 14px;
+    width: 14px;
+    left: 3px;
+    bottom: 3px;
+    background: #fff;
+    border-radius: 50%;
+    transition: transform 0.2s;
+}
+
+.toggle-switch input:checked + .toggle-slider {
+    background: var(--accent-primary, #7c5cfc);
+}
+
+.toggle-switch input:checked + .toggle-slider::before {
+    transform: translateX(16px);
+}
+
+/* ── Task card body/footer ────────────────────────── */
+
+.task-card-body {
+    margin-top: 0.6rem;
+    padding-top: 0.6rem;
+    border-top: 1px solid var(--control-border);
+}
+
+.task-prompt-preview {
+    font-size: var(--type-callout);
+    color: var(--text-dim);
+    line-height: 1.4;
+    word-break: break-word;
+}
+
+.task-tag {
+    display: inline-block;
+    margin-top: 0.4rem;
+    padding: 0.15rem 0.5rem;
+    font-size: var(--type-callout);
+    background: var(--hover-bg, rgba(124, 92, 252, 0.1));
+    border-radius: 4px;
+    color: var(--text-dim);
+}
+
+.task-card-footer {
+    margin-top: 0.5rem;
+    padding-top: 0.5rem;
+    border-top: 1px solid var(--control-border);
+    display: flex;
+    justify-content: space-between;
+    font-size: var(--type-callout);
+    color: var(--text-dim);
+}
+
+.last-run,
+.next-run {
+    display: flex;
+    align-items: center;
+    gap: 0.3rem;
+}
+
+.run-status.success {
+    color: #2ecc71;
+}
+
+.run-status.error {
+    color: #e74c3c;
+}
+
+/* ── Empty state ──────────────────────────────────── */
+
+.empty-state {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    text-align: center;
+    padding: 3rem 1rem;
+}
+
+.empty-icon {
+    font-size: var(--type-title1);
+    margin-bottom: 1rem;
+}
+
+.empty-title {
+    font-size: var(--type-title3);
+    margin: 0 0 0.5rem;
+}
+
+.empty-desc {
+    color: var(--text-dim);
+    font-size: var(--type-callout);
+    margin: 0 0 1.5rem;
+    max-width: 360px;
+}
+
+/* ── Responsive ───────────────────────────────────── */
+
+@media (max-width: 600px) {
+    .scheduled-tasks-page {
+        padding: 1rem;
+    }
+    .header-row {
+        flex-direction: column;
+        align-items: stretch;
+    }
+    .task-card-header {
+        flex-direction: column;
+        align-items: flex-start;
+    }
+    .task-actions {
+        margin-top: 0.5rem;
+    }
+}
diff --git a/PolyPilot/MauiProgram.cs b/PolyPilot/MauiProgram.cs
index b313f32a..53b91ab7 100644
--- a/PolyPilot/MauiProgram.cs
+++ b/PolyPilot/MauiProgram.cs
@@ -116,6 +116,7 @@ public static MauiApp CreateMauiApp()
 	builder.Services.AddSingleton<INotificationManagerService, NotificationManagerService>();
 	builder.Services.AddSingleton<ISpeechToText>(SpeechToText.Default);
 	builder.Services.AddSingleton<EfficiencyAnalysisService>();
+	builder.Services.AddSingleton<ScheduledTaskService>();
 
 #if DEBUG
 		builder.Services.AddBlazorWebViewDeveloperTools();
diff --git a/PolyPilot/Models/ScheduledTask.cs b/PolyPilot/Models/ScheduledTask.cs
new file mode 100644
index 00000000..54186739
--- /dev/null
+++ b/PolyPilot/Models/ScheduledTask.cs
@@ -0,0 +1,176 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace PolyPilot.Models;
+
+/// <summary>
+/// Defines the recurrence type for a scheduled task.
+/// </summary>
+public enum ScheduleType
+{
+    /// <summary>Run every N minutes.</summary>
+    Interval,
+    /// <summary>Run once daily at a specific time.</summary>
+    Daily,
+    /// <summary>Run on specific days of the week at a specific time.</summary>
+    Weekly
+}
+
+/// <summary>
+/// A single execution log entry for a scheduled task.
+/// </summary>
+public class ScheduledTaskRun
+{
+    public DateTime StartedAt { get; set; }
+    public DateTime? CompletedAt { get; set; }
+    public string? SessionName { get; set; }
+    public bool Success { get; set; }
+    public string? Error { get; set; }
+}
+
+/// <summary>
+/// A recurring task definition — prompt, schedule, and execution state.
+/// Persisted to ~/.polypilot/scheduled-tasks.json.
+/// </summary>
+public class ScheduledTask
+{
+    public string Id { get; set; } = Guid.NewGuid().ToString("N");
+    public string Name { get; set; } = "";
+    public string Prompt { get; set; } = "";
+
+    /// <summary>
+    /// Target an existing session by name. If null, a new session is created for each run.
+    /// </summary>
+    public string? SessionName { get; set; }
+
+    /// <summary>Model to use when creating a new session. Ignored when SessionName is set.</summary>
+    public string? Model { get; set; }
+
+    /// <summary>Working directory for newly created sessions.</summary>
+    public string? WorkingDirectory { get; set; }
+
+    public ScheduleType Schedule { get; set; } = ScheduleType.Daily;
+
+    /// <summary>Interval in minutes — used when Schedule == Interval.</summary>
+    public int IntervalMinutes { get; set; } = 60;
+
+    /// <summary>Time of day (local) — used when Schedule is Daily or Weekly.</summary>
+    public string TimeOfDay { get; set; } = "09:00";
+
+    /// <summary>Days of week — used when Schedule == Weekly. 0=Sunday..6=Saturday.</summary>
+    public List<int> DaysOfWeek { get; set; } = new() { 1, 2, 3, 4, 5 }; // weekdays
+
+    public bool IsEnabled { get; set; } = true;
+    public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
+    public DateTime? LastRunAt { get; set; }
+
+    /// <summary>Recent execution history (kept to last 10 runs).</summary>
+    public List<ScheduledTaskRun> RecentRuns { get; set; } = new();
+
+    // ── Schedule calculation ──────────────────────────────────────────
+
+    /// <summary>
+    /// Parses the TimeOfDay string ("HH:mm") into hours and minutes.
+    /// Returns (9, 0) as default if parsing fails.
+    /// </summary>
+    internal (int hours, int minutes) ParseTimeOfDay()
+    {
+        if (TimeSpan.TryParse(TimeOfDay, out var ts))
+            return (ts.Hours, ts.Minutes);
+        return (9, 0);
+    }
+
+    /// <summary>
+    /// Calculates the next run time based on the schedule and the last run time.
+    /// Returns null if the task cannot be scheduled (e.g., Weekly with no days selected).
+    /// </summary>
+    public DateTime? GetNextRunTimeUtc(DateTime now)
+    {
+        switch (Schedule)
+        {
+            case ScheduleType.Interval:
+                if (IntervalMinutes <= 0) return null;
+                if (LastRunAt == null) return now; // run immediately
+                var next = LastRunAt.Value.AddMinutes(IntervalMinutes);
+                return next <= now ? now : next;
+
+            case ScheduleType.Daily:
+            {
+                var (h, m) = ParseTimeOfDay();
+                var todayLocal = now.ToLocalTime().Date.AddHours(h).AddMinutes(m);
+                var todayUtc = todayLocal.ToUniversalTime();
+                if (LastRunAt == null)
+                    return todayUtc; // never run — schedule for today's slot (may be in the past, that's fine — IsDue will fire)
+                if (todayUtc > now && LastRunAt.Value.Date < now.ToLocalTime().Date)
+                    return todayUtc;
+                // Next day
+                return todayLocal.AddDays(1).ToUniversalTime();
+            }
+
+            case ScheduleType.Weekly:
+            {
+                if (DaysOfWeek.Count == 0) return null;
+                var (h, m) = ParseTimeOfDay();
+                var localNow = now.ToLocalTime();
+                // Look up to 8 days ahead to find the next matching day
+                for (int i = 0; i <= 7; i++)
+                {
+                    var candidate = localNow.Date.AddDays(i).AddHours(h).AddMinutes(m);
+                    var candidateUtc = candidate.ToUniversalTime();
+                    if (candidateUtc <= now && i == 0) continue; // today's slot already passed
+                    var dow = (int)candidate.DayOfWeek;
+                    if (DaysOfWeek.Contains(dow))
+                    {
+                        // Ensure we haven't already run at this slot
+                        if (LastRunAt != null && LastRunAt.Value >= candidateUtc) continue;
+                        return candidateUtc;
+                    }
+                }
+                return null;
+            }
+
+            default:
+                return null;
+        }
+    }
+
+    /// <summary>Returns true if the task is due to run now.</summary>
+    public bool IsDue(DateTime utcNow)
+    {
+        if (!IsEnabled) return false;
+        var next = GetNextRunTimeUtc(utcNow);
+        return next != null && next.Value <= utcNow;
+    }
+
+    /// <summary>Adds a run entry and trims history to 10 entries.</summary>
+    public void RecordRun(ScheduledTaskRun run)
+    {
+        RecentRuns.Add(run);
+        if (RecentRuns.Count > 10)
+            RecentRuns.RemoveRange(0, RecentRuns.Count - 10);
+        LastRunAt = run.StartedAt;
+    }
+
+    /// <summary>Human-readable schedule description for the UI.</summary>
+    [JsonIgnore]
+    public string ScheduleDescription
+    {
+        get
+        {
+            return Schedule switch
+            {
+                ScheduleType.Interval => $"Every {IntervalMinutes} minute{(IntervalMinutes != 1 ? "s" : "")}",
+                ScheduleType.Daily => $"Daily at {TimeOfDay}",
+                ScheduleType.Weekly => $"Weekly ({FormatDays()}) at {TimeOfDay}",
+                _ => "Unknown"
+            };
+        }
+    }
+
+    private string FormatDays()
+    {
+        var dayNames = new[] { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
+        var sorted = DaysOfWeek.Where(d => d >= 0 && d <= 6).OrderBy(d => d);
+        return string.Join(", ", sorted.Select(d => dayNames[d]));
+    }
+}
diff --git a/PolyPilot/Services/ScheduledTaskService.cs b/PolyPilot/Services/ScheduledTaskService.cs
new file mode 100644
index 00000000..a56f8c68
--- /dev/null
+++ b/PolyPilot/Services/ScheduledTaskService.cs
@@ -0,0 +1,288 @@
+using System.Text.Json;
+using PolyPilot.Models;
+
+namespace PolyPilot.Services;
+
+/// <summary>
+/// Manages scheduled (recurring) tasks — persistence, background evaluation, and execution.
+/// Tasks are stored in ~/.polypilot/scheduled-tasks.json and evaluated every 30 seconds.
+/// When a task is due, it sends the configured prompt to the target session (or creates a new one).
+/// </summary>
+public class ScheduledTaskService : IDisposable
+{
+    private static string? _tasksFilePath;
+    private static string TasksFilePath => _tasksFilePath ??= Path.Combine(GetPolyPilotDir(), "scheduled-tasks.json");
+
+    /// <summary>Override file path for tests to prevent writing to real ~/.polypilot/.</summary>
+    internal static void SetTasksFilePathForTesting(string path) => _tasksFilePath = path;
+
+    private readonly CopilotService _copilotService;
+    private readonly List<ScheduledTask> _tasks = new();
+    private readonly object _lock = new();
+    private Timer? _evaluationTimer;
+    private int _evaluating; // Guard against overlapping evaluations
+    private bool _disposed;
+
+    /// <summary>Raised when any task list or state change occurs (for UI refresh).</summary>
+    public event Action? OnTasksChanged;
+
+    /// <summary>Interval between schedule evaluations.</summary>
+    internal const int EvaluationIntervalSeconds = 30;
+
+    public ScheduledTaskService(CopilotService copilotService)
+    {
+        _copilotService = copilotService;
+        LoadTasks();
+        Start(); // Auto-start the evaluation timer
+    }
+
+    /// <summary>Start the background evaluation timer.</summary>
+    public void Start()
+    {
+        _evaluationTimer?.Dispose();
+        _evaluationTimer = new Timer(
+            _ => _ = EvaluateTasksAsync(),
+            null,
+            TimeSpan.FromSeconds(EvaluationIntervalSeconds),
+            TimeSpan.FromSeconds(EvaluationIntervalSeconds));
+    }
+
+    /// <summary>Stop the background evaluation timer.</summary>
+    public void Stop()
+    {
+        _evaluationTimer?.Dispose();
+        _evaluationTimer = null;
+    }
+
+    // ── CRUD ──────────────────────────────────────────────────────────
+
+    public IReadOnlyList<ScheduledTask> GetTasks()
+    {
+        lock (_lock) return _tasks.ToList();
+    }
+
+    public ScheduledTask? GetTask(string id)
+    {
+        lock (_lock) return _tasks.FirstOrDefault(t => t.Id == id);
+    }
+
+    public void AddTask(ScheduledTask task)
+    {
+        lock (_lock) _tasks.Add(task);
+        SaveTasks();
+        OnTasksChanged?.Invoke();
+    }
+
+    public void UpdateTask(ScheduledTask task)
+    {
+        lock (_lock)
+        {
+            var idx = _tasks.FindIndex(t => t.Id == task.Id);
+            if (idx >= 0) _tasks[idx] = task;
+        }
+        SaveTasks();
+        OnTasksChanged?.Invoke();
+    }
+
+    public bool DeleteTask(string id)
+    {
+        bool removed;
+        lock (_lock) removed = _tasks.RemoveAll(t => t.Id == id) > 0;
+        if (removed)
+        {
+            SaveTasks();
+            OnTasksChanged?.Invoke();
+        }
+        return removed;
+    }
+
+    public void SetEnabled(string id, bool enabled)
+    {
+        lock (_lock)
+        {
+            var task = _tasks.FirstOrDefault(t => t.Id == id);
+            if (task != null) task.IsEnabled = enabled;
+        }
+        SaveTasks();
+        OnTasksChanged?.Invoke();
+    }
+
+    // ── Evaluation ───────────────────────────────────────────────────
+
+    /// <summary>
+    /// Evaluate all tasks and execute any that are due.
+    /// Called by the background timer every 30 seconds.
+    /// Uses an interlocked guard to prevent overlapping evaluations.
+    /// </summary>
+    internal async Task EvaluateTasksAsync()
+    {
+        // Prevent overlapping evaluations if a previous run is still executing
+        if (Interlocked.CompareExchange(ref _evaluating, 1, 0) != 0) return;
+
+        try
+        {
+            List<ScheduledTask> dueTasks;
+            var now = DateTime.UtcNow;
+
+            lock (_lock)
+            {
+                dueTasks = _tasks.Where(t => t.IsDue(now)).ToList();
+            }
+
+            foreach (var task in dueTasks)
+            {
+                await ExecuteTaskAsync(task, now);
+            }
+        }
+        finally
+        {
+            Interlocked.Exchange(ref _evaluating, 0);
+        }
+    }
+
+    /// <summary>Execute a single scheduled task.</summary>
+    internal async Task ExecuteTaskAsync(ScheduledTask task, DateTime utcNow)
+    {
+        var run = new ScheduledTaskRun { StartedAt = utcNow };
+
+        try
+        {
+            if (!_copilotService.IsInitialized)
+            {
+                run.Error = "CopilotService not initialized";
+                run.Success = false;
+                RecordRunAndSave(task, run);
+                return;
+            }
+
+            string sessionName;
+
+            if (!string.IsNullOrEmpty(task.SessionName))
+            {
+                // Use existing session
+                sessionName = task.SessionName;
+                var sessions = _copilotService.GetAllSessions();
+                if (!sessions.Any(s => s.Name == sessionName))
+                {
+                    run.Error = $"Session '{sessionName}' not found";
+                    run.Success = false;
+                    RecordRunAndSave(task, run);
+                    return;
+                }
+            }
+            else
+            {
+                // Create a new session for this run
+                var timestamp = utcNow.ToLocalTime().ToString("MMM dd HH:mm");
+                sessionName = $"⏰ {task.Name} ({timestamp})";
+                try
+                {
+                    await _copilotService.CreateSessionAsync(sessionName, task.Model, task.WorkingDirectory);
+                }
+                catch (Exception ex)
+                {
+                    run.Error = $"Failed to create session: {ex.Message}";
+                    run.Success = false;
+                    RecordRunAndSave(task, run);
+                    return;
+                }
+            }
+
+            run.SessionName = sessionName;
+            await _copilotService.SendPromptAsync(sessionName, task.Prompt);
+
+            run.CompletedAt = DateTime.UtcNow;
+            run.Success = true;
+        }
+        catch (Exception ex)
+        {
+            run.CompletedAt = DateTime.UtcNow;
+            run.Error = ex.Message;
+            run.Success = false;
+            System.Diagnostics.Debug.WriteLine($"[ScheduledTask] Execution failed for '{task.Name}': {ex.Message}");
+        }
+
+        RecordRunAndSave(task, run);
+    }
+
+    private void RecordRunAndSave(ScheduledTask task, ScheduledTaskRun run)
+    {
+        lock (_lock) task.RecordRun(run);
+        SaveTasks();
+        OnTasksChanged?.Invoke();
+    }
+
+    // ── Persistence ──────────────────────────────────────────────────
+
+    internal void LoadTasks()
+    {
+        try
+        {
+            if (File.Exists(TasksFilePath))
+            {
+                var json = File.ReadAllText(TasksFilePath);
+                var loaded = JsonSerializer.Deserialize<List<ScheduledTask>>(json);
+                if (loaded != null)
+                {
+                    lock (_lock)
+                    {
+                        _tasks.Clear();
+                        _tasks.AddRange(loaded);
+                    }
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            System.Diagnostics.Debug.WriteLine($"[ScheduledTask] Failed to load tasks: {ex.Message}");
+        }
+    }
+
+    internal void SaveTasks()
+    {
+        try
+        {
+            List<ScheduledTask> snapshot;
+            lock (_lock) snapshot = _tasks.ToList();
+
+            var dir = Path.GetDirectoryName(TasksFilePath)!;
+            Directory.CreateDirectory(dir);
+            var json = JsonSerializer.Serialize(snapshot, new JsonSerializerOptions { WriteIndented = true });
+            File.WriteAllText(TasksFilePath, json);
+        }
+        catch (Exception ex)
+        {
+            System.Diagnostics.Debug.WriteLine($"[ScheduledTask] Failed to save tasks: {ex.Message}");
+        }
+    }
+
+    private static string GetPolyPilotDir()
+    {
+#if IOS || ANDROID
+        try
+        {
+            return Path.Combine(FileSystem.AppDataDirectory, ".polypilot");
+        }
+        catch
+        {
+            var fallback = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
+            if (string.IsNullOrEmpty(fallback))
+                fallback = Path.GetTempPath();
+            return Path.Combine(fallback, ".polypilot");
+        }
+#else
+        var home = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
+        if (string.IsNullOrEmpty(home))
+            home = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
+        return Path.Combine(home, ".polypilot");
+#endif
+    }
+
+    public void Dispose()
+    {
+        if (_disposed) return;
+        _disposed = true;
+        _evaluationTimer?.Dispose();
+        _evaluationTimer = null;
+    }
+}