diff --git a/apps/code/src/renderer/api/posthogClient.test.ts b/apps/code/src/renderer/api/posthogClient.test.ts
index f684aa266..7e5b01bac 100644
--- a/apps/code/src/renderer/api/posthogClient.test.ts
+++ b/apps/code/src/renderer/api/posthogClient.test.ts
@@ -385,4 +385,108 @@ describe("PostHogAPIClient", () => {
       expect(result.length).toBe(50);
     });
   });
+
+  describe("Task automations", () => {
+    function buildAutomationClient() {
+      const client = new PostHogAPIClient(
+        "http://localhost:8000",
+        async () => "token",
+        async () => "token",
+        123,
+      );
+      const api = {
+        get: vi.fn(),
+        post: vi.fn(),
+        patch: vi.fn(),
+        delete: vi.fn(),
+      };
+      (client as unknown as { api: typeof api }).api = api;
+      return { client, api };
+    }
+
+    it("listTaskAutomations returns the paginated results array", async () => {
+      const { client, api } = buildAutomationClient();
+      api.get.mockResolvedValue({ results: [{ id: "a" }, { id: "b" }] });
+      const result = await client.listTaskAutomations();
+      expect(api.get).toHaveBeenCalledWith(
+        "/api/projects/{project_id}/task_automations/",
+        expect.objectContaining({
+          path: { project_id: "123" },
+          query: {},
+        }),
+      );
+      expect(result).toEqual([{ id: "a" }, { id: "b" }]);
+    });
+
+    it("listTaskAutomations handles a missing results field", async () => {
+      const { client, api } = buildAutomationClient();
+      api.get.mockResolvedValue({});
+      expect(await client.listTaskAutomations()).toEqual([]);
+    });
+
+    it("createTaskAutomation POSTs the input body to the team-scoped path", async () => {
+      const { client, api } = buildAutomationClient();
+      api.post.mockResolvedValue({ id: "new" });
+      const result = await client.createTaskAutomation({
+        name: "Daily audit",
+        prompt: "Audit my flags",
+        cron_expression: "0 9 * * *",
+        repository: "",
+        timezone: "America/New_York",
+        enabled: true,
+      });
+      expect(api.post).toHaveBeenCalledWith(
+        "/api/projects/{project_id}/task_automations/",
+        expect.objectContaining({
+          path: { project_id: "123" },
+          body: expect.objectContaining({
+            name: "Daily audit",
+            prompt: "Audit my flags",
+            cron_expression: "0 9 * * *",
+            repository: "",
+            timezone: "America/New_York",
+            enabled: true,
+          }),
+        }),
+      );
+      expect(result).toEqual({ id: "new" });
+    });
+
+    it("updateTaskAutomation PATCHes the team-and-id-scoped path", async () => {
+      const { client, api } = buildAutomationClient();
+      api.patch.mockResolvedValue({ id: "abc" });
+      await client.updateTaskAutomation("abc", { enabled: false });
+      expect(api.patch).toHaveBeenCalledWith(
+        "/api/projects/{project_id}/task_automations/{id}/",
+        expect.objectContaining({
+          path: { project_id: "123", id: "abc" },
+          body: { enabled: false },
+        }),
+      );
+    });
+
+    it("deleteTaskAutomation DELETEs the team-and-id-scoped path", async () => {
+      const { client, api } = buildAutomationClient();
+      api.delete.mockResolvedValue(undefined);
+      await client.deleteTaskAutomation("abc");
+      expect(api.delete).toHaveBeenCalledWith(
+        "/api/projects/{project_id}/task_automations/{id}/",
+        expect.objectContaining({
+          path: { project_id: "123", id: "abc" },
+        }),
+      );
+    });
+
+    it("runTaskAutomationNow POSTs to the /run/ endpoint", async () => {
+      const { client, api } = buildAutomationClient();
+      api.post.mockResolvedValue({ id: "abc" });
+      await client.runTaskAutomationNow("abc");
+      expect(api.post).toHaveBeenCalledWith(
+        "/api/projects/{project_id}/task_automations/{id}/run/",
+        expect.objectContaining({
+          path: { project_id: "123", id: "abc" },
+        }),
+      );
+    });
+  });
 });
diff --git a/apps/code/src/renderer/api/posthogClient.ts b/apps/code/src/renderer/api/posthogClient.ts
index 011494253..cfafe08b4 100644
--- a/apps/code/src/renderer/api/posthogClient.ts
+++ b/apps/code/src/renderer/api/posthogClient.ts
@@ -1013,6 +1013,77 @@ export class PostHogAPIClient {
     });
   }
 
+  async listTaskAutomations(): Promise<Schemas.TaskAutomation[]> {
+    const teamId = await this.getTeamId();
+    const data = await this.api.get(
+      `/api/projects/{project_id}/task_automations/`,
+      {
+        path: { project_id: teamId.toString() },
+        query: {},
+      },
+    );
+    return data.results ?? [];
+  }
+
+  async createTaskAutomation(
+    input: Pick<
+      Schemas.TaskAutomation,
+      "name" | "prompt" | "cron_expression" | "repository"
+    > &
+      Partial<
+        Pick<
+          Schemas.TaskAutomation,
+          "github_integration" | "timezone" | "template_id" | "enabled"
+        >
+      >,
+  ): Promise<Schemas.TaskAutomation> {
+    const teamId = await this.getTeamId();
+    const data = await this.api.post(
+      `/api/projects/{project_id}/task_automations/`,
+      {
+        path: { project_id: teamId.toString() },
+        body: input as unknown as Schemas.TaskAutomation,
+      },
+    );
+    return data;
+  }
+
+  async updateTaskAutomation(
+    automationId: string,
+    updates: Schemas.PatchedTaskAutomation,
+  ): Promise<Schemas.TaskAutomation> {
+    const teamId = await this.getTeamId();
+    const data = await this.api.patch(
+      `/api/projects/{project_id}/task_automations/{id}/`,
+      {
+        path: { project_id: teamId.toString(), id: automationId },
+        body: updates,
+      },
+    );
+    return data;
+  }
+
+  async deleteTaskAutomation(automationId: string): Promise<void> {
+    const teamId = await this.getTeamId();
+    await this.api.delete(`/api/projects/{project_id}/task_automations/{id}/`, {
+      path: { project_id: teamId.toString(), id: automationId },
+    });
+  }
+
+  async runTaskAutomationNow(
+    automationId: string,
+  ): Promise<Schemas.TaskAutomation> {
+    const teamId = await this.getTeamId();
+    const data = await this.api.post(
+      `/api/projects/{project_id}/task_automations/{id}/run/`,
+      {
+        path: { project_id: teamId.toString(), id: automationId },
+        body: {} as unknown as Schemas.TaskAutomation,
+      },
+    );
+    return data;
+  }
+
   async sendRunCommand(
     taskId: string,
     runId: string,
diff --git a/apps/code/src/renderer/features/work/components/EmptyState.tsx b/apps/code/src/renderer/features/work/components/EmptyState.tsx
new file mode 100644
index 000000000..532c01c30
--- /dev/null
+++ b/apps/code/src/renderer/features/work/components/EmptyState.tsx
@@ -0,0 +1,77 @@
+import { ClockCounterClockwise, Plus } from "@phosphor-icons/react";
+import { Box, Button, Flex, Text } from "@radix-ui/themes";
+import { EXAMPLE_PROMPTS } from "../data/examplePrompts";
+import type { PendingCreateDraft } from "../stores/workStore";
+
+interface EmptyStateProps {
+  onCreate: (initial?: PendingCreateDraft) => void;
+}
+
+export function EmptyState({ onCreate }: EmptyStateProps) {
+  return (
+    <Flex
+      align="center"
+      justify="center"
+      direction="column"
+      gap="5"
+      className="py-12"
+    >
+      <Box className="rounded-(--radius-3) border border-(--gray-6) border-dashed p-5">
+        <ClockCounterClockwise size={28} className="text-(--gray-8)" />
+      </Box>
+      <Flex direction="column" align="center" gap="2" className="max-w-md">
+        <Text size="3" weight="medium" className="text-(--gray-12)">
+          No scheduled tasks yet
+        </Text>
+        <Text size="2" align="center" className="text-(--gray-11)">
+          Set up a task that runs on its own schedule — describe what you want
+          done in plain English and pick how often.
+        </Text>
+      </Flex>
+
+      <Flex direction="column" gap="2" className="w-full max-w-md">
+        <Text
+          size="1"
+          weight="medium"
+          className="text-(--gray-10) uppercase tracking-wider"
+        >
+          Start from an example
+        </Text>
+        {EXAMPLE_PROMPTS.map((example) => {
+          const Icon = example.icon;
+          return (
+            <button
+              key={example.id}
+              type="button"
+              onClick={() =>
+                onCreate({ name: example.name, prompt: example.prompt })
+              }
+              className="flex w-full cursor-pointer items-start gap-3 rounded-(--radius-2) border border-(--gray-5) bg-(--gray-2) px-3 py-3 text-left transition-colors hover:bg-(--gray-3)"
+            >
+              <Box className="mt-[2px] shrink-0 text-(--accent-10)">
+                <Icon size={16} weight="duotone" />
+              </Box>
+              <Flex direction="column" gap="1" className="min-w-0">
+                <Text
+                  size="2"
+                  weight="medium"
+                  className="truncate text-(--gray-12)"
+                >
+                  {example.name}
+                </Text>
+                <Text size="1" className="text-(--gray-11)">
+                  {example.description}
+                </Text>
+              </Flex>
+            </button>
+          );
+        })}
+      </Flex>
+
+      <Button size="2" variant="soft" onClick={() => onCreate()}>
+        <Plus size={14} />
+        Start from scratch
+      </Button>
+    </Flex>
+  );
+}
diff --git a/apps/code/src/renderer/features/work/components/ScheduleField.tsx b/apps/code/src/renderer/features/work/components/ScheduleField.tsx
new file mode 100644
index 000000000..0d743d71e
--- /dev/null
+++ b/apps/code/src/renderer/features/work/components/ScheduleField.tsx
@@ -0,0 +1,83 @@
+import { Check, WarningCircle } from "@phosphor-icons/react";
+import { Flex, Text, TextField } from "@radix-ui/themes";
+import { parseSchedule } from "../utils/parseSchedule";
+
+interface ScheduleFieldProps {
+  value: string;
+  onChange: (next: string) => void;
+}
+
+const QUICK_FILLS = [
+  "Daily at 9am",
+  "Weekdays at 9am",
+  "Mondays at 9am",
+  "Every hour",
+  "1st of month at 9am",
+];
+
+export function ScheduleField({ value, onChange }: ScheduleFieldProps) {
+  const trimmed = value.trim();
+  const parsed = trimmed ? parseSchedule(trimmed) : null;
+  const hasValue = trimmed.length > 0;
+  const isValid = parsed !== null;
+
+  return (
+    <Flex direction="column" gap="2">
+      <Text size="1" weight="medium" className="text-(--gray-11)">
+        Schedule
+      </Text>
+
+      <TextField.Root
+        size="2"
+        placeholder="e.g. every Tuesday at 5pm"
+        value={value}
+        onChange={(e) => onChange(e.target.value)}
+      />
+
+      {hasValue && isValid && (
+        <Flex align="center" gap="2" className="text-(--green-11)">
+          <Check size={12} />
+          <Text size="1">→ {parsed.description}</Text>
+        </Flex>
+      )}
+      {hasValue && !isValid && (
+        <Flex align="center" gap="2" className="text-(--amber-11)">
+          <WarningCircle size={12} />
+          <Text size="1">
+            Couldn't understand that — try "every Tuesday at 5pm", "daily at
+            9am", "weekdays at 9am", or a cron expression.
+          </Text>
+        </Flex>
+      )}
+
+      <Flex direction="column" gap="1" className="pt-1">
+        <Text
+          size="1"
+          weight="medium"
+          className="text-(--gray-10) uppercase tracking-wider"
+        >
+          Quick fills
+        </Text>
+        <Flex gap="1" wrap="wrap">
+          {QUICK_FILLS.map((label) => {
+            const isActive = trimmed.toLowerCase() === label.toLowerCase();
+            return (
+              <button
+                key={label}
+                type="button"
+                onClick={() => onChange(label)}
+                className={`cursor-pointer rounded-full border px-3 py-1 text-[12px] transition-colors ${
+                  isActive
+                    ? "border-(--accent-7) bg-(--accent-3) text-(--gray-12)"
+                    : "border-(--gray-5) bg-(--gray-2) text-(--gray-11) hover:bg-(--gray-3) hover:text-(--gray-12)"
+                }`}
+              >
+                {label}
+              </button>
+            );
+          })}
+        </Flex>
+      </Flex>
+    </Flex>
+  );
+}
diff --git a/apps/code/src/renderer/features/work/components/ScheduledTaskEditor.tsx b/apps/code/src/renderer/features/work/components/ScheduledTaskEditor.tsx
new file mode 100644
index 000000000..7877f6037
--- /dev/null
+++ b/apps/code/src/renderer/features/work/components/ScheduledTaskEditor.tsx
@@ -0,0 +1,402 @@
+import { useSetHeaderContent } from "@hooks/useSetHeaderContent";
+import {
+  ArrowLeft,
+  ArrowSquareOut,
+  ClockCounterClockwise,
+  FloppyDisk,
+  Play,
+  Trash,
+} from "@phosphor-icons/react";
+import {
+  Box,
+  Button,
+  Callout,
+  Flex,
+  ScrollArea,
+  Switch,
+  Text,
+  TextArea,
+  TextField,
+} from "@radix-ui/themes";
+import type { Schemas } from "@renderer/api/generated";
+import { useNavigationStore } from "@stores/navigationStore";
+import { formatRelativeTimeLong } from "@utils/time";
+import { useEffect, useMemo, useState } from "react";
+import { toast } from "sonner";
+import { useOpenLastRun } from "../hooks/useOpenLastRun";
+import {
+  useCreateScheduledTask,
+  useDeleteScheduledTask,
+  useRunScheduledTaskNow,
+  useScheduledTasks,
+  useUpdateScheduledTask,
+} from "../hooks/useScheduledTasks";
+import { useWorkStore } from "../stores/workStore";
+import { describeCron, parseSchedule } from "../utils/parseSchedule";
+import { decodePrompt, encodePrompt } from "../utils/sourcesPrompt";
+import { detectTimezone } from "../utils/timezone";
+import { ScheduledTaskStatusBadge } from "./ScheduledTaskStatusBadge";
+import { ScheduleField } from "./ScheduleField";
+import { SourcesPicker } from "./SourcesPicker";
+
+interface ScheduledTaskEditorProps {
+  editingId: string | null;
+}
+
+interface Draft {
+  name: string;
+  promptBody: string;
+  sources: string[];
+  scheduleText: string;
+  enabled: boolean;
+}
+
+function toDraft(automation: Schemas.TaskAutomation | null): Draft {
+  if (!automation) {
+    return {
+      name: "",
+      promptBody: "",
+      sources: [],
+      scheduleText: "Daily at 9am",
+      enabled: true,
+    };
+  }
+  const { sources, body } = decodePrompt(automation.prompt);
+  return {
+    name: automation.name,
+    promptBody: body,
+    sources,
+    scheduleText: describeCron(automation.cron_expression),
+    enabled: automation.enabled ?? true,
+  };
+}
+
+export function ScheduledTaskEditor({ editingId }: ScheduledTaskEditorProps) {
+  const showList = useNavigationStore((s) => s.navigateToWorkScheduledList);
+  const consumePendingCreateDraft = useWorkStore(
+    (s) => s.consumePendingCreateDraft,
+  );
+  const { data: automations } = useScheduledTasks();
+
+  const existing = useMemo(
+    () => automations?.find((a) => a.id === editingId) ?? null,
+    [automations, editingId],
+  );
+
+  const [draft, setDraft] = useState<Draft>(() => {
+    const base = toDraft(existing);
+    if (!existing) {
+      const seeded = consumePendingCreateDraft();
+      if (seeded) {
+        return {
+          ...base,
+          name: seeded.name ?? base.name,
+          promptBody: seeded.prompt ?? base.promptBody,
+        };
+      }
+    }
+    return base;
+  });
+
+  // Sync the draft when the editor is pointed at a different existing automation.
+  useEffect(() => {
+    if (existing) setDraft(toDraft(existing));
+    // The id is what should trigger a reset — other field changes from polling
+    // shouldn't clobber user edits.
+  }, [existing?.id, existing]);
+
+  const createScheduledTask = useCreateScheduledTask();
+  const updateScheduledTask = useUpdateScheduledTask();
+  const deleteScheduledTask = useDeleteScheduledTask();
+  const runScheduledTaskNow = useRunScheduledTaskNow();
+  const { openLastRun, isOpening } = useOpenLastRun();
+
+  const isEditing = editingId !== null && existing !== null;
+  const isSaving =
+    createScheduledTask.isPending || updateScheduledTask.isPending;
+
+  const nameTrimmed = draft.name.trim();
+  const promptTrimmed = draft.promptBody.trim();
+  const parsedSchedule = parseSchedule(draft.scheduleText);
+  const missingFields = !nameTrimmed || !promptTrimmed || !parsedSchedule;
+  const canSave = !missingFields && !isSaving;
+
+  const headerContent = useMemo(
+    () => (
+      <Flex align="center" gap="2" className="min-w-0">
+        <ClockCounterClockwise
+          size={12}
+          className="shrink-0 text-(--gray-10)"
+        />
+        <Text
+          size="1"
+          weight="medium"
+          className="truncate font-mono text-[12px]"
+        >
+          {isEditing ? existing.name || "Scheduled task" : "New scheduled task"}
+        </Text>
+      </Flex>
+    ),
+    [isEditing, existing],
+  );
+  useSetHeaderContent(headerContent);
+
+  const handleSave = async () => {
+    if (!canSave || !parsedSchedule) return;
+    const promptToSend = encodePrompt(promptTrimmed, draft.sources);
+
+    try {
+      if (isEditing) {
+        await updateScheduledTask.mutateAsync({
+          id: existing.id,
+          updates: {
+            name: nameTrimmed,
+            prompt: promptToSend,
+            cron_expression: parsedSchedule.cron,
+            enabled: draft.enabled,
+          },
+        });
+        toast.success("Scheduled task updated");
+      } else {
+        await createScheduledTask.mutateAsync({
+          name: nameTrimmed,
+          prompt: promptToSend,
+          cron_expression: parsedSchedule.cron,
+          // Work-mode tasks aren't repo-scoped, but the backend currently
+          // requires a non-blank `repository`. Send a sentinel until the
+          // backend makes the field nullable; the runtime ignores it for
+          // PostHog-data skills.
+          repository: "posthog-work",
+          timezone: detectTimezone(),
+          enabled: draft.enabled,
+        });
+        toast.success("Scheduled task created");
+      }
+      showList();
+    } catch (error) {
+      toast.error(
+        error instanceof Error
+          ? error.message
+          : "Failed to save scheduled task",
+      );
+    }
+  };
+
+  const handleDelete = async () => {
+    if (!isEditing) return;
+    if (
+      !window.confirm(
+        `Delete "${existing.name || "this scheduled task"}"? This cannot be undone.`,
+      )
+    ) {
+      return;
+    }
+    try {
+      await deleteScheduledTask.mutateAsync(existing.id);
+      toast.success("Scheduled task deleted");
+      showList();
+    } catch (error) {
+      toast.error(
+        error instanceof Error
+          ? error.message
+          : "Failed to delete scheduled task",
+      );
+    }
+  };
+
+  const handleRunNow = async () => {
+    if (!isEditing) return;
+    try {
+      await runScheduledTaskNow.mutateAsync(existing.id);
+      toast.success("Running now — opening the task to follow along");
+      // After the run is triggered the automation row gets new last_task_id /
+      // last_task_run_id values on the next refetch. We don't deep-link
+      // immediately because the task may take a moment to appear in cache.
+    } catch (error) {
+      toast.error(
+        error instanceof Error ? error.message : "Failed to run scheduled task",
+      );
+    }
+  };
+
+  return (
+    <Flex direction="column" height="100%" className="overflow-hidden">
+      <Flex
+        align="center"
+        justify="between"
+        px="4"
+        py="3"
+        className="shrink-0 border-(--gray-6) border-b"
+      >
+        <Flex align="center" gap="2">
+          <Button size="1" variant="ghost" onClick={showList}>
+            <ArrowLeft size={14} />
+            Back
+          </Button>
+          <Text size="3" weight="medium" className="text-(--gray-12)">
+            {isEditing ? "Edit scheduled task" : "New scheduled task"}
+          </Text>
+        </Flex>
+        <Flex align="center" gap="2">
+          {isEditing && (
+            <>
+              <Button
+                size="2"
+                variant="soft"
+                color="gray"
+                onClick={handleRunNow}
+                loading={runScheduledTaskNow.isPending}
+              >
+                <Play size={14} />
+                Run now
+              </Button>
+              <Button
+                size="2"
+                variant="soft"
+                color="red"
+                onClick={handleDelete}
+                loading={deleteScheduledTask.isPending}
+              >
+                <Trash size={14} />
+                Delete
+              </Button>
+            </>
+          )}
+          <Button
+            size="2"
+            onClick={handleSave}
+            disabled={!canSave}
+            loading={isSaving}
+          >
+            <FloppyDisk size={14} />
+            Save
+          </Button>
+        </Flex>
+      </Flex>
+
+      <ScrollArea type="auto" className="min-h-0 flex-1">
+        <Box px="4" py="4" className="mx-auto max-w-2xl">
+          <Flex direction="column" gap="4">
+            <Flex direction="column" gap="2">
+              <Text size="1" weight="medium" className="text-(--gray-11)">
+                Name
+              </Text>
+              <TextField.Root
+                size="2"
+                placeholder="e.g. Audit feature flags weekly"
+                value={draft.name}
+                onChange={(e) =>
+                  setDraft((d) => ({ ...d, name: e.target.value }))
+                }
+              />
+            </Flex>
+
+            <Flex direction="column" gap="2">
+              <Text size="1" weight="medium" className="text-(--gray-11)">
+                What should it do?
+              </Text>
+              <TextArea
+                size="2"
+                placeholder="Describe what you want done in plain English."
+                value={draft.promptBody}
+                onChange={(e) =>
+                  setDraft((d) => ({ ...d, promptBody: e.target.value }))
+                }
+                rows={6}
+                className="resize-y"
+              />
+              <Text size="1" className="text-(--gray-10)">
+                The agent picks the right skill from your request when the task
+                runs — no need to specify one.
+              </Text>
+            </Flex>
+
+            <ScheduleField
+              value={draft.scheduleText}
+              onChange={(scheduleText) =>
+                setDraft((d) => ({ ...d, scheduleText }))
+              }
+            />
+
+            <SourcesPicker
+              value={draft.sources}
+              onChange={(sources) => setDraft((d) => ({ ...d, sources }))}
+            />
+
+            {isEditing && (
+              <Flex
+                align="center"
+                justify="between"
+                className="rounded-(--radius-2) border border-(--gray-5) bg-(--gray-2) px-3 py-2"
+              >
+                <Flex direction="column" gap="1">
+                  <Text size="2" weight="medium" className="text-(--gray-12)">
+                    Enabled
+                  </Text>
+                  <Text size="1" className="text-(--gray-10)">
+                    When off, the task won't run on its schedule.
+                  </Text>
+                </Flex>
+                <Switch
+                  checked={draft.enabled}
+                  onCheckedChange={(enabled) =>
+                    setDraft((d) => ({ ...d, enabled }))
+                  }
+                />
+              </Flex>
+            )}
+
+            {isEditing && existing.last_run_at && (
+              <Flex
+                direction="column"
+                gap="2"
+                className="rounded-(--radius-2) border border-(--gray-5) bg-(--gray-2) px-3 py-3"
+              >
+                <Flex align="center" justify="between" gap="3">
+                  <Flex direction="column" gap="1" className="min-w-0">
+                    <Text size="1" weight="medium" className="text-(--gray-11)">
+                      Last run
+                    </Text>
+                    <Flex align="center" gap="2">
+                      <ScheduledTaskStatusBadge automation={existing} />
+                      <Text size="2" className="truncate text-(--gray-12)">
+                        {formatRelativeTimeLong(existing.last_run_at)}
+                      </Text>
+                    </Flex>
+                  </Flex>
+                  {existing.last_task_id && (
+                    <Button
+                      size="2"
+                      variant="soft"
+                      onClick={() =>
+                        openLastRun(
+                          existing.last_task_id ?? "",
+                          existing.last_task_run_id,
+                        )
+                      }
+                      loading={isOpening}
+                    >
+                      <ArrowSquareOut size={14} />
+                      Open task
+                    </Button>
+                  )}
+                </Flex>
+                {existing.last_error && (
+                  <Callout.Root size="1" color="red" variant="soft">
+                    <Callout.Text>{existing.last_error}</Callout.Text>
+                  </Callout.Root>
+                )}
+              </Flex>
+            )}
+
+            {missingFields && (
+              <Text size="1" className="text-(--gray-10)">
+                Add a name, a prompt, and a schedule to save.
+              </Text>
+            )}
+          </Flex>
+        </Box>
+      </ScrollArea>
+    </Flex>
+  );
+}
diff --git a/apps/code/src/renderer/features/work/components/ScheduledTaskRow.tsx b/apps/code/src/renderer/features/work/components/ScheduledTaskRow.tsx
new file mode 100644
index 000000000..48948d377
--- /dev/null
+++ b/apps/code/src/renderer/features/work/components/ScheduledTaskRow.tsx
@@ -0,0 +1,73 @@
+import { CaretRight } from "@phosphor-icons/react";
+import { Flex, Text } from "@radix-ui/themes";
+import type { Schemas } from "@renderer/api/generated";
+import { formatRelativeTimeLong } from "@utils/time";
+import {
+  labelForCron,
+  nextRunForPreset,
+  presetForCron,
+} from "../utils/schedulePresets";
+import { ScheduledTaskStatusBadge } from "./ScheduledTaskStatusBadge";
+
+interface ScheduledTaskRowProps {
+  automation: Schemas.TaskAutomation;
+  onClick: () => void;
+}
+
+function formatNextRun(automation: Schemas.TaskAutomation): string | null {
+  if (automation.enabled === false) return null;
+  const preset = presetForCron(automation.cron_expression);
+  if (!preset) return null;
+  const next = nextRunForPreset(preset.id);
+  return next.toLocaleString(undefined, {
+    weekday: "short",
+    hour: "numeric",
+    minute: "2-digit",
+  });
+}
+
+export function ScheduledTaskRow({
+  automation,
+  onClick,
+}: ScheduledTaskRowProps) {
+  const nextRunText = formatNextRun(automation);
+
+  return (
+    <button
+      type="button"
+      onClick={onClick}
+      className="w-full cursor-pointer rounded-(--radius-2) border border-(--gray-5) bg-(--gray-2) px-3 py-3 text-left transition-colors hover:bg-(--gray-3)"
+    >
+      <Flex align="center" gap="3" className="min-w-0">
+        <Flex direction="column" gap="1" className="min-w-0 flex-1">
+          <Flex align="center" gap="2" className="min-w-0">
+            <Text
+              size="2"
+              weight="medium"
+              className="truncate text-(--gray-12)"
+            >
+              {automation.name || "Untitled scheduled task"}
+            </Text>
+            <ScheduledTaskStatusBadge automation={automation} />
+          </Flex>
+          <Flex align="center" gap="3" wrap="wrap" className="min-w-0">
+            <Text size="1" className="text-(--gray-11)">
+              {labelForCron(automation.cron_expression)}
+            </Text>
+            {nextRunText && (
+              <Text size="1" className="text-(--gray-10)">
+                · Next {nextRunText}
+              </Text>
+            )}
+            {automation.last_run_at && (
+              <Text size="1" className="text-(--gray-10)">
+                · Last ran {formatRelativeTimeLong(automation.last_run_at)}
+              </Text>
+            )}
+          </Flex>
+        </Flex>
+        <CaretRight size={14} className="shrink-0 text-(--gray-9)" />
+      </Flex>
+    </button>
+  );
+}
diff --git a/apps/code/src/renderer/features/work/components/ScheduledTaskStatusBadge.tsx b/apps/code/src/renderer/features/work/components/ScheduledTaskStatusBadge.tsx
new file mode 100644
index 000000000..8ba415448
--- /dev/null
+++ b/apps/code/src/renderer/features/work/components/ScheduledTaskStatusBadge.tsx
@@ -0,0 +1,53 @@
+import { Badge } from "@radix-ui/themes";
+import type { Schemas } from "@renderer/api/generated";
+
+interface ScheduledTaskStatusBadgeProps {
+  automation: Schemas.TaskAutomation;
+}
+
+export function ScheduledTaskStatusBadge({
+  automation,
+}: ScheduledTaskStatusBadgeProps) {
+  if (automation.enabled === false) {
+    return (
+      <Badge size="1" variant="soft" color="gray">
+        Paused
+      </Badge>
+    );
+  }
+
+  switch (automation.last_run_status) {
+    case "failed":
+      return (
+        <Badge size="1" variant="soft" color="red">
+          Failed
+        </Badge>
+      );
+    case "success":
+    case "completed":
+      return (
+        <Badge size="1" variant="soft" color="green">
+          Healthy
+        </Badge>
+      );
+    case "running":
+    case "in_progress":
+      return (
+        <Badge size="1" variant="soft" color="blue">
+          Running
+        </Badge>
+      );
+    case "cancelled":
+      return (
+        <Badge size="1" variant="soft" color="gray">
+          Cancelled
+        </Badge>
+      );
+    default:
+      return (
+        <Badge size="1" variant="soft" color="blue">
+          Active
+        </Badge>
+      );
+  }
+}
diff --git a/apps/code/src/renderer/features/work/components/ScheduledTasksList.tsx b/apps/code/src/renderer/features/work/components/ScheduledTasksList.tsx
new file mode 100644
index 000000000..744b92d26
--- /dev/null
+++ b/apps/code/src/renderer/features/work/components/ScheduledTasksList.tsx
@@ -0,0 +1,96 @@
+import { useSetHeaderContent } from "@hooks/useSetHeaderContent";
+import { ClockCounterClockwise, Plus } from "@phosphor-icons/react";
+import { Box, Button, Flex, ScrollArea, Spinner, Text } from "@radix-ui/themes";
+import { useNavigationStore } from "@stores/navigationStore";
+import { useMemo } from "react";
+import { useScheduledTasks } from "../hooks/useScheduledTasks";
+import { type PendingCreateDraft, useWorkStore } from "../stores/workStore";
+import { EmptyState } from "./EmptyState";
+import { ScheduledTaskRow } from "./ScheduledTaskRow";
+
+export function ScheduledTasksList() {
+  const navigateToCreate = useNavigationStore(
+    (s) => s.navigateToWorkScheduledCreate,
+  );
+  const navigateToEdit = useNavigationStore(
+    (s) => s.navigateToWorkScheduledEdit,
+  );
+  const setPendingCreateDraft = useWorkStore((s) => s.setPendingCreateDraft);
+  const { data: automations, isLoading } = useScheduledTasks();
+
+  const handleCreate = (initial?: PendingCreateDraft) => {
+    setPendingCreateDraft(initial ?? null);
+    navigateToCreate();
+  };
+
+  const items = automations ?? [];
+
+  const headerContent = useMemo(
+    () => (
+      <Flex align="center" gap="2" className="min-w-0">
+        <ClockCounterClockwise
+          size={12}
+          className="shrink-0 text-(--gray-10)"
+        />
+        <Text
+          size="1"
+          weight="medium"
+          className="truncate font-mono text-[12px]"
+        >
+          Scheduled tasks
+        </Text>
+      </Flex>
+    ),
+    [],
+  );
+  useSetHeaderContent(headerContent);
+
+  return (
+    <Flex direction="column" height="100%" className="overflow-hidden">
+      <Flex
+        align="center"
+        justify="between"
+        px="4"
+        py="3"
+        className="shrink-0 border-(--gray-6) border-b"
+      >
+        <Flex direction="column" gap="1">
+          <Text size="3" weight="medium" className="text-(--gray-12)">
+            Scheduled tasks
+          </Text>
+          <Text size="1" className="text-(--gray-10)">
+            {items.length === 0
+              ? "Nothing scheduled yet"
+              : `${items.length} scheduled task${items.length === 1 ? "" : "s"}`}
+          </Text>
+        </Flex>
+        <Button size="2" onClick={() => handleCreate()}>
+          <Plus size={14} />
+          New
+        </Button>
+      </Flex>
+
+      <ScrollArea type="auto" className="min-h-0 flex-1">
+        <Box px="4" py="3">
+          {isLoading && items.length === 0 ? (
+            <Flex align="center" justify="center" className="py-16">
+              <Spinner size="3" />
+            </Flex>
+          ) : items.length === 0 ? (
+            <EmptyState onCreate={handleCreate} />
+          ) : (
+            <Flex direction="column" gap="2">
+              {items.map((automation) => (
+                <ScheduledTaskRow
+                  key={automation.id}
+                  automation={automation}
+                  onClick={() => navigateToEdit(automation.id)}
+                />
+              ))}
+            </Flex>
+          )}
+        </Box>
+      </ScrollArea>
+    </Flex>
+  );
+}
diff --git a/apps/code/src/renderer/features/work/components/SourcesPicker.tsx b/apps/code/src/renderer/features/work/components/SourcesPicker.tsx
new file mode 100644
index 000000000..b2ab5debc
--- /dev/null
+++ b/apps/code/src/renderer/features/work/components/SourcesPicker.tsx
@@ -0,0 +1,94 @@
+import { ServerIcon } from "@features/mcp-servers/components/parts/icons";
+import { useMcpServers } from "@features/mcp-servers/hooks/useMcpServers";
+import { Check } from "@phosphor-icons/react";
+import { Box, Flex, Text } from "@radix-ui/themes";
+import { useMemo } from "react";
+
+interface SourcesPickerProps {
+  /** MCP template ids the user has selected. */
+  value: string[];
+  onChange: (next: string[]) => void;
+}
+
+interface SourceOption {
+  id: string;
+  label: string;
+  iconKey: string | null | undefined;
+}
+
+export function SourcesPicker({ value, onChange }: SourcesPickerProps) {
+  const { servers, installedTemplateIds } = useMcpServers();
+
+  const options = useMemo<SourceOption[]>(() => {
+    if (!servers) return [];
+    // Prefer the servers the user has installed; if they have none, fall back
+    // to the full recommended catalogue so the picker isn't empty.
+    const haveInstalled = installedTemplateIds.size > 0;
+    return servers
+      .filter((s) => (haveInstalled ? installedTemplateIds.has(s.id) : true))
+      .map((s) => ({ id: s.id, label: s.name, iconKey: s.icon_key }))
+      .slice(0, 24);
+  }, [servers, installedTemplateIds]);
+
+  const selected = useMemo(() => new Set(value), [value]);
+
+  const toggle = (id: string) => {
+    if (selected.has(id)) {
+      onChange(value.filter((v) => v !== id));
+    } else {
+      onChange([...value, id]);
+    }
+  };
+
+  if (options.length === 0) {
+    return (
+      <Flex direction="column" gap="2">
+        <Text size="1" weight="medium" className="text-(--gray-11)">
+          Data sources
+        </Text>
+        <Text size="1" className="text-(--gray-10)">
+          No data sources connected. The task will run with whatever tools the
+          agent has by default.
+        </Text>
+      </Flex>
+    );
+  }
+
+  return (
+    <Flex direction="column" gap="2">
+      <Flex direction="column" gap="1">
+        <Text size="1" weight="medium" className="text-(--gray-11)">
+          Data sources
+        </Text>
+        <Text size="1" className="text-(--gray-10)">
+          Pick which connected tools the agent should reach for. If none are
+          picked, the agent decides.
+        </Text>
+      </Flex>
+
+      <Flex gap="2" wrap="wrap">
+        {options.map((option) => {
+          const isSelected = selected.has(option.id);
+          return (
+            <button
+              key={option.id}
+              type="button"
+              onClick={() => toggle(option.id)}
+              className={`flex cursor-pointer items-center gap-2 rounded-full border px-3 py-1 text-[12px] transition-colors ${
+                isSelected
+                  ? "border-(--accent-7) bg-(--accent-3) text-(--gray-12)"
+                  : "border-(--gray-5) bg-(--gray-2) text-(--gray-11) hover:bg-(--gray-3) hover:text-(--gray-12)"
+              }`}
+            >
+              <Box className="shrink-0">
+                <ServerIcon iconKey={option.iconKey} size={14} />
+              </Box>
+              <Text size="1">{option.label}</Text>
+              {isSelected && <Check size={12} />}
+            </button>
+          );
+        })}
+      </Flex>
+    </Flex>
+  );
+}
diff --git a/apps/code/src/renderer/features/work/components/WorkHome.tsx b/apps/code/src/renderer/features/work/components/WorkHome.tsx
new file mode 100644
index 000000000..4dfe56662
--- /dev/null
+++ b/apps/code/src/renderer/features/work/components/WorkHome.tsx
@@ -0,0 +1,54 @@
+import { Box, Flex, Text } from "@radix-ui/themes";
+import beachHog from "@renderer/assets/images/hedgehogs/beach-hog.png";
+import { WorkHomePrompt } from "./WorkHomePrompt";
+import { WorkSampleProjects } from "./WorkSampleProjects";
+
+export function WorkHome() {
+  return (
+    <Box className="scrollbar-overlay-y h-full w-full overflow-y-auto">
+      <Flex
+        direction="column"
+        align="center"
+        gap="6"
+        className="mx-auto w-full max-w-[680px] px-6 pt-16 pb-12"
+      >
+        <Flex
+          direction="column"
+          align="center"
+          gap="3"
+          className="work-enter work-enter-1"
+        >
+          <img
+            src={beachHog}
+            alt=""
+            className="h-28 w-auto select-none"
+            draggable={false}
+          />
+          <Box className="text-center">
+            <Text
+              as="div"
+              weight="medium"
+              className="text-(--gray-12) text-[22px]"
+            >
+              Hello normie, what can I do for you today?
+            </Text>
+          </Box>
+        </Flex>
+
+        <Box className="work-enter work-enter-2 w-full">
+          <WorkHomePrompt />
+        </Box>
+
+        <Box className="work-enter work-enter-3 w-full">
+          <Text
+            as="div"
+            className="mb-2 text-center text-(--gray-10) text-[11px] uppercase tracking-wide"
+          >
+            Or if you're used to outsourcing your brain to Claude...
+          </Text>
+          <WorkSampleProjects />
+        </Box>
+      </Flex>
+    </Box>
+  );
+}
diff --git a/apps/code/src/renderer/features/work/components/WorkSidebarMenu.tsx b/apps/code/src/renderer/features/work/components/WorkSidebarMenu.tsx
index cbb919f57..40a677b89 100644
--- a/apps/code/src/renderer/features/work/components/WorkSidebarMenu.tsx
+++ b/apps/code/src/renderer/features/work/components/WorkSidebarMenu.tsx
@@ -12,7 +12,7 @@ import {
 } from "@phosphor-icons/react";
 import { ScrollArea } from "@posthog/quill";
 import { Box, Flex, Text } from "@radix-ui/themes";
-import { useNavigationStore } from "@stores/navigationStore";
+import { useNavigationStore, type WorkView } from "@stores/navigationStore";
 import { useWorkSkillsStore } from "@stores/workSkillsStore";
 import type { ComponentType } from "react";
 import { NewTaskItem } from "../../sidebar/components/items/HomeItem";
@@ -21,12 +21,17 @@ import { SidebarItem } from "../../sidebar/components/SidebarItem";
 interface WorkSidebarItemSpec {
   icon: ComponentType<IconProps>;
   label: string;
-  active?: boolean;
+  /** When set, the item navigates to that workView and lights up while active. */
+  workView?: WorkView | "scheduled-section";
 }
 
 const STATIC_ITEMS: WorkSidebarItemSpec[] = [
   { icon: FolderSimple, label: "Projects" },
-  { icon: ClockClockwise, label: "Automations" },
+  {
+    icon: ClockClockwise,
+    label: "Scheduled",
+    workView: "scheduled-section",
+  },
   { icon: Notebook, label: "Artifacts" },
   { icon: Plugs, label: "MCP" },
   { icon: Brain, label: "Memory" },
@@ -45,6 +50,9 @@ export function WorkSidebarMenu() {
   const navigateToWorkLibrary = useNavigationStore(
     (s) => s.navigateToWorkLibrary,
   );
+  const navigateToWorkScheduledList = useNavigationStore(
+    (s) => s.navigateToWorkScheduledList,
+  );
   const skills = useWorkSkillsStore((s) => s.skills);
 
   const handleNewTaskClick = () => {
@@ -55,6 +63,8 @@ export function WorkSidebarMenu() {
   const isHomeActive = workView === "home";
   const isGenerateActive = workView === "generate";
   const isLibraryActive = workView === "library";
+  const isScheduledActive =
+    workView === "scheduled-list" || workView === "scheduled-edit";
 
   return (
     <Box height="100%" position="relative">
@@ -82,15 +92,21 @@ export function WorkSidebarMenu() {
 
           {STATIC_ITEMS.map((item) => {
             const Icon = item.icon;
+            const isScheduled = item.workView === "scheduled-section";
+            const isActive = isScheduled && isScheduledActive;
+            const onClick = isScheduled
+              ? navigateToWorkScheduledList
+              : undefined;
             return (
               <Box key={item.label}>
                 <SidebarItem
                   depth={0}
                   icon={
-                    <Icon size={16} weight={item.active ? "fill" : "regular"} />
+                    <Icon size={16} weight={isActive ? "fill" : "regular"} />
                   }
                   label={item.label}
-                  isActive={item.active}
+                  isActive={isActive}
+                  onClick={onClick}
                 />
               </Box>
             );
diff --git a/apps/code/src/renderer/features/work/components/WorkView.tsx b/apps/code/src/renderer/features/work/components/WorkView.tsx
index 03a3835d5..4e8c5a3ea 100644
--- a/apps/code/src/renderer/features/work/components/WorkView.tsx
+++ b/apps/code/src/renderer/features/work/components/WorkView.tsx
@@ -1,6 +1,8 @@
 import { Box, Flex, Text } from "@radix-ui/themes";
 import beachHog from "@renderer/assets/images/hedgehogs/beach-hog.png";
 import { useNavigationStore } from "@stores/navigationStore";
+import { ScheduledTaskEditor } from "./ScheduledTaskEditor";
+import { ScheduledTasksList } from "./ScheduledTasksList";
 import { WorkGenerateView } from "./WorkGenerateView";
 import { WorkHomePrompt } from "./WorkHomePrompt";
 import { WorkSampleProjects } from "./WorkSampleProjects";
@@ -9,6 +11,7 @@ import { WorkSkillsView } from "./WorkSkillsView";
 
 export function WorkView() {
   const workView = useNavigationStore((s) => s.workView);
+  const scheduledEditId = useNavigationStore((s) => s.workScheduledEditId);
 
   if (workView === "generate") {
     return <WorkGenerateView />;
@@ -22,6 +25,14 @@ export function WorkView() {
     return <WorkSkillsView />;
   }
 
+  if (workView === "scheduled-list") {
+    return <ScheduledTasksList />;
+  }
+
+  if (workView === "scheduled-edit") {
+    return <ScheduledTaskEditor editingId={scheduledEditId ?? null} />;
+  }
+
   return (
     <Box className="scrollbar-overlay-y h-full w-full overflow-y-auto">
       <Flex
diff --git a/apps/code/src/renderer/features/work/data/examplePrompts.test.ts b/apps/code/src/renderer/features/work/data/examplePrompts.test.ts
new file mode 100644
index 000000000..456c58cd3
--- /dev/null
+++ b/apps/code/src/renderer/features/work/data/examplePrompts.test.ts
@@ -0,0 +1,22 @@
+import { describe, expect, it } from "vitest";
+import { EXAMPLE_PROMPTS } from "./examplePrompts";
+
+describe("EXAMPLE_PROMPTS", () => {
+  it("ships at least a handful of examples", () => {
+    expect(EXAMPLE_PROMPTS.length).toBeGreaterThanOrEqual(3);
+  });
+
+  it("has unique ids", () => {
+    const ids = EXAMPLE_PROMPTS.map((e) => e.id);
+    expect(new Set(ids).size).toBe(ids.length);
+  });
+
+  it("every entry has a name, description, non-empty prompt, and an icon", () => {
+    for (const example of EXAMPLE_PROMPTS) {
+      expect(example.name.trim()).not.toBe("");
+      expect(example.description.trim()).not.toBe("");
+      expect(example.prompt.trim().length).toBeGreaterThan(0);
+      expect(example.icon).toBeTruthy();
+    }
+  });
+});
diff --git a/apps/code/src/renderer/features/work/data/examplePrompts.ts b/apps/code/src/renderer/features/work/data/examplePrompts.ts
new file mode 100644
index 000000000..d332640c3
--- /dev/null
+++ b/apps/code/src/renderer/features/work/data/examplePrompts.ts
@@ -0,0 +1,70 @@
+import {
+  CalendarBlank,
+  ChartLineUp,
+  ChatsTeardrop,
+  PresentationChart,
+  Trophy,
+} from "@phosphor-icons/react";
+import type { ComponentType } from "react";
+
+interface IconProps {
+  size?: number | string;
+  weight?: "thin" | "light" | "regular" | "bold" | "fill" | "duotone";
+  className?: string;
+}
+
+export interface ExamplePrompt {
+  id: string;
+  name: string;
+  description: string;
+  prompt: string;
+  icon: ComponentType<IconProps>;
+}
+
+/**
+ * Curated suggestions for the empty Scheduled tab. Each entry is the kind of
+ * recurring job a non-engineer would actually want to schedule. Clicking one
+ * prefills both the name and the prompt in the editor.
+ */
+export const EXAMPLE_PROMPTS: ExamplePrompt[] = [
+  {
+    id: "competitive-analysis",
+    name: "Weekly competitive analysis",
+    description: "Track what competitors shipped and talked about",
+    prompt:
+      "Each Monday morning, scan our top competitors' marketing pages, blog posts, changelogs, and recent social posts. Summarise what they shipped, what they're emphasising, and any pricing or positioning changes. Flag anything worth a deeper look.",
+    icon: Trophy,
+  },
+  {
+    id: "daily-briefing",
+    name: "Daily meeting briefing",
+    description: "Prep notes for the day's calendar based on context",
+    prompt:
+      "Every weekday morning at 8am, look at my calendar for the day. For each meeting, pull together a short briefing: who's attending, what we discussed last time, any decisions still outstanding, and one or two suggested talking points.",
+    icon: CalendarBlank,
+  },
+  {
+    id: "customer-feedback-digest",
+    name: "Customer feedback digest",
+    description: "Weekly themes from support, interviews, and surveys",
+    prompt:
+      "Each Monday, gather customer feedback from support tickets, interview notes, and surveys over the past week. Cluster into the top 3 themes worth raising in our product meeting, with quotes and frequency.",
+    icon: ChatsTeardrop,
+  },
+  {
+    id: "monthly-metric-review",
+    name: "Monthly metric review",
+    description: "Narrative summary of your key product metrics",
+    prompt:
+      "On the 1st of each month, compile our key product metrics (DAU/WAU, retention, top-feature engagement, conversion) versus the previous month. Write a short narrative summary of what changed, what's working, and what looks worrying.",
+    icon: PresentationChart,
+  },
+  {
+    id: "weekly-product-update",
+    name: "Weekly product update",
+    description: "Drafted update for your team's Monday standup",
+    prompt:
+      "Every Monday at 9am, draft a weekly product update for my team: top events shipped, the biggest metric changes from last week, and anything anomalous worth flagging. Format it for sharing in Slack.",
+    icon: ChartLineUp,
+  },
+];
diff --git a/apps/code/src/renderer/features/work/hooks/useOpenLastRun.ts b/apps/code/src/renderer/features/work/hooks/useOpenLastRun.ts
new file mode 100644
index 000000000..38b92a8e9
--- /dev/null
+++ b/apps/code/src/renderer/features/work/hooks/useOpenLastRun.ts
@@ -0,0 +1,46 @@
+import type { TaskService } from "@features/task-detail/service/service";
+import { get } from "@renderer/di/container";
+import { RENDERER_TOKENS } from "@renderer/di/tokens";
+import { useNavigationStore } from "@stores/navigationStore";
+import { useCallback, useState } from "react";
+import { toast } from "sonner";
+
+/**
+ * Opens the task generated by a scheduled task's most recent run: switches
+ * the app to Code mode and navigates to that task's detail view. Reuses the
+ * same TaskService.openTask path the deep-link handler uses, so workspace
+ * setup is taken care of.
+ */
+export function useOpenLastRun() {
+  const [isOpening, setIsOpening] = useState(false);
+  const setMode = useNavigationStore((s) => s.setMode);
+  const navigateToTask = useNavigationStore((s) => s.navigateToTask);
+
+  const openLastRun = useCallback(
+    async (taskId: string, taskRunId?: string | null) => {
+      setIsOpening(true);
+      try {
+        const taskService = get<TaskService>(RENDERER_TOKENS.TaskService);
+        const result = await taskService.openTask(
+          taskId,
+          taskRunId ?? undefined,
+        );
+        if (!result.success) {
+          toast.error(`Couldn't open the last run: ${result.error}`);
+          return;
+        }
+        setMode("code");
+        navigateToTask(result.data.task);
+      } catch (error) {
+        toast.error(
+          error instanceof Error ? error.message : "Couldn't open the last run",
+        );
+      } finally {
+        setIsOpening(false);
+      }
+    },
+    [setMode, navigateToTask],
+  );
+
+  return { openLastRun, isOpening };
+}
diff --git a/apps/code/src/renderer/features/work/hooks/useScheduledTasks.ts b/apps/code/src/renderer/features/work/hooks/useScheduledTasks.ts
new file mode 100644
index 000000000..89db00c7d
--- /dev/null
+++ b/apps/code/src/renderer/features/work/hooks/useScheduledTasks.ts
@@ -0,0 +1,89 @@
+import { useAuthenticatedMutation } from "@hooks/useAuthenticatedMutation";
+import { useAuthenticatedQuery } from "@hooks/useAuthenticatedQuery";
+import type { Schemas } from "@renderer/api/generated";
+import { queryClient } from "@utils/queryClient";
+
+const SCHEDULED_TASKS_POLL_INTERVAL_MS = 30_000;
+
+export const scheduledTasksKeys = {
+  all: ["scheduled-tasks"] as const,
+  list: () => [...scheduledTasksKeys.all, "list"] as const,
+};
+
+export type ScheduledTaskCreateInput = Pick<
+  Schemas.TaskAutomation,
+  "name" | "prompt" | "cron_expression" | "repository"
+> &
+  Partial<
+    Pick<
+      Schemas.TaskAutomation,
+      "github_integration" | "timezone" | "template_id" | "enabled"
+    >
+  >;
+
+export function useScheduledTasks() {
+  return useAuthenticatedQuery(
+    scheduledTasksKeys.list(),
+    (client) => client.listTaskAutomations(),
+    { refetchInterval: SCHEDULED_TASKS_POLL_INTERVAL_MS },
+  );
+}
+
+export function useCreateScheduledTask() {
+  return useAuthenticatedMutation(
+    (client, input: ScheduledTaskCreateInput) =>
+      client.createTaskAutomation(input),
+    {
+      onSuccess: () => {
+        void queryClient.invalidateQueries({
+          queryKey: scheduledTasksKeys.list(),
+        });
+      },
+    },
+  );
+}
+
+export function useUpdateScheduledTask() {
+  return useAuthenticatedMutation(
+    (
+      client,
+      variables: { id: string; updates: Schemas.PatchedTaskAutomation },
+    ) => client.updateTaskAutomation(variables.id, variables.updates),
+    {
+      onSuccess: () => {
+        void queryClient.invalidateQueries({
+          queryKey: scheduledTasksKeys.list(),
+        });
+      },
+    },
+  );
+}
+
+export function useDeleteScheduledTask() {
+  return useAuthenticatedMutation(
+    (client, id: string) => client.deleteTaskAutomation(id),
+    {
+      onSuccess: () => {
+        void queryClient.invalidateQueries({
+          queryKey: scheduledTasksKeys.list(),
+        });
+      },
+    },
+  );
+}
+
+export function useRunScheduledTaskNow() {
+  return useAuthenticatedMutation(
+    (client, id: string) => client.runTaskAutomationNow(id),
+    {
+      onSuccess: () => {
+        void Promise.all([
+          queryClient.invalidateQueries({
+            queryKey: scheduledTasksKeys.list(),
+          }),
+          queryClient.invalidateQueries({ queryKey: ["tasks"] }),
+        ]);
+      },
+    },
+  );
+}
diff --git a/apps/code/src/renderer/features/work/stores/workStore.test.ts b/apps/code/src/renderer/features/work/stores/workStore.test.ts
new file mode 100644
index 000000000..1307281be
--- /dev/null
+++ b/apps/code/src/renderer/features/work/stores/workStore.test.ts
@@ -0,0 +1,38 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { useWorkStore } from "./workStore";
+
+describe("workStore", () => {
+  beforeEach(() => {
+    useWorkStore.setState({ pendingCreateDraft: null });
+  });
+
+  it("starts with no pending draft", () => {
+    expect(useWorkStore.getState().pendingCreateDraft).toBeNull();
+  });
+
+  it("setPendingCreateDraft writes the slot", () => {
+    useWorkStore
+      .getState()
+      .setPendingCreateDraft({ name: "Audit", prompt: "Audit my flags" });
+    expect(useWorkStore.getState().pendingCreateDraft).toEqual({
+      name: "Audit",
+      prompt: "Audit my flags",
+    });
+  });
+
+  it("consumePendingCreateDraft returns the seeded draft and clears it", () => {
+    useWorkStore.getState().setPendingCreateDraft({ name: "n", prompt: "p" });
+    expect(useWorkStore.getState().consumePendingCreateDraft()).toEqual({
+      name: "n",
+      prompt: "p",
+    });
+    expect(useWorkStore.getState().pendingCreateDraft).toBeNull();
+    expect(useWorkStore.getState().consumePendingCreateDraft()).toBeNull();
+  });
+
+  it("setPendingCreateDraft(null) clears the slot", () => {
+    useWorkStore.getState().setPendingCreateDraft({ prompt: "x" });
+    useWorkStore.getState().setPendingCreateDraft(null);
+    expect(useWorkStore.getState().pendingCreateDraft).toBeNull();
+  });
+});
diff --git a/apps/code/src/renderer/features/work/stores/workStore.ts b/apps/code/src/renderer/features/work/stores/workStore.ts
new file mode 100644
index 000000000..4b9178b8c
--- /dev/null
+++ b/apps/code/src/renderer/features/work/stores/workStore.ts
@@ -0,0 +1,28 @@
+import { create } from "zustand";
+
+export interface PendingCreateDraft {
+  name?: string;
+  prompt?: string;
+}
+
+interface WorkStoreState {
+  /** Draft seed for a brand-new scheduled-task editor session — cleared once consumed. */
+  pendingCreateDraft: PendingCreateDraft | null;
+}
+
+interface WorkStoreActions {
+  setPendingCreateDraft: (draft: PendingCreateDraft | null) => void;
+  consumePendingCreateDraft: () => PendingCreateDraft | null;
+}
+
+type WorkStore = WorkStoreState & WorkStoreActions;
+
+export const useWorkStore = create<WorkStore>()((set, get) => ({
+  pendingCreateDraft: null,
+  setPendingCreateDraft: (draft) => set({ pendingCreateDraft: draft }),
+  consumePendingCreateDraft: () => {
+    const value = get().pendingCreateDraft;
+    if (value !== null) set({ pendingCreateDraft: null });
+    return value;
+  },
+}));
diff --git a/apps/code/src/renderer/features/work/utils/parseSchedule.test.ts b/apps/code/src/renderer/features/work/utils/parseSchedule.test.ts
new file mode 100644
index 000000000..f2d2dc3a6
--- /dev/null
+++ b/apps/code/src/renderer/features/work/utils/parseSchedule.test.ts
@@ -0,0 +1,105 @@
+import { describe, expect, it } from "vitest";
+import { describeCron, parseSchedule } from "./parseSchedule";
+
+describe("parseSchedule", () => {
+  it("returns null for empty input", () => {
+    expect(parseSchedule("")).toBeNull();
+    expect(parseSchedule("   ")).toBeNull();
+  });
+
+  it("passes through raw cron expressions", () => {
+    expect(parseSchedule("0 9 * * *")).toEqual({
+      cron: "0 9 * * *",
+      description: "0 9 * * *",
+    });
+    expect(parseSchedule("*/15 * * * 1-5")).toEqual({
+      cron: "*/15 * * * 1-5",
+      description: "*/15 * * * 1-5",
+    });
+  });
+
+  it("parses hourly", () => {
+    expect(parseSchedule("hourly")?.cron).toBe("0 * * * *");
+    expect(parseSchedule("Every hour")?.cron).toBe("0 * * * *");
+  });
+
+  it("parses 'every N hours'", () => {
+    expect(parseSchedule("every 4 hours")?.cron).toBe("0 */4 * * *");
+    expect(parseSchedule("every 1 hour")?.cron).toBe("0 */1 * * *");
+  });
+
+  it("rejects out-of-range hour intervals", () => {
+    expect(parseSchedule("every 0 hours")).toBeNull();
+    expect(parseSchedule("every 24 hours")).toBeNull();
+  });
+
+  it("parses 'every N minutes'", () => {
+    expect(parseSchedule("every 15 minutes")?.cron).toBe("*/15 * * * *");
+  });
+
+  it("parses daily at TIME", () => {
+    expect(parseSchedule("daily at 9am")?.cron).toBe("0 9 * * *");
+    expect(parseSchedule("every day at 5pm")?.cron).toBe("0 17 * * *");
+    expect(parseSchedule("daily at 9:30am")?.cron).toBe("30 9 * * *");
+    expect(parseSchedule("daily at noon")?.cron).toBe("0 12 * * *");
+    expect(parseSchedule("daily at midnight")?.cron).toBe("0 0 * * *");
+    expect(parseSchedule("daily at 14:30")?.cron).toBe("30 14 * * *");
+  });
+
+  it("handles 12am / 12pm correctly", () => {
+    expect(parseSchedule("daily at 12am")?.cron).toBe("0 0 * * *");
+    expect(parseSchedule("daily at 12pm")?.cron).toBe("0 12 * * *");
+  });
+
+  it("parses weekdays / weekends", () => {
+    expect(parseSchedule("weekdays at 9am")?.cron).toBe("0 9 * * 1-5");
+    expect(parseSchedule("every weekday at 5pm")?.cron).toBe("0 17 * * 1-5");
+    expect(parseSchedule("weekends at 10am")?.cron).toBe("0 10 * * 0,6");
+  });
+
+  it("parses individual days of the week", () => {
+    expect(parseSchedule("Mondays at 9am")?.cron).toBe("0 9 * * 1");
+    expect(parseSchedule("every Tuesday at 5pm")?.cron).toBe("0 17 * * 2");
+    expect(parseSchedule("Friday at 4pm")?.cron).toBe("0 16 * * 5");
+    expect(parseSchedule("Sundays at noon")?.cron).toBe("0 12 * * 0");
+  });
+
+  it("parses 1st of month variants", () => {
+    expect(parseSchedule("1st of the month at 9am")?.cron).toBe("0 9 1 * *");
+    expect(parseSchedule("first of month at 9am")?.cron).toBe("0 9 1 * *");
+    expect(parseSchedule("first of the month at noon")?.cron).toBe(
+      "0 12 1 * *",
+    );
+  });
+
+  it("parses Nth of month", () => {
+    expect(parseSchedule("15th of the month at 9am")?.cron).toBe("0 9 15 * *");
+    expect(parseSchedule("3 of month at 8am")?.cron).toBe("0 8 3 * *");
+  });
+
+  it("rejects nonsense", () => {
+    expect(parseSchedule("blue chickens")).toBeNull();
+    expect(parseSchedule("daily at half past nine")).toBeNull();
+    expect(parseSchedule("every quarter")).toBeNull();
+  });
+
+  it("returns a friendly description for parsed values", () => {
+    expect(parseSchedule("daily at 9am")?.description).toBe("Daily at 9am");
+    expect(parseSchedule("every Tuesday at 5pm")?.description).toBe(
+      "Tuesdays at 5pm",
+    );
+  });
+});
+
+describe("describeCron", () => {
+  it("returns the friendly preset label when known", () => {
+    expect(describeCron("0 9 * * *")).toBe("Daily at 9am");
+    expect(describeCron("0 9 * * 1-5")).toBe("Weekdays at 9am");
+    expect(describeCron("0 9 * * 1")).toBe("Mondays at 9am");
+  });
+
+  it("returns the raw cron when not a known preset", () => {
+    expect(describeCron("*/15 * * * *")).toBe("*/15 * * * *");
+    expect(describeCron("0 17 * * 2")).toBe("0 17 * * 2");
+  });
+});
diff --git a/apps/code/src/renderer/features/work/utils/parseSchedule.ts b/apps/code/src/renderer/features/work/utils/parseSchedule.ts
new file mode 100644
index 000000000..b337a8f42
--- /dev/null
+++ b/apps/code/src/renderer/features/work/utils/parseSchedule.ts
@@ -0,0 +1,210 @@
+/**
+ * Small natural-language → cron parser for the scheduled-task editor.
+ *
+ * Supports common patterns a non-engineer would type. Returns null when it
+ * can't make sense of the input — the caller surfaces "couldn't understand"
+ * and blocks save in that case. Raw 5-field cron expressions pass through.
+ */
+
+const DAY_INDEX: Record<string, number> = {
+  sun: 0,
+  sunday: 0,
+  mon: 1,
+  monday: 1,
+  tue: 2,
+  tues: 2,
+  tuesday: 2,
+  wed: 3,
+  weds: 3,
+  wednesday: 3,
+  thu: 4,
+  thur: 4,
+  thurs: 4,
+  thursday: 4,
+  fri: 5,
+  friday: 5,
+  sat: 6,
+  saturday: 6,
+};
+
+const DAY_DISPLAY = [
+  "Sundays",
+  "Mondays",
+  "Tuesdays",
+  "Wednesdays",
+  "Thursdays",
+  "Fridays",
+  "Saturdays",
+];
+
+interface ParsedTime {
+  h: number;
+  m: number;
+}
+
+function parseTime(input: string): ParsedTime | null {
+  const text = input.trim().toLowerCase();
+  if (text === "noon") return { h: 12, m: 0 };
+  if (text === "midnight") return { h: 0, m: 0 };
+  const match = text.match(/^(\d{1,2})(?::(\d{2}))?\s*(am|pm)?$/);
+  if (!match) return null;
+  let h = Number.parseInt(match[1], 10);
+  const m = match[2] ? Number.parseInt(match[2], 10) : 0;
+  const ampm = match[3];
+  if (ampm === "am") {
+    if (h === 12) h = 0;
+  } else if (ampm === "pm") {
+    if (h !== 12) h += 12;
+  }
+  if (h < 0 || h > 23 || m < 0 || m > 59) return null;
+  return { h, m };
+}
+
+function formatTime(t: ParsedTime): string {
+  const period = t.h >= 12 ? "pm" : "am";
+  const h12 = t.h === 0 ? 12 : t.h > 12 ? t.h - 12 : t.h;
+  if (t.m === 0) return `${h12}${period}`;
+  return `${h12}:${String(t.m).padStart(2, "0")}${period}`;
+}
+
+const DAY_KEY_PATTERN = Object.keys(DAY_INDEX)
+  .sort((a, b) => b.length - a.length)
+  .join("|");
+
+export interface ParseResult {
+  cron: string;
+  description: string;
+}
+
+/**
+ * Returns a cron expression + a friendly description, or null if the input
+ * can't be parsed.
+ */
+export function parseSchedule(input: string): ParseResult | null {
+  const text = input.trim().toLowerCase();
+  if (!text) return null;
+
+  // Raw cron: exactly 5 whitespace-separated tokens of cron-shaped chars.
+  // Pass through unchanged so users can paste a real cron expression too.
+  const CRON_FIELD = "[0-9*,\\-/]+";
+  if (new RegExp(`^${CRON_FIELD}(?:\\s+${CRON_FIELD}){4}$`).test(text)) {
+    return { cron: text, description: text };
+  }
+
+  // Hourly
+  if (text === "hourly" || text === "every hour") {
+    return { cron: "0 * * * *", description: "Every hour" };
+  }
+
+  // Every N hours
+  let m = text.match(/^every\s+(\d+)\s+hours?$/);
+  if (m) {
+    const n = Number.parseInt(m[1], 10);
+    if (n < 1 || n > 23) return null;
+    return { cron: `0 */${n} * * *`, description: `Every ${n} hours` };
+  }
+
+  // Every N minutes
+  m = text.match(/^every\s+(\d+)\s+minutes?$/);
+  if (m) {
+    const n = Number.parseInt(m[1], 10);
+    if (n < 1 || n > 59) return null;
+    return { cron: `*/${n} * * * *`, description: `Every ${n} minutes` };
+  }
+
+  // Daily / every day at TIME
+  m = text.match(/^(?:daily|every\s+day)\s+at\s+(.+)$/);
+  if (m) {
+    const time = parseTime(m[1]);
+    if (!time) return null;
+    return {
+      cron: `${time.m} ${time.h} * * *`,
+      description: `Daily at ${formatTime(time)}`,
+    };
+  }
+
+  // Weekdays / every weekday at TIME
+  m = text.match(/^(?:weekdays|every\s+weekday)\s+at\s+(.+)$/);
+  if (m) {
+    const time = parseTime(m[1]);
+    if (!time) return null;
+    return {
+      cron: `${time.m} ${time.h} * * 1-5`,
+      description: `Weekdays at ${formatTime(time)}`,
+    };
+  }
+
+  // Weekends at TIME
+  m = text.match(/^(?:weekends|every\s+weekend)\s+at\s+(.+)$/);
+  if (m) {
+    const time = parseTime(m[1]);
+    if (!time) return null;
+    return {
+      cron: `${time.m} ${time.h} * * 0,6`,
+      description: `Weekends at ${formatTime(time)}`,
+    };
+  }
+
+  // <Day(s)> at TIME, optionally "every <Day> at TIME"
+  m = text.match(
+    new RegExp(`^(?:every\\s+)?(${DAY_KEY_PATTERN})s?\\s+at\\s+(.+)$`),
+  );
+  if (m) {
+    const day = DAY_INDEX[m[1]];
+    const time = parseTime(m[2]);
+    if (!time) return null;
+    return {
+      cron: `${time.m} ${time.h} * * ${day}`,
+      description: `${DAY_DISPLAY[day]} at ${formatTime(time)}`,
+    };
+  }
+
+  // 1st of (the) month at TIME / first of month at TIME
+  m = text.match(/^(?:1st|first)\s+of\s+(?:the\s+)?month\s+at\s+(.+)$/);
+  if (m) {
+    const time = parseTime(m[1]);
+    if (!time) return null;
+    return {
+      cron: `${time.m} ${time.h} 1 * *`,
+      description: `1st of month at ${formatTime(time)}`,
+    };
+  }
+
+  // Nth of (the) month at TIME (e.g. "15th of the month at 9am")
+  m = text.match(/^(\d+)(?:st|nd|rd|th)?\s+of\s+(?:the\s+)?month\s+at\s+(.+)$/);
+  if (m) {
+    const dom = Number.parseInt(m[1], 10);
+    if (dom < 1 || dom > 31) return null;
+    const time = parseTime(m[2]);
+    if (!time) return null;
+    return {
+      cron: `${time.m} ${time.h} ${dom} * *`,
+      description: `Day ${dom} of month at ${formatTime(time)}`,
+    };
+  }
+
+  return null;
+}
+
+/**
+ * Inverse — best effort. Used to seed the schedule field with friendly
+ * text when an existing automation's cron matches a known pattern.
+ * Returns the original cron string when nothing matches (the parser
+ * accepts raw cron pass-through, so the UI still works either way).
+ */
+export function describeCron(cron: string): string {
+  switch (cron.trim()) {
+    case "0 * * * *":
+      return "Every hour";
+    case "0 9 * * *":
+      return "Daily at 9am";
+    case "0 9 * * 1-5":
+      return "Weekdays at 9am";
+    case "0 9 * * 1":
+      return "Mondays at 9am";
+    case "0 9 1 * *":
+      return "1st of month at 9am";
+    default:
+      return cron;
+  }
+}
diff --git a/apps/code/src/renderer/features/work/utils/schedulePresets.test.ts b/apps/code/src/renderer/features/work/utils/schedulePresets.test.ts
new file mode 100644
index 000000000..1fabc0c9a
--- /dev/null
+++ b/apps/code/src/renderer/features/work/utils/schedulePresets.test.ts
@@ -0,0 +1,193 @@
+import { describe, expect, it } from "vitest";
+import {
+  cronForPreset,
+  DEFAULT_PRESET_ID,
+  labelForCron,
+  nextRunForPreset,
+  presetForCron,
+  SCHEDULE_PRESETS,
+} from "./schedulePresets";
+
+describe("schedulePresets", () => {
+  it("contains the default preset id", () => {
+    expect(SCHEDULE_PRESETS.some((p) => p.id === DEFAULT_PRESET_ID)).toBe(true);
+  });
+
+  it("has unique preset ids", () => {
+    const ids = SCHEDULE_PRESETS.map((p) => p.id);
+    expect(new Set(ids).size).toBe(ids.length);
+  });
+
+  it("has unique cron expressions", () => {
+    const crons = SCHEDULE_PRESETS.map((p) => p.cron);
+    expect(new Set(crons).size).toBe(crons.length);
+  });
+
+  it("round-trips id ↔ cron for every preset", () => {
+    for (const preset of SCHEDULE_PRESETS) {
+      expect(cronForPreset(preset.id)).toBe(preset.cron);
+      expect(presetForCron(preset.cron)?.id).toBe(preset.id);
+    }
+  });
+
+  it("cronForPreset throws for unknown id", () => {
+    // @ts-expect-error - intentionally passing an invalid id
+    expect(() => cronForPreset("not-a-real-preset")).toThrow();
+  });
+
+  it("presetForCron returns null for unknown cron", () => {
+    expect(presetForCron("12 34 5 6 7")).toBeNull();
+  });
+
+  it("labelForCron returns the preset label when matched", () => {
+    expect(labelForCron("0 9 * * *")).toBe("Daily at 9am");
+  });
+
+  it("labelForCron falls back to the raw cron string when unknown", () => {
+    expect(labelForCron("*/15 * * * *")).toBe("*/15 * * * *");
+  });
+});
+
+describe("nextRunForPreset", () => {
+  it("always returns a Date strictly greater than `now`", () => {
+    const now = new Date("2026-05-13T14:23:45");
+    for (const preset of SCHEDULE_PRESETS) {
+      const next = nextRunForPreset(preset.id, now);
+      expect(next.getTime()).toBeGreaterThan(now.getTime());
+    }
+  });
+
+  describe("hourly", () => {
+    it("rolls to the top of the next hour", () => {
+      // 2026-05-13 Wed 14:23
+      const now = new Date(2026, 4, 13, 14, 23, 45, 100);
+      const next = nextRunForPreset("hourly", now);
+      expect(next.getMinutes()).toBe(0);
+      expect(next.getSeconds()).toBe(0);
+      expect(next.getMilliseconds()).toBe(0);
+      expect(next.getHours()).toBe(15);
+      expect(next.getDate()).toBe(13);
+    });
+
+    it("rolls across day boundary at 23:xx", () => {
+      const now = new Date(2026, 4, 13, 23, 50);
+      const next = nextRunForPreset("hourly", now);
+      expect(next.getDate()).toBe(14);
+      expect(next.getHours()).toBe(0);
+    });
+  });
+
+  describe("daily-9am", () => {
+    it("returns today at 9am if before 9am", () => {
+      const now = new Date(2026, 4, 13, 8, 0); // 8:00 Wed
+      const next = nextRunForPreset("daily-9am", now);
+      expect(next.getDate()).toBe(13);
+      expect(next.getHours()).toBe(9);
+      expect(next.getMinutes()).toBe(0);
+    });
+
+    it("returns tomorrow at 9am if past 9am", () => {
+      const now = new Date(2026, 4, 13, 10, 0); // 10:00 Wed
+      const next = nextRunForPreset("daily-9am", now);
+      expect(next.getDate()).toBe(14);
+      expect(next.getHours()).toBe(9);
+    });
+
+    it("returns tomorrow at 9am exactly at 9am", () => {
+      const now = new Date(2026, 4, 13, 9, 0); // exactly 9:00 Wed
+      const next = nextRunForPreset("daily-9am", now);
+      expect(next.getDate()).toBe(14);
+      expect(next.getHours()).toBe(9);
+    });
+  });
+
+  describe("weekdays-9am", () => {
+    it("returns today at 9am on a weekday morning", () => {
+      const now = new Date(2026, 4, 13, 8, 0); // Wed 8:00
+      const next = nextRunForPreset("weekdays-9am", now);
+      expect(next.getDate()).toBe(13);
+      expect(next.getDay()).toBe(3);
+    });
+
+    it("rolls to Monday from Friday afternoon", () => {
+      // 2026-05-15 is Friday
+      const friday = new Date(2026, 4, 15, 10, 0);
+      const next = nextRunForPreset("weekdays-9am", friday);
+      expect(next.getDay()).toBe(1); // Monday
+    });
+
+    it("rolls to Monday from Saturday morning before 9", () => {
+      const saturday = new Date(2026, 4, 16, 8, 0);
+      const next = nextRunForPreset("weekdays-9am", saturday);
+      expect(next.getDay()).toBe(1);
+    });
+
+    it("rolls to Monday from Sunday afternoon", () => {
+      const sunday = new Date(2026, 4, 17, 16, 0);
+      const next = nextRunForPreset("weekdays-9am", sunday);
+      expect(next.getDay()).toBe(1);
+    });
+  });
+
+  describe("monday-9am", () => {
+    it("returns today at 9am on Monday morning before 9", () => {
+      // 2026-05-11 is Monday
+      const now = new Date(2026, 4, 11, 8, 0);
+      const next = nextRunForPreset("monday-9am", now);
+      expect(next.getDay()).toBe(1);
+      expect(next.getDate()).toBe(11);
+    });
+
+    it("rolls to next Monday from Monday afternoon", () => {
+      const now = new Date(2026, 4, 11, 10, 0);
+      const next = nextRunForPreset("monday-9am", now);
+      expect(next.getDay()).toBe(1);
+      expect(next.getDate()).toBe(18);
+    });
+
+    it("rolls forward from Wednesday morning before 9", () => {
+      const now = new Date(2026, 4, 13, 8, 0); // Wed
+      const next = nextRunForPreset("monday-9am", now);
+      expect(next.getDay()).toBe(1);
+      expect(next.getDate()).toBe(18); // following Monday
+    });
+  });
+
+  describe("monthly-1st-9am", () => {
+    it("returns today at 9am on the 1st before 9", () => {
+      const now = new Date(2026, 4, 1, 8, 0);
+      const next = nextRunForPreset("monthly-1st-9am", now);
+      expect(next.getDate()).toBe(1);
+      expect(next.getMonth()).toBe(4);
+    });
+
+    it("rolls to next month from the 1st past 9am", () => {
+      const now = new Date(2026, 4, 1, 10, 0);
+      const next = nextRunForPreset("monthly-1st-9am", now);
+      expect(next.getDate()).toBe(1);
+      expect(next.getMonth()).toBe(5);
+    });
+
+    it("rolls to next month from mid-month", () => {
+      const now = new Date(2026, 4, 15, 12, 0);
+      const next = nextRunForPreset("monthly-1st-9am", now);
+      expect(next.getDate()).toBe(1);
+      expect(next.getMonth()).toBe(5);
+    });
+
+    it("handles Dec → Jan year roll", () => {
+      const now = new Date(2026, 11, 20, 12, 0);
+      const next = nextRunForPreset("monthly-1st-9am", now);
+      expect(next.getDate()).toBe(1);
+      expect(next.getMonth()).toBe(0);
+      expect(next.getFullYear()).toBe(2027);
+    });
+
+    it("returns the 1st of next month from the 31st", () => {
+      const now = new Date(2026, 0, 31, 12, 0);
+      const next = nextRunForPreset("monthly-1st-9am", now);
+      expect(next.getDate()).toBe(1);
+      expect(next.getMonth()).toBe(1);
+    });
+  });
+});
diff --git a/apps/code/src/renderer/features/work/utils/schedulePresets.ts b/apps/code/src/renderer/features/work/utils/schedulePresets.ts
new file mode 100644
index 000000000..80f131ebc
--- /dev/null
+++ b/apps/code/src/renderer/features/work/utils/schedulePresets.ts
@@ -0,0 +1,85 @@
+export const SCHEDULE_PRESETS = [
+  { id: "hourly", label: "Every hour", cron: "0 * * * *" },
+  { id: "daily-9am", label: "Daily at 9am", cron: "0 9 * * *" },
+  { id: "weekdays-9am", label: "Weekdays at 9am", cron: "0 9 * * 1-5" },
+  { id: "monday-9am", label: "Mondays at 9am", cron: "0 9 * * 1" },
+  { id: "monthly-1st-9am", label: "1st of month at 9am", cron: "0 9 1 * *" },
+] as const;
+
+export type SchedulePreset = (typeof SCHEDULE_PRESETS)[number];
+export type SchedulePresetId = SchedulePreset["id"];
+
+export const DEFAULT_PRESET_ID: SchedulePresetId = "daily-9am";
+
+export function presetForCron(cron: string): SchedulePreset | null {
+  return SCHEDULE_PRESETS.find((preset) => preset.cron === cron) ?? null;
+}
+
+export function cronForPreset(id: SchedulePresetId): string {
+  const preset = SCHEDULE_PRESETS.find((p) => p.id === id);
+  if (!preset) {
+    throw new Error(`Unknown schedule preset: ${id}`);
+  }
+  return preset.cron;
+}
+
+export function labelForCron(cron: string): string {
+  return presetForCron(cron)?.label ?? cron;
+}
+
+/**
+ * Compute the next fire time for a preset relative to `now`, in the local timezone.
+ * Returned Date is always strictly greater than `now`.
+ */
+export function nextRunForPreset(
+  presetId: SchedulePresetId,
+  now: Date = new Date(),
+): Date {
+  const next = new Date(now);
+
+  switch (presetId) {
+    case "hourly": {
+      next.setMinutes(0, 0, 0);
+      next.setHours(next.getHours() + 1);
+      return next;
+    }
+    case "daily-9am": {
+      next.setHours(9, 0, 0, 0);
+      if (next <= now) next.setDate(next.getDate() + 1);
+      return next;
+    }
+    case "weekdays-9am": {
+      next.setHours(9, 0, 0, 0);
+      if (next <= now || isWeekend(next)) {
+        next.setDate(next.getDate() + 1);
+      }
+      while (isWeekend(next)) {
+        next.setDate(next.getDate() + 1);
+      }
+      return next;
+    }
+    case "monday-9am": {
+      next.setHours(9, 0, 0, 0);
+      if (next <= now || next.getDay() !== 1) {
+        next.setDate(next.getDate() + 1);
+      }
+      while (next.getDay() !== 1) {
+        next.setDate(next.getDate() + 1);
+      }
+      return next;
+    }
+    case "monthly-1st-9am": {
+      next.setHours(9, 0, 0, 0);
+      if (next.getDate() !== 1 || next <= now) {
+        next.setMonth(next.getMonth() + 1, 1);
+        next.setHours(9, 0, 0, 0);
+      }
+      return next;
+    }
+  }
+}
+
+function isWeekend(date: Date): boolean {
+  const day = date.getDay();
+  return day === 0 || day === 6;
+}
diff --git a/apps/code/src/renderer/features/work/utils/sourcesPrompt.test.ts b/apps/code/src/renderer/features/work/utils/sourcesPrompt.test.ts
new file mode 100644
index 000000000..7a8865c4a
--- /dev/null
+++ b/apps/code/src/renderer/features/work/utils/sourcesPrompt.test.ts
@@ -0,0 +1,44 @@
+import { describe, expect, it } from "vitest";
+import { decodePrompt, encodePrompt } from "./sourcesPrompt";
+
+describe("sourcesPrompt", () => {
+  it("decodes a prompt without a sources header", () => {
+    expect(decodePrompt("just the prompt")).toEqual({
+      sources: [],
+      body: "just the prompt",
+    });
+  });
+
+  it("decodes a prompt with a sources header", () => {
+    expect(decodePrompt("[Sources: github, slack]\n\nDo the thing")).toEqual({
+      sources: ["github", "slack"],
+      body: "Do the thing",
+    });
+  });
+
+  it("decodes ignores extra whitespace and empty entries", () => {
+    expect(decodePrompt("[Sources:   github , , slack ]\n\nx")).toEqual({
+      sources: ["github", "slack"],
+      body: "x",
+    });
+  });
+
+  it("encodes nothing when sources is empty", () => {
+    expect(encodePrompt("body", [])).toBe("body");
+    expect(encodePrompt("body", ["", "  "])).toBe("body");
+  });
+
+  it("encodes a sources header", () => {
+    expect(encodePrompt("body", ["github", "slack"])).toBe(
+      "[Sources: github, slack]\n\nbody",
+    );
+  });
+
+  it("round-trips encode → decode", () => {
+    const encoded = encodePrompt("the actual prompt", ["a", "b", "c"]);
+    expect(decodePrompt(encoded)).toEqual({
+      sources: ["a", "b", "c"],
+      body: "the actual prompt",
+    });
+  });
+});
diff --git a/apps/code/src/renderer/features/work/utils/sourcesPrompt.ts b/apps/code/src/renderer/features/work/utils/sourcesPrompt.ts
new file mode 100644
index 000000000..2932e6c92
--- /dev/null
+++ b/apps/code/src/renderer/features/work/utils/sourcesPrompt.ts
@@ -0,0 +1,36 @@
+/**
+ * Encode/decode the user's selected MCP data sources as a prefix in the
+ * scheduled task's prompt. This is a stopgap until the backend grows a
+ * first-class `mcp_sources` field on TaskAutomation.
+ *
+ * Format:
+ *   [Sources: github, slack, linear]
+ *   <blank line>
+ *   <prompt body>
+ *
+ * If the prompt doesn't start with this header, the sources list is empty
+ * and the body is the entire prompt.
+ */
+
+const PREFIX_RE = /^\[Sources:\s*([^\]]*)\]\s*\n+([\s\S]*)$/;
+
+export interface PromptWithSources {
+  sources: string[];
+  body: string;
+}
+
+export function decodePrompt(prompt: string): PromptWithSources {
+  const m = prompt.match(PREFIX_RE);
+  if (!m) return { sources: [], body: prompt };
+  const sources = m[1]
+    .split(",")
+    .map((s) => s.trim())
+    .filter((s) => s.length > 0);
+  return { sources, body: m[2] };
+}
+
+export function encodePrompt(body: string, sources: string[]): string {
+  const cleaned = sources.map((s) => s.trim()).filter((s) => s.length > 0);
+  if (cleaned.length === 0) return body;
+  return `[Sources: ${cleaned.join(", ")}]\n\n${body}`;
+}
diff --git a/apps/code/src/renderer/features/work/utils/timezone.test.ts b/apps/code/src/renderer/features/work/utils/timezone.test.ts
new file mode 100644
index 000000000..e7e1302c4
--- /dev/null
+++ b/apps/code/src/renderer/features/work/utils/timezone.test.ts
@@ -0,0 +1,31 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { detectTimezone } from "./timezone";
+
+describe("detectTimezone", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("returns an IANA timezone string in the happy path", () => {
+    const tz = detectTimezone();
+    expect(typeof tz).toBe("string");
+    expect(tz.length).toBeGreaterThan(0);
+  });
+
+  it("falls back to UTC when Intl throws", () => {
+    vi.spyOn(Intl, "DateTimeFormat").mockImplementation(() => {
+      throw new Error("nope");
+    });
+    expect(detectTimezone()).toBe("UTC");
+  });
+
+  it("falls back to UTC when resolvedOptions returns an empty timezone", () => {
+    vi.spyOn(Intl, "DateTimeFormat").mockImplementation(
+      () =>
+        ({
+          resolvedOptions: () => ({ timeZone: "" }) as never,
+        }) as never,
+    );
+    expect(detectTimezone()).toBe("UTC");
+  });
+});
diff --git a/apps/code/src/renderer/features/work/utils/timezone.ts b/apps/code/src/renderer/features/work/utils/timezone.ts
new file mode 100644
index 000000000..d75b1c9fe
--- /dev/null
+++ b/apps/code/src/renderer/features/work/utils/timezone.ts
@@ -0,0 +1,11 @@
+/**
+ * Returns the user's local IANA timezone, e.g. "America/New_York".
+ * Falls back to "UTC" if the runtime can't resolve it.
+ */
+export function detectTimezone(): string {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+  } catch {
+    return "UTC";
+  }
+}
diff --git a/apps/code/src/renderer/stores/navigationStore.ts b/apps/code/src/renderer/stores/navigationStore.ts
index b6d66a6aa..e2d5e6a95 100644
--- a/apps/code/src/renderer/stores/navigationStore.ts
+++ b/apps/code/src/renderer/stores/navigationStore.ts
@@ -37,7 +37,13 @@ interface TaskInputNavigationOptions {
 
 export type AppMode = "code" | "work";
 
-export type WorkView = "home" | "generate" | "skill-detail" | "library";
+export type WorkView =
+  | "home"
+  | "generate"
+  | "skill-detail"
+  | "library"
+  | "scheduled-list"
+  | "scheduled-edit";
 
 interface ViewState {
   type: ViewType;
@@ -57,10 +63,14 @@ interface NavigationStore {
   skipWorkOnboarding: () => void;
   workView: WorkView;
   workSelectedSkillId?: string;
+  workScheduledEditId?: string;
   navigateToWorkHome: () => void;
   navigateToWorkGenerate: () => void;
   navigateToWorkSkill: (skillId: string) => void;
   navigateToWorkLibrary: () => void;
+  navigateToWorkScheduledList: () => void;
+  navigateToWorkScheduledCreate: () => void;
+  navigateToWorkScheduledEdit: (scheduledId: string) => void;
   view: ViewState;
   history: ViewState[];
   historyIndex: number;
@@ -143,14 +153,49 @@ export const useNavigationStore = create<NavigationStore>()(
         skipWorkOnboarding: () => set({ workOnboardingSkipped: true }),
         workView: "home",
         workSelectedSkillId: undefined,
+        workScheduledEditId: undefined,
         navigateToWorkHome: () =>
-          set({ workView: "home", workSelectedSkillId: undefined }),
+          set({
+            workView: "home",
+            workSelectedSkillId: undefined,
+            workScheduledEditId: undefined,
+          }),
         navigateToWorkGenerate: () =>
-          set({ workView: "generate", workSelectedSkillId: undefined }),
+          set({
+            workView: "generate",
+            workSelectedSkillId: undefined,
+            workScheduledEditId: undefined,
+          }),
         navigateToWorkSkill: (skillId: string) =>
-          set({ workView: "skill-detail", workSelectedSkillId: skillId }),
+          set({
+            workView: "skill-detail",
+            workSelectedSkillId: skillId,
+            workScheduledEditId: undefined,
+          }),
         navigateToWorkLibrary: () =>
-          set({ workView: "library", workSelectedSkillId: undefined }),
+          set({
+            workView: "library",
+            workSelectedSkillId: undefined,
+            workScheduledEditId: undefined,
+          }),
+        navigateToWorkScheduledList: () =>
+          set({
+            workView: "scheduled-list",
+            workSelectedSkillId: undefined,
+            workScheduledEditId: undefined,
+          }),
+        navigateToWorkScheduledCreate: () =>
+          set({
+            workView: "scheduled-edit",
+            workSelectedSkillId: undefined,
+            workScheduledEditId: undefined,
+          }),
+        navigateToWorkScheduledEdit: (scheduledId: string) =>
+          set({
+            workView: "scheduled-edit",
+            workSelectedSkillId: undefined,
+            workScheduledEditId: scheduledId,
+          }),
         view: { type: "task-input" },
         history: [{ type: "task-input" }],
         historyIndex: 0,
@@ -370,6 +415,7 @@ export const useNavigationStore = create<NavigationStore>()(
         workOnboardingSkipped: state.workOnboardingSkipped,
         workView: state.workView,
         workSelectedSkillId: state.workSelectedSkillId,
+        workScheduledEditId: state.workScheduledEditId,
         view: {
           type: state.view.type,
           taskId: state.view.taskId,