Add scheduled tasks - the deferred "automation" item, scoped honestly

Run a saved prompt against a chosen model on a repeating interval while
the app is open (Settings -> Automation). Each task gets a dedicated
chat session it appends results to, so you get a running log instead
of a new sidebar entry every run.

Deliberately scoped down from a full "scheduled agent": this only runs
while Modelforge is open (setInterval timers in the main process, no
OS-level task registration - closing the app stops it), and it's plain
chat completions, not Agent mode - tool-calling would need porting the
renderer's tool loop into the main process, a materially bigger change
than the rest of this feature.

Implementation:
- scheduled-tasks-store.ts: CRUD persistence, same pattern as the
  other *-store.ts modules.
- scheduler.ts: owns the interval timers, reschedules on any
  create/update/delete, and runs a task by calling back into main.ts's
  existing provider-dispatch logic (extracted into a shared
  dispatchChat/completePrompt pair also used by chat:send, rather than
  duplicating the ollama/llamacpp/openai/anthropic branching a second
  time).
- Settings -> Automation tab: create/enable/disable/run-now/delete,
  reusing the same model picker as chat defaults.

Found and fixed a real race while verifying in a live browser session:
creating a task optimistically appended it to local state, but the
initial mount fetch (a separate window.api.scheduledTasks.list() call)
could resolve *after* that append and already include the same task,
producing a visible duplicate. Confirmed via React fiber inspection
that the state array itself held two entries, not just a rendering
artifact, then fixed by re-fetching the list after create instead of
appending optimistically, and confirmed the fix holds even with an
artificially delayed mount fetch designed to force the race.

Author: voidstackloop

README.md

@@ -54,6 +54,9 @@ Beyond chat, Modelforge includes an **agentic mode** — the model can read/writ
 
 **Agent mode** — see the [dedicated section](#agent-mode) below.
 
+**Automation**
+- **Scheduled tasks** (Settings → Automation) — run a saved prompt against a chosen model on a repeating interval while the app is open, with results appended to a dedicated chat for that task so you get a running log rather than a new chat every time. This only runs while Modelforge is open (there's no OS-level background service), and doesn't use Agent mode tools — it's plain scheduled chat completions, not a scheduled agent run.
+
 **Models & hardware**
 - Model recommendations based on your actual hardware — RAM and VRAM are detected and summed **across all GPUs**, not just the first one, so multi-GPU machines get accurate suggestions.
 - **GPU offload control** — set how many model layers Ollama offloads to GPU (`num_gpu`) per chat, per project, or as a global default; leave it blank to let Ollama decide automatically.

app/src/main.ts

@@ -18,13 +18,15 @@ import * as figma from "./figma";
 import * as ocr from "./ocr";
 import * as huggingface from "./huggingface";
 import * as llamacpp from "./llamacpp-manager";
+import * as scheduledTasksStore from "./scheduled-tasks-store";
+import * as scheduler from "./scheduler";
 import type { McpServerConfig } from "./mcp-client";
 import type { AttachedFile } from "./file-reader";
 import * as openaiProvider from "./providers/openai";
 import * as anthropicProvider from "./providers/anthropic";
 import { setupMenu } from "./menu";
 import { setupAutoUpdater, checkForUpdatesManually } from "./updater";
-import type { ChatMessage, ChatChunk, ChatOptions, ProviderId } from "./providers/types";
+import type { ChatMessage, ChatChunk, ChatOptions, ProviderId, ToolDefinition } from "./providers/types";
 
 const PROVIDER_SECRET_KEYS: Record<Exclude<ProviderId, "ollama" | "llamacpp">, string> = {
     openai: "openai_api_key",
@@ -158,6 +160,43 @@ function createWindow(): void {
     }
 }
 
+// Shared by chat:send (renderer-driven, streams tokens back over IPC) and
+// the scheduled-task runner (background, wants the full text once done) —
+// same provider dispatch and error handling either way.
+async function dispatchChat(
+    provider: ProviderId,
+    model: string,
+    messages: ChatMessage[],
+    options: ChatOptions | undefined,
+    onToken: (chunk: ChatChunk) => void,
+    signal?: AbortSignal,
+    tools?: ToolDefinition[]
+): Promise<void> {
+    if (provider === "ollama") {
+        await ollama.chat(model, messages, options, onToken, signal, tools);
+    } else if (provider === "llamacpp") {
+        const modelPath = path.join(getLlamaCppModelsDir(), model);
+        await llamacpp.chat(modelPath, messages, options, onToken, signal, tools);
+    } else {
+        const secretKey = PROVIDER_SECRET_KEYS[provider];
+        const apiKey = secretsStore.getSecret(secretKey);
+        if (!apiKey) throw new Error(`No API key set for ${provider}. Add one in Settings.`);
+        const providerFn = provider === "openai" ? openaiProvider.chat : anthropicProvider.chat;
+        await providerFn(apiKey, model, messages, options, onToken, signal, tools);
+    }
+}
+
+// Runs a single-turn prompt to completion and returns the full text —
+// what the scheduled-task runner needs, as opposed to chat:send's
+// token-by-token streaming back to the renderer.
+async function completePrompt(provider: ProviderId, model: string, prompt: string): Promise<string> {
+    let text = "";
+    await dispatchChat(provider, model, [{ role: "user", content: prompt }], undefined, (chunk) => {
+        text += chunk.message?.content ?? "";
+    });
+    return text;
+}
+
 function registerIpcHandlers(): void {
     ipcMain.handle("ollama:status", () => ollama.isRunning());
     ipcMain.handle("ollama:start", () => ollama.start());
@@ -253,20 +292,7 @@ function registerIpcHandlers(): void {
             activeChatRequests.set(requestId, controller);
             const tools = agentMode ? [...agentTools.AGENT_TOOLS, ...mcpClient.getConnectedTools()] : undefined;
             try {
-                if (provider === "ollama") {
-                    await ollama.chat(model, messages, options, onToken, controller.signal, tools);
-                } else if (provider === "llamacpp") {
-                    const modelPath = path.join(getLlamaCppModelsDir(), model);
-                    await llamacpp.chat(modelPath, messages, options, onToken, controller.signal, tools);
-                } else {
-                    const secretKey = PROVIDER_SECRET_KEYS[provider];
-                    const apiKey = secretsStore.getSecret(secretKey);
-                    if (!apiKey) {
-                        throw new Error(`No API key set for ${provider}. Add one in Settings.`);
-                    }
-                    const providerFn = provider === "openai" ? openaiProvider.chat : anthropicProvider.chat;
-                    await providerFn(apiKey, model, messages, options, onToken, controller.signal, tools);
-                }
+                await dispatchChat(provider, model, messages, options, onToken, controller.signal, tools);
                 return { done: true };
             } catch (err) {
                 const error = err as Error;
@@ -315,6 +341,59 @@ function registerIpcHandlers(): void {
     );
     ipcMain.handle("sessions:clearAll", () => sessionsStore.clearAll());
 
+    ipcMain.handle("scheduledTasks:list", () => scheduledTasksStore.listTasks());
+
+    ipcMain.handle(
+        "scheduledTasks:create",
+        (
+            _event: IpcMainInvokeEvent,
+            {
+                name,
+                prompt,
+                model,
+                intervalMinutes,
+            }: { name: string; prompt: string; model: string; intervalMinutes: number }
+        ) => {
+            requireString(name, "task name");
+            requireString(prompt, "task prompt");
+            requireString(model, "task model");
+            // Each task gets a dedicated chat session it appends results to —
+            // created here so the task always has somewhere to write to.
+            const session = sessionsStore.createSession(model);
+            sessionsStore.updateSession(session.id, { title: name });
+            const task = scheduledTasksStore.createTask({
+                name,
+                prompt,
+                model,
+                targetSessionId: session.id,
+                intervalMinutes: Math.max(1, intervalMinutes || 60),
+            });
+            scheduler.rescheduleAll();
+            return task;
+        }
+    );
+
+    ipcMain.handle(
+        "scheduledTasks:update",
+        (_event: IpcMainInvokeEvent, { id, partial }: { id: string; partial: Record<string, unknown> }) => {
+            requireString(id, "task id");
+            const updated = scheduledTasksStore.updateTask(id, partial);
+            scheduler.rescheduleAll();
+            return updated;
+        }
+    );
+
+    ipcMain.handle("scheduledTasks:delete", (_event: IpcMainInvokeEvent, id: string) => {
+        requireString(id, "task id");
+        scheduledTasksStore.deleteTask(id);
+        scheduler.rescheduleAll();
+    });
+
+    ipcMain.handle("scheduledTasks:runNow", (_event: IpcMainInvokeEvent, id: string) => {
+        requireString(id, "task id");
+        return scheduler.runTask(id);
+    });
+
     ipcMain.handle("projects:list", () => projectsStore.listProjects());
     ipcMain.handle("projects:create", (_event: IpcMainInvokeEvent, name: string) =>
         projectsStore.createProject(requireString(name, "project name"))
@@ -580,6 +659,7 @@ app.whenReady().then(async () => {
     llamacpp.setGpuBackend(settingsStore.getSettings().llamaCppGpuBackend ?? "auto");
     setupAutoUpdater(() => mainWindow);
     void connectEnabledMcpServers();
+    scheduler.init((provider, model, prompt) => completePrompt(provider as ProviderId, model, prompt));
 
     app.on("activate", () => {
         if (BrowserWindow.getAllWindows().length === 0) createWindow();

app/src/preload.ts

@@ -6,6 +6,7 @@ import type { McpServerConfig, McpServerStatus } from "./mcp-client";
 import type { RollbackResult, ProjectScripts } from "./agent-tools";
 import type { PromptPreset } from "./settings-store";
 import type { LocalGgufModel, GpuBackend } from "./llamacpp-manager";
+import type { ScheduledTask } from "./scheduled-tasks-store";
 
 interface ToolExecuteResult {
     result?: unknown;
@@ -135,6 +136,16 @@ contextBridge.exposeInMainWorld("api", {
         clearAll: () => ipcRenderer.invoke("sessions:clearAll"),
     },
 
+    scheduledTasks: {
+        list: (): Promise<ScheduledTask[]> => ipcRenderer.invoke("scheduledTasks:list"),
+        create: (name: string, prompt: string, model: string, intervalMinutes: number): Promise<ScheduledTask> =>
+            ipcRenderer.invoke("scheduledTasks:create", { name, prompt, model, intervalMinutes }),
+        update: (id: string, partial: Record<string, unknown>): Promise<ScheduledTask | null> =>
+            ipcRenderer.invoke("scheduledTasks:update", { id, partial }),
+        delete: (id: string): Promise<void> => ipcRenderer.invoke("scheduledTasks:delete", id),
+        runNow: (id: string): Promise<void> => ipcRenderer.invoke("scheduledTasks:runNow", id),
+    },
+
     files: {
         openAndRead: () => ipcRenderer.invoke("files:openAndRead"),
         openFolderAndRead: () => ipcRenderer.invoke("files:openFolderAndRead"),

app/src/scheduled-tasks-store.test.ts

@@ -0,0 +1,52 @@
+import { describe, it, expect } from "vitest";
+import { listTasks, getTask, createTask, updateTask, deleteTask } from "./scheduled-tasks-store";
+
+describe("scheduled-tasks-store", () => {
+    it("starts with no tasks", () => {
+        expect(listTasks()).toEqual([]);
+    });
+
+    it("creates a task with sensible defaults", () => {
+        const task = createTask({
+            name: "Check something",
+            prompt: "Summarize the latest changes.",
+            model: "ollama:llama3.1:8b",
+            targetSessionId: "session-1",
+            intervalMinutes: 30,
+        });
+        expect(task.enabled).toBe(true);
+        expect(task.lastRunAt).toBeNull();
+        expect(task.lastError).toBeNull();
+        expect(getTask(task.id)).toEqual(task);
+    });
+
+    it("updates a task in place", () => {
+        const task = createTask({
+            name: "A",
+            prompt: "p",
+            model: "ollama:m",
+            targetSessionId: "s",
+            intervalMinutes: 10,
+        });
+        const updated = updateTask(task.id, { enabled: false, lastError: "boom" });
+        expect(updated?.enabled).toBe(false);
+        expect(updated?.lastError).toBe("boom");
+        expect(getTask(task.id)?.enabled).toBe(false);
+    });
+
+    it("returns null when updating a task that doesn't exist", () => {
+        expect(updateTask("nonexistent", { enabled: false })).toBeNull();
+    });
+
+    it("deletes a task", () => {
+        const task = createTask({
+            name: "B",
+            prompt: "p",
+            model: "ollama:m",
+            targetSessionId: "s",
+            intervalMinutes: 10,
+        });
+        deleteTask(task.id);
+        expect(getTask(task.id)).toBeNull();
+    });
+});

app/src/scheduled-tasks-store.ts

@@ -0,0 +1,68 @@
+import * as path from "node:path";
+import { randomUUID } from "node:crypto";
+import { app } from "electron";
+import { readJson, writeJson } from "./json-store";
+
+export interface ScheduledTask {
+    id: string;
+    name: string;
+    prompt: string;
+    // "provider:modelId", same format used everywhere else in the app.
+    model: string;
+    // Every run appends to this one chat session (created alongside the
+    // task) rather than starting a fresh chat each time — a running log of
+    // results is far more useful than a new sidebar entry every interval.
+    targetSessionId: string;
+    intervalMinutes: number;
+    enabled: boolean;
+    lastRunAt: string | null;
+    lastError: string | null;
+    createdAt: string;
+}
+
+function filePath(): string {
+    return path.join(app.getPath("userData"), "scheduled-tasks.json");
+}
+
+export function listTasks(): ScheduledTask[] {
+    return readJson<ScheduledTask[]>(filePath(), []);
+}
+
+export function getTask(id: string): ScheduledTask | null {
+    return listTasks().find((t) => t.id === id) ?? null;
+}
+
+export function createTask(
+    partial: Pick<ScheduledTask, "name" | "prompt" | "model" | "targetSessionId" | "intervalMinutes">
+): ScheduledTask {
+    const task: ScheduledTask = {
+        id: randomUUID(),
+        enabled: true,
+        lastRunAt: null,
+        lastError: null,
+        createdAt: new Date().toISOString(),
+        ...partial,
+    };
+    const all = listTasks();
+    all.push(task);
+    writeJson(filePath(), all);
+    return task;
+}
+
+export function updateTask(
+    id: string,
+    partial: Partial<
+        Pick<ScheduledTask, "name" | "prompt" | "model" | "intervalMinutes" | "enabled" | "lastRunAt" | "lastError">
+    >
+): ScheduledTask | null {
+    const all = listTasks();
+    const idx = all.findIndex((t) => t.id === id);
+    if (idx === -1) return null;
+    all[idx] = { ...all[idx], ...partial };
+    writeJson(filePath(), all);
+    return all[idx];
+}
+
+export function deleteTask(id: string): void {
+    writeJson(filePath(), listTasks().filter((t) => t.id !== id));
+}

app/src/scheduler.test.ts

@@ -0,0 +1,72 @@
+import { describe, it, expect, vi } from "vitest";
+import * as scheduler from "./scheduler";
+import * as scheduledTasksStore from "./scheduled-tasks-store";
+import * as sessionsStore from "./sessions-store";
+
+describe("scheduler.runTask", () => {
+    it("appends the prompt and response to the task's target session on success", async () => {
+        const session = sessionsStore.createSession("ollama:llama3.1:8b");
+        const task = scheduledTasksStore.createTask({
+            name: "Test task",
+            prompt: "How's it going?",
+            model: "ollama:llama3.1:8b",
+            targetSessionId: session.id,
+            intervalMinutes: 30,
+        });
+
+        scheduler.init(async () => "All good.");
+        await scheduler.runTask(task.id);
+
+        const updatedSession = sessionsStore.getSession(session.id);
+        expect(updatedSession?.messages).toEqual([
+            { role: "user", content: "How's it going?" },
+            { role: "assistant", content: "All good." },
+        ]);
+        const updatedTask = scheduledTasksStore.getTask(task.id);
+        expect(updatedTask?.lastRunAt).not.toBeNull();
+        expect(updatedTask?.lastError).toBeNull();
+    });
+
+    it("records the error and leaves the session untouched when the prompt fails", async () => {
+        const session = sessionsStore.createSession("ollama:llama3.1:8b");
+        const task = scheduledTasksStore.createTask({
+            name: "Failing task",
+            prompt: "Do the thing.",
+            model: "ollama:llama3.1:8b",
+            targetSessionId: session.id,
+            intervalMinutes: 30,
+        });
+
+        scheduler.init(async () => {
+            throw new Error("model unavailable");
+        });
+        await scheduler.runTask(task.id);
+
+        const updatedSession = sessionsStore.getSession(session.id);
+        expect(updatedSession?.messages).toEqual([]);
+        const updatedTask = scheduledTasksStore.getTask(task.id);
+        expect(updatedTask?.lastError).toBe("model unavailable");
+        expect(updatedTask?.lastRunAt).not.toBeNull();
+    });
+
+    it("does nothing for an unknown task id", async () => {
+        const runPrompt = vi.fn(async () => "unused");
+        scheduler.init(runPrompt);
+        await scheduler.runTask("nonexistent");
+        expect(runPrompt).not.toHaveBeenCalled();
+    });
+
+    it("records an error for a malformed model reference instead of throwing", async () => {
+        const session = sessionsStore.createSession("bad-model-ref");
+        const task = scheduledTasksStore.createTask({
+            name: "Bad model",
+            prompt: "p",
+            model: "no-colon-here",
+            targetSessionId: session.id,
+            intervalMinutes: 30,
+        });
+        scheduler.init(async () => "unused");
+        await scheduler.runTask(task.id);
+        expect(scheduledTasksStore.getTask(task.id)?.lastError).toMatch(/Invalid model reference/);
+    });
+});