diff --git a/client/src/App.tsx b/client/src/App.tsx
index 79e23e59..6aea35c7 100644
--- a/client/src/App.tsx
+++ b/client/src/App.tsx
@@ -358,6 +358,27 @@ function AppBody() {
     handleSelectSession(target.projectId, target.sessionId, target.worktreeId);
   }, []);
 
+  /**
+   * Open a session referenced by a schedule run. The Schedules section
+   * passes the run's `projectId` (the cross-project view can show schedules
+   * from any project, not just the active one — issue #303 P2 review), and
+   * we prefer that over `activeProjectId` so deep-links land in the right
+   * project. `activeProjectId` is the fallback for callers that don't pass
+   * it. Mirrors `handleOpenConversation` but tolerates a missing `worktreeId`.
+   */
+  const handleOpenSessionFromSchedule = useCallback(
+    (params: {
+      sessionId: string;
+      worktreeId?: string;
+      projectId?: string;
+    }) => {
+      const projectId = params.projectId ?? activeProjectId;
+      if (!projectId) return;
+      handleSelectSession(projectId, params.sessionId, params.worktreeId);
+    },
+    [activeProjectId]
+  );
+
   const handleNewThread = (projectId: string, worktreeId?: string) => {
     setActiveProjectId(projectId);
     setView({ page: "session", projectId, worktreeId });
@@ -799,6 +820,8 @@ function AppBody() {
             section={activeView.section}
             onSectionChange={(section) => setView({ page: "settings", section })}
             onClose={() => setView(preSettingsViewRef.current)}
+            projectId={activeProjectId ?? undefined}
+            onOpenSession={handleOpenSessionFromSchedule}
           />
         )}
         </AppErrorBoundary>
diff --git a/client/src/api.ts b/client/src/api.ts
index 6ce425cd..de0bc1f2 100644
--- a/client/src/api.ts
+++ b/client/src/api.ts
@@ -1688,3 +1688,191 @@ export async function resetShortcutBindings(): Promise<ShortcutBindings> {
   const res = await fetch(`${BASE}/shortcuts`, { method: "DELETE" });
   return res.json();
 }
+
+// --- Schedules (issue #303) ---
+//
+// Mirrors the server's `Schedule` / `ScheduleInput` shapes (server/lib/schedules.ts).
+// The UI is a thin client over the existing REST surface: list, create, toggle
+// enabled, delete, and inspect runs. Editing a trigger is intentionally out of
+// scope — the server has no PUT route for it (issue #303 non-goals).
+
+export type ScheduleSource = "user" | "agent";
+
+export interface Schedule {
+  id: string;
+  projectId: string;
+  worktreeId: string;
+  prompt: string;
+  provider?: string;
+  model?: string;
+  mode?: "default" | "plan";
+  cron: string | null;
+  timezone: string;
+  runAt: string | null;
+  nextRunAt: string;
+  lastRunAt: string | null;
+  lastRunSessionId: string | null;
+  lastError: string | null;
+  source: ScheduleSource;
+  enabled: boolean;
+  createdAt: string;
+  createdBy: string | null;
+}
+
+export interface ScheduleInput {
+  worktreeId: string;
+  prompt: string;
+  provider?: string;
+  model?: string;
+  mode?: "default" | "plan";
+  cron?: string | null;
+  timezone?: string;
+  runAt?: string | null;
+  enabled?: boolean;
+  source?: ScheduleSource;
+  createdBy?: string | null;
+}
+
+export interface ScheduleRun {
+  firedAt: string;
+  sessionId: string | null;
+  error: string | null;
+}
+
+/**
+ * A schedule paired with its owning project's id and a label, so the
+ * cross-project Schedules section can render a single list without the
+ * caller having to track which project each row came from. The
+ * `projectName` is denormalised at fetch time and is purely a display
+ * hint; the `projectId` is the source of truth.
+ */
+export interface ScheduleWithProject extends Schedule {
+  projectName: string;
+}
+
+/**
+ * Result of a cross-project schedule fetch. `schedules` is what the
+ * UI renders; `failedProjectIds` lists projects whose storage we
+ * couldn't read this round, so the section can surface a non-fatal
+ * "some projects failed to load" banner instead of silently
+ * dropping them. Issue #303 P2 review: swallowing per-project
+ * failures made the UI show "No schedules yet" while active
+ * schedules were still around.
+ */
+export interface AllSchedulesResult {
+  schedules: ScheduleWithProject[];
+  failedProjectIds: string[];
+}
+
+function schedulePath(projectId: string, scheduleId?: string): string {
+  const base = `${BASE}/projects/${projectId}/schedules`;
+  return scheduleId ? `${base}/${scheduleId}` : base;
+}
+
+export async function fetchSchedules(
+  projectId: string,
+  includeDisabled = true
+): Promise<Schedule[]> {
+  const params = new URLSearchParams({ includeDisabled: String(includeDisabled) });
+  const res = await fetch(`${schedulePath(projectId)}?${params}`);
+  await throwIfNotOk(res, "Failed to fetch schedules");
+  const body = (await res.json()) as unknown;
+  return Array.isArray(body) ? (body as Schedule[]) : [];
+}
+
+/**
+ * Fetch every project's schedules in parallel and merge them into a
+ * single list annotated with the owning project's display name.
+ *
+ * The server doesn't expose a `/api/schedules` cross-project endpoint
+ * by design (issue #303 — the CLI is the source of truth for the data
+ * model), so this is a client-side fan-out. It's the same shape every
+ * per-project page already uses, just collected in one place.
+ *
+ * Per-project failures are reported back via `failedProjectIds`
+ * rather than swallowed: in a corrupt-store or transient 500 case,
+ * the user should see "X projects failed to load" rather than an
+ * incomplete list that looks healthy. Issue #303 P2 review.
+ */
+export async function fetchAllSchedules(
+  includeDisabled = true
+): Promise<AllSchedulesResult> {
+  const projects = await fetchProjects();
+  const settled = await Promise.all(
+    projects.map(async (project) => {
+      try {
+        const schedules = await fetchSchedules(project.id, includeDisabled);
+        return {
+          ok: true as const,
+          project,
+          schedules: schedules.map((schedule) => ({
+            ...schedule,
+            projectName: project.name,
+          })),
+        };
+      } catch (error) {
+        return {
+          ok: false as const,
+          project,
+          error: error instanceof Error ? error.message : String(error),
+        };
+      }
+    }),
+  );
+  const schedules: ScheduleWithProject[] = [];
+  const failedProjectIds: string[] = [];
+  for (const entry of settled) {
+    if (entry.ok) {
+      schedules.push(...entry.schedules);
+    } else {
+      failedProjectIds.push(entry.project.id);
+    }
+  }
+  return { schedules, failedProjectIds };
+}
+
+export async function createSchedule(
+  projectId: string,
+  input: ScheduleInput
+): Promise<Schedule> {
+  const res = await fetch(schedulePath(projectId), {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(input),
+  });
+  await throwIfNotOk(res, "Failed to create schedule");
+  return res.json();
+}
+
+export async function setScheduleEnabled(
+  projectId: string,
+  scheduleId: string,
+  enabled: boolean
+): Promise<Schedule> {
+  const action = enabled ? "enable" : "disable";
+  const res = await fetch(`${schedulePath(projectId, scheduleId)}/${action}`, {
+    method: "POST",
+  });
+  await throwIfNotOk(res, `Failed to ${action} schedule`);
+  return res.json();
+}
+
+export async function deleteSchedule(
+  projectId: string,
+  scheduleId: string
+): Promise<void> {
+  const res = await fetch(schedulePath(projectId, scheduleId), {
+    method: "DELETE",
+  });
+  await throwIfNotOk(res, "Failed to delete schedule");
+}
+
+export async function fetchScheduleRuns(
+  projectId: string,
+  scheduleId: string
+): Promise<ScheduleRun[]> {
+  const res = await fetch(`${schedulePath(projectId, scheduleId)}/runs`);
+  await throwIfNotOk(res, "Failed to fetch schedule runs");
+  const body = (await res.json()) as unknown;
+  return Array.isArray(body) ? (body as ScheduleRun[]) : [];
+}
diff --git a/client/src/components/__tests__/schedules-section.test.tsx b/client/src/components/__tests__/schedules-section.test.tsx
new file mode 100644
index 00000000..61e10f99
--- /dev/null
+++ b/client/src/components/__tests__/schedules-section.test.tsx
@@ -0,0 +1,472 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { renderToStaticMarkup } from "react-dom/server";
+import {
+  SchedulesSection,
+  ScheduleRow,
+  CreateScheduleForm,
+} from "../schedules-section.tsx";
+import type {
+  Project,
+  Schedule,
+  ScheduleWithProject,
+  Worktree,
+} from "../../api.ts";
+
+/*
+ * Regression test for the Schedules settings section (issue #303).
+ *
+ * The server side is fully covered by `server/lib/__tests__/schedules.test.ts`
+ * and the REST surface in `server/routes/schedules.ts`. This file covers what
+ * the UI is responsible for:
+ *
+ *   1. List rendering — `ScheduleRow` surfaces project name, prompt
+ *      preview, trigger type, enabled state, last run, and last error.
+ *      The section is cross-project (per review feedback on #303), so
+ *      each row also carries a project badge.
+ *   2. Create happy path — `CreateScheduleForm` (extracted from the
+ *      dialog wrapper) exposes the project + worktree selectors, the
+ *      prompt, the trigger toggle, and the save button.
+ *   3. Delete confirmation — the section renders an `AlertDialog` and
+ *      only fires DELETE after the destructive action is confirmed
+ *      (verified via the data-testid hooks).
+ *   4. Enable / disable toggle — `ScheduleRow` renders a `Switch` that
+ *      reflects `schedule.enabled` and is wired to `onToggle`.
+ *
+ * We use `renderToStaticMarkup` (matching the other client regression
+ * tests in this folder) and export the inner `ScheduleRow` /
+ * `CreateScheduleForm` so we can render them with deterministic inputs
+ * without mounting the full stateful section.
+ */
+
+const NOOP = () => {};
+const NOOP_STR = (_v: string) => {};
+const NOOP_TRIGGER = (_v: "runAt" | "cron") => {};
+const NOOP_ASYNC = async () => [];
+
+const PROJECT: Project = {
+  id: "project-1",
+  name: "Anita",
+  path: "/tmp/project-1",
+  createdAt: "2025-01-01T00:00:00.000Z",
+};
+
+const PROJECT_2: Project = {
+  id: "project-2",
+  name: "Germini",
+  path: "/tmp/project-2",
+  createdAt: "2025-01-01T00:00:00.000Z",
+};
+
+const WORKTREES: Worktree[] = [
+  {
+    id: "wt-1",
+    projectId: PROJECT.id,
+    name: "main",
+    path: "/tmp/wt-1",
+    isMain: true,
+    createdAt: "2025-01-01T00:00:00.000Z",
+  },
+  {
+    id: "wt-2",
+    projectId: PROJECT.id,
+    name: "feature",
+    path: "/tmp/wt-2",
+    isMain: false,
+    createdAt: "2025-01-01T00:00:00.000Z",
+  },
+];
+
+function schedule(overrides: Partial<Schedule> = {}): Schedule {
+  return {
+    id: "sched-1",
+    projectId: PROJECT.id,
+    worktreeId: "wt-1",
+    prompt: "Run the daily digest",
+    cron: "0 9 * * *",
+    timezone: "UTC",
+    runAt: null,
+    nextRunAt: "2025-05-01T09:00:00.000Z",
+    lastRunAt: null,
+    lastRunSessionId: null,
+    lastError: null,
+    source: "user",
+    enabled: true,
+    createdAt: "2025-04-30T00:00:00.000Z",
+    createdBy: "ui",
+    ...overrides,
+  };
+}
+
+function withProject(
+  base: Schedule,
+  project: Project
+): ScheduleWithProject {
+  return { ...base, projectName: project.name };
+}
+
+function renderRow(
+  entry: ScheduleWithProject,
+  options: { toggling?: boolean } = {}
+): string {
+  return renderToStaticMarkup(
+    <ScheduleRow
+      schedule={entry}
+      onToggle={NOOP}
+      onDelete={NOOP}
+      onViewRuns={NOOP}
+      toggling={options.toggling ?? false}
+    />,
+  );
+}
+
+// ---------------------------------------------------------------------------
+// 1. List rendering — `ScheduleRow`
+// ---------------------------------------------------------------------------
+
+test("ScheduleRow surfaces the project name, trigger, and prompt preview for a cron schedule", () => {
+  const html = renderRow(withProject(schedule(), PROJECT));
+  assert.match(html, /data-testid="schedule-row-sched-1"/);
+  assert.match(html, /Run the daily digest/);
+  // Project badge is the first thing in the row.
+  assert.match(html, />Anita</);
+  // Trigger label is human-readable: cron expression.
+  assert.match(html, /cron: 0 9 \* \* \*/);
+  // Source badge.
+  assert.match(html, />user</);
+  // No "disabled" badge for an enabled row.
+  assert.doesNotMatch(html, />disabled</);
+});
+
+test("ScheduleRow renders the trigger type and runAt for a one-shot schedule", () => {
+  const html = renderRow(
+    withProject(
+      schedule({ id: "sched-2", cron: null, runAt: "2025-06-01T00:00:00.000Z" }),
+      PROJECT
+    )
+  );
+  // The trigger badge switches to "runAt" for one-shots.
+  assert.match(html, />runAt</);
+  // The trigger label includes the runAt timestamp.
+  assert.match(html, /one-shot: 2025-06-01 00:00 UTC/);
+});
+
+test("ScheduleRow shows the disabled badge for a paused schedule", () => {
+  const html = renderRow(withProject(schedule({ enabled: false }), PROJECT));
+  assert.match(html, />disabled</);
+});
+
+test("ScheduleRow shows the last run timestamp when present", () => {
+  const html = renderRow(
+    withProject(
+      schedule({ lastRunAt: "2025-04-30T09:00:00.000Z" }),
+      PROJECT
+    )
+  );
+  assert.match(html, /last: 2025-04-30 09:00 UTC/);
+});
+
+test("ScheduleRow surfaces lastError inline when the last fire failed", () => {
+  const html = renderRow(
+    withProject(
+      schedule({ lastError: "Invalid cron: foo bar baz" }),
+      PROJECT
+    )
+  );
+  assert.match(html, /Invalid cron: foo bar baz/);
+});
+
+test("ScheduleRow exposes the enable toggle, runs link, and delete control", () => {
+  const html = renderRow(withProject(schedule(), PROJECT));
+  assert.match(html, /data-testid="schedule-toggle-sched-1"/);
+  assert.match(html, /data-testid="schedule-runs-sched-1"/);
+  assert.match(html, /data-testid="schedule-delete-sched-1"/);
+});
+
+test("ScheduleRow renders a spinner in place of the switch while toggling", () => {
+  const html = renderRow(withProject(schedule(), PROJECT), { toggling: true });
+  // The switch testid is gone while a toggle is in flight; the spinner
+  // takes its place so users see that the action is pending.
+  assert.doesNotMatch(html, /data-testid="schedule-toggle-sched-1"/);
+  assert.match(html, /animate-spin/);
+});
+
+test("ScheduleRow shows the correct project badge per row in a cross-project list", () => {
+  const a = renderRow(withProject(schedule({ id: "sched-a" }), PROJECT));
+  const b = renderRow(withProject(schedule({ id: "sched-b" }), PROJECT_2));
+  assert.match(a, />Anita</);
+  assert.doesNotMatch(a, />Germini</);
+  assert.match(b, />Germini</);
+  assert.doesNotMatch(b, />Anita</);
+});
+
+// ---------------------------------------------------------------------------
+// 2. Create happy path — `CreateScheduleForm`
+// ---------------------------------------------------------------------------
+
+function renderForm(
+  options: {
+    projects?: Project[];
+    projectId?: string;
+    worktrees?: Worktree[];
+    worktreeId?: string;
+    worktreesLoading?: boolean;
+    prompt?: string;
+    triggerType?: "runAt" | "cron";
+    runAt?: string;
+    cron?: string;
+    timezone?: string;
+    error?: string | null;
+  } = {}
+): string {
+  return renderToStaticMarkup(
+    <CreateScheduleForm
+      projects={options.projects ?? [PROJECT, PROJECT_2]}
+      projectId={options.projectId ?? PROJECT.id}
+      onProjectChange={NOOP_STR}
+      worktrees={options.worktrees ?? WORKTREES}
+      worktreeId={options.worktreeId ?? WORKTREES[0].id}
+      onWorktreeChange={NOOP_STR}
+      worktreesLoading={options.worktreesLoading ?? false}
+      prompt={options.prompt ?? ""}
+      onPromptChange={NOOP_STR}
+      triggerType={options.triggerType ?? "runAt"}
+      onTriggerTypeChange={NOOP_TRIGGER}
+      runAt={options.runAt ?? ""}
+      onRunAtChange={NOOP_STR}
+      cron={options.cron ?? ""}
+      onCronChange={NOOP_STR}
+      timezone={options.timezone ?? "UTC"}
+      onTimezoneChange={NOOP_STR}
+      error={options.error ?? null}
+    />,
+  );
+}
+
+test("CreateScheduleForm renders the project and worktree selectors populated from props", () => {
+  const html = renderForm();
+  assert.match(html, /data-testid="schedule-form-project"/);
+  assert.match(html, /data-testid="schedule-form-worktree"/);
+  // The project select lists every project the caller passed in.
+  assert.match(html, /<option value="project-1"[^>]*>Anita<\/option>/);
+  assert.match(html, /<option value="project-2"[^>]*>Germini<\/option>/);
+  // The worktree select lists the worktrees for the selected project.
+  assert.match(html, /<option value="wt-1"[^>]*>main<\/option>/);
+  assert.match(html, /<option value="wt-2"[^>]*>feature<\/option>/);
+});
+
+test("CreateScheduleForm renders the prompt textarea and trigger toggle", () => {
+  const html = renderForm();
+  assert.match(html, /data-testid="schedule-form-prompt"/);
+  assert.match(html, /data-testid="schedule-form-trigger-runAt"/);
+  assert.match(html, /data-testid="schedule-form-trigger-cron"/);
+});
+
+test("CreateScheduleForm defaults to a one-shot datetime-local input", () => {
+  const html = renderForm();
+  assert.match(html, /data-testid="schedule-form-runAt"/);
+  assert.match(html, /type="datetime-local"/);
+  // The cron field is only rendered when the user picks "Recurring".
+  assert.doesNotMatch(html, /data-testid="schedule-form-cron"/);
+});
+
+test("CreateScheduleForm renders the cron expression and timezone fields when trigger is cron", () => {
+  const html = renderForm({ triggerType: "cron" });
+  assert.match(html, /data-testid="schedule-form-cron"/);
+  assert.match(html, /data-testid="schedule-form-timezone"/);
+  // The one-shot input is gone.
+  assert.doesNotMatch(html, /data-testid="schedule-form-runAt"/);
+});
+
+test("CreateScheduleForm renders an empty-state message when no projects exist", () => {
+  const html = renderForm({ projects: [], projectId: "" });
+  assert.match(html, /No projects available/);
+});
+
+test("CreateScheduleForm renders a loading state on the worktree select", () => {
+  const html = renderForm({ worktreesLoading: true });
+  assert.match(html, /Loading worktrees/);
+});
+
+test("CreateScheduleForm surfaces server-side validation errors inline", () => {
+  const html = renderForm({ error: "Invalid cron expression foo" });
+  assert.match(html, /data-testid="schedule-form-error"/);
+  assert.match(html, /Invalid cron expression foo/);
+});
+
+// ---------------------------------------------------------------------------
+// 3. Delete confirmation — the section mounts an `AlertDialog`
+// ---------------------------------------------------------------------------
+
+test("SchedulesSection renders the new-schedule button and the section root in static markup", () => {
+  // The list and runs drawer are populated async, so the static markup
+  // shows the empty/loading state. What we *can* assert statically is the
+  // always-present entry point and the test id hooks.
+  const html = renderToStaticMarkup(<SchedulesSection />);
+  assert.match(html, /data-testid="schedule-new"/);
+  // Confirm the section does not require a project id (the cross-project
+  // view must work even before any project is selected).
+  assert.doesNotThrow(() => renderToStaticMarkup(<SchedulesSection />));
+});
+
+test("SchedulesSection mounts a delete confirm action via the AlertDialog flow", async () => {
+  // The destructive confirm action is rendered as part of the
+  // `AlertDialogAction` inside the section's `AlertDialog`. The
+  // dialog uses a portal that does not render in SSR, so we can't
+  // observe the markup via `renderToStaticMarkup` directly. Instead
+  // we lock in the public data-testid contract by reading the
+  // section source — this is the same hook future browser-driven
+  // automation will use, and it stays stable across refactors of
+  // the surrounding JSX.
+  const { readFileSync } = await import("node:fs");
+  const { fileURLToPath } = await import("node:url");
+  const source = readFileSync(
+    fileURLToPath(new URL("../schedules-section.tsx", import.meta.url)),
+    "utf8",
+  );
+  // Confirm both the row-level delete hook and the confirm-action hook
+  // exist in the source so the click → confirm → DELETE flow is wired.
+  assert.match(
+    source,
+    /data-testid="schedule-delete-/,
+    "row-level delete testid must remain stable",
+  );
+  assert.match(
+    source,
+    /data-testid="schedule-delete-confirm"/,
+    "destructive confirm action must remain stable",
+  );
+  // The confirm action is only fired after the user clicks
+  // `AlertDialogAction`, and the resulting `handleDelete` call hits
+  // DELETE on the schedule id. Verify the wiring by looking for the
+  // matching DELETE call.
+  assert.match(
+    source,
+    /deleteSchedule\(schedule\.projectId, schedule\.id\)/,
+    "confirm must invoke deleteSchedule with the row's projectId and id",
+  );
+});
+
+// ---------------------------------------------------------------------------
+// 4. Enable / disable toggle wiring
+// ---------------------------------------------------------------------------
+
+test("ScheduleRow renders a Switch whose data-slot is present in both enabled and disabled states", () => {
+  const enabledHtml = renderRow(withProject(schedule({ enabled: true }), PROJECT));
+  assert.match(enabledHtml, /data-testid="schedule-toggle-sched-1"/);
+  assert.match(enabledHtml, /data-slot="switch"/);
+
+  const disabledHtml = renderRow(withProject(schedule({ enabled: false }), PROJECT));
+  // The same testid is present; the disabled state is reflected via
+  // base-ui's data-checked / data-unchecked attributes and the
+  // "disabled" badge.
+  assert.match(disabledHtml, /data-slot="switch"/);
+  assert.match(disabledHtml, />disabled</);
+});
+
+// ---------------------------------------------------------------------------
+// 5. P2 review fixes (issue #303 cross-project hardening)
+// ---------------------------------------------------------------------------
+
+test("fetchAllSchedules contract exposes failed projects alongside the merged list", async () => {
+  // Issue #303 P2 review: per-project failures must not be silently
+  // dropped. Verify the API surface carries a `failedProjectIds`
+  // array so the section can render a partial-load banner.
+  const { readFileSync } = await import("node:fs");
+  const { fileURLToPath } = await import("node:url");
+  const source = readFileSync(
+    fileURLToPath(new URL("../../api.ts", import.meta.url)),
+    "utf8",
+  );
+  assert.match(
+    source,
+    /export interface AllSchedulesResult[\s\S]*failedProjectIds: string\[\]/,
+    "AllSchedulesResult must carry failedProjectIds",
+  );
+  // The new return type and the catch arm that collects failures.
+  assert.match(
+    source,
+    /failedProjectIds\.push\(entry\.project\.id\)/,
+    "fetchAllSchedules must collect per-project failures",
+  );
+});
+
+test("SchedulesSection renders a partial-load banner when fetchAllSchedules reports failed projects", async () => {
+  // We can't drive a fetch via `renderToStaticMarkup`, but the
+  // banner is rendered when `failedProjectNames` is non-empty. The
+  // easiest way to exercise that without a real DOM is to read the
+  // section source and confirm the rendering branch and the
+  // testid hook are still in place — same approach we use for the
+  // delete confirm action.
+  const { readFileSync } = await import("node:fs");
+  const { fileURLToPath } = await import("node:url");
+  const source = readFileSync(
+    fileURLToPath(new URL("../schedules-section.tsx", import.meta.url)),
+    "utf8",
+  );
+  assert.match(
+    source,
+    /data-testid="schedule-partial-error"/,
+    "partial-load banner testid must remain stable",
+  );
+  assert.match(
+    source,
+    /failedProjectNames\.length > 0/,
+    "partial-load banner must be conditionally rendered",
+  );
+});
+
+test("Run-link click carries the row's projectId so deep-links land in the right project", async () => {
+  // P2 review on #303: in the cross-project view, opening a run
+  // for a non-active project was navigating to the wrong session
+  // because the click handler didn't include projectId in the
+  // payload. The onClick is inside the Dialog body so we can't
+  // observe it in static markup, but the source contract is the
+  // public hook — keep it pinned.
+  const { readFileSync } = await import("node:fs");
+  const { fileURLToPath } = await import("node:url");
+  const source = readFileSync(
+    fileURLToPath(new URL("../schedules-section.tsx", import.meta.url)),
+    "utf8",
+  );
+  // Both halves of the fix must remain in place: the onClick must
+  // pass `projectId: runsFor.projectId`, and the App handler must
+  // prefer `params.projectId` over `activeProjectId`.
+  assert.match(
+    source,
+    /projectId: runsFor\.projectId/,
+    "run onClick must include projectId",
+  );
+  const appSource = readFileSync(
+    fileURLToPath(new URL("../../App.tsx", import.meta.url)),
+    "utf8",
+  );
+  assert.match(
+    appSource,
+    /projectId = params\.projectId \?\? activeProjectId/,
+    "App handler must prefer payload projectId over activeProjectId",
+  );
+});
+
+test("openRuns drops stale responses via a monotonic request id", async () => {
+  // P3 review on #303: if the user clicks Runs for A and then B
+  // before A's request resolves, A's late response would otherwise
+  // overwrite B's runs dialog. The fix bumps a ref on every call
+  // and the async fetcher bails out if a newer request has started.
+  const { readFileSync } = await import("node:fs");
+  const { fileURLToPath } = await import("node:url");
+  const source = readFileSync(
+    fileURLToPath(new URL("../schedules-section.tsx", import.meta.url)),
+    "utf8",
+  );
+  assert.match(
+    source,
+    /runsRequestIdRef\.current = requestId/,
+    "openRuns must bump the request id",
+  );
+  assert.match(
+    source,
+    /if \(runsRequestIdRef\.current !== requestId\) return/,
+    "async fetcher must bail out on stale responses",
+  );
+});
diff --git a/client/src/components/schedules-section.tsx b/client/src/components/schedules-section.tsx
new file mode 100644
index 00000000..ca3bb7e7
--- /dev/null
+++ b/client/src/components/schedules-section.tsx
@@ -0,0 +1,964 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import {
+  AlertTriangle,
+  Check,
+  Clock,
+  Loader2,
+  Plus,
+  Trash2,
+  X,
+} from "lucide-react";
+import { Button } from "@/components/ui/button";
+import { Switch } from "@/components/ui/switch";
+import { Badge } from "@/components/ui/badge";
+import {
+  Dialog,
+  DialogContent,
+  DialogHeader,
+  DialogTitle,
+  DialogDescription,
+  DialogFooter,
+} from "@/components/ui/dialog";
+import {
+  AlertDialog,
+  AlertDialogContent,
+  AlertDialogHeader,
+  AlertDialogTitle,
+  AlertDialogDescription,
+  AlertDialogFooter,
+  AlertDialogCancel,
+  AlertDialogAction,
+} from "@/components/ui/alert-dialog";
+import {
+  createSchedule,
+  deleteSchedule,
+  fetchAllSchedules,
+  fetchProjects,
+  fetchScheduleRuns,
+  fetchWorktrees,
+  setScheduleEnabled,
+  type Project,
+  type Schedule,
+  type ScheduleInput,
+  type ScheduleRun,
+  type ScheduleWithProject,
+  type Worktree,
+} from "../api.ts";
+
+/*
+ * Settings panel for scheduled sessions (issue #303).
+ *
+ * Originally scoped to the active project, but the user-facing review
+ * wanted every project's schedules in one place — the section is the
+ * one place in the app where a "what's about to fire?" overview is
+ * useful, and forcing a project selection up front hides the rest.
+ * The server doesn't expose a cross-project list (the CLI is still
+ * the source of truth for the data model), so this component fans
+ * out client-side: list projects, then list each project's
+ * schedules, then merge.
+ *
+ * Each row carries its `projectId` and a denormalised `projectName`
+ * so the toggle / delete / runs handlers don't need a separate
+ * lookup, and the create form has its own project + worktree picker.
+ *
+ * Editing an existing schedule's trigger is intentionally not exposed
+ * — the server has no PUT route for it and the issue lists it as a
+ * follow-up. The form below requires either a one-shot ISO timestamp
+ * (`runAt`) or a cron expression plus timezone; the server validates
+ * both and surfaces any failure as a 400, which we render inline.
+ *
+ * Session deep links from a `firedAt` run: the row exposes the
+ * `sessionId` as a button that asks the parent to switch views to
+ * that session via the `onOpenSession` prop. Runs only carry the
+ * bare id (no `controller://` envelope) so we forward a derived
+ * target including the worktree id.
+ */
+
+const COMMON_TIMEZONES = [
+  "UTC",
+  "America/Los_Angeles",
+  "America/Denver",
+  "America/Chicago",
+  "America/New_York",
+  "America/Sao_Paulo",
+  "Europe/London",
+  "Europe/Berlin",
+  "Europe/Paris",
+  "Europe/Madrid",
+  "Africa/Johannesburg",
+  "Asia/Dubai",
+  "Asia/Kolkata",
+  "Asia/Singapore",
+  "Asia/Tokyo",
+  "Asia/Seoul",
+  "Australia/Sydney",
+  "Pacific/Auckland",
+];
+
+interface SchedulesSectionProps {
+  /**
+   * Switch the main view to the given session. Used by the runs panel
+   * to deep-link a fired schedule's resulting session. Optional — the
+   * section still works without it, the link just becomes a no-op.
+   *
+   * `projectId` is required to deep-link correctly: the Schedules
+   * section is cross-project, so the run we clicked may belong to
+   * any project — not necessarily the active one. Callers should
+   * always pass it; it's optional only for backwards compatibility
+   * with future single-project sections. (P2 review on #303.)
+   */
+  onOpenSession?: (params: {
+    sessionId: string;
+    worktreeId?: string;
+    projectId?: string;
+  }) => void;
+}
+
+export function SchedulesSection({ onOpenSession }: SchedulesSectionProps) {
+  const [schedules, setSchedules] = useState<ScheduleWithProject[]>([]);
+  const [projects, setProjects] = useState<Project[]>([]);
+  const [worktreesByProject, setWorktreesByProject] = useState<
+    Record<string, Worktree[]>
+  >({});
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  // Names of projects whose /schedules fetch failed this round.
+  // Surfaces a non-fatal banner so the user can see *something*
+  // failed even when the list isn't empty (P2 review on #303).
+  const [failedProjectNames, setFailedProjectNames] = useState<string[]>([]);
+  const [createOpen, setCreateOpen] = useState(false);
+  const [deleting, setDeleting] = useState<ScheduleWithProject | null>(null);
+  const [runsFor, setRunsFor] = useState<ScheduleWithProject | null>(null);
+  const [runs, setRuns] = useState<ScheduleRun[]>([]);
+  const [runsLoading, setRunsLoading] = useState(false);
+  const [runsError, setRunsError] = useState<string | null>(null);
+  const [togglingId, setTogglingId] = useState<string | null>(null);
+  // Monotonic id for the most recent Runs request. The async fetcher
+  // captures its own id and bails out of the setState calls if a
+  // newer request has started (P3 review on #303 — slow A response
+  // would otherwise clobber B's dialog).
+  const runsRequestIdRef = useRef(0);
+
+  const load = useCallback(async () => {
+    setLoading(true);
+    try {
+      const [allSchedules, projectList] = await Promise.all([
+        fetchAllSchedules(true),
+        fetchProjects(),
+      ]);
+      setSchedules(allSchedules.schedules);
+      setProjects(projectList);
+      setFailedProjectNames(
+        allSchedules.failedProjectIds.map(
+          (id) => projectList.find((p) => p.id === id)?.name ?? id
+        ),
+      );
+      setError(null);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to load schedules");
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+
+  useEffect(() => {
+    void load();
+  }, [load]);
+
+  // Lazily load worktrees for a project on demand (the create dialog
+  // needs them; the list view doesn't). Cached per project id so a
+  // user picking the same project twice in a row doesn't re-fetch.
+  const worktreesFor = useCallback(
+    async (projectId: string): Promise<Worktree[]> => {
+      const cached = worktreesByProject[projectId];
+      if (cached) return cached;
+      const list = await fetchWorktrees(projectId);
+      setWorktreesByProject((current) => ({ ...current, [projectId]: list }));
+      return list;
+    },
+    [worktreesByProject]
+  );
+
+  const handleToggle = useCallback(
+    async (schedule: ScheduleWithProject, enabled: boolean) => {
+      setTogglingId(schedule.id);
+      try {
+        const updated = await setScheduleEnabled(
+          schedule.projectId,
+          schedule.id,
+          enabled
+        );
+        setSchedules((current) =>
+          current.map((entry) =>
+            entry.id === updated.id
+              ? { ...updated, projectName: entry.projectName }
+              : entry
+          )
+        );
+      } catch (err) {
+        setError(
+          err instanceof Error ? err.message : "Failed to update schedule"
+        );
+      } finally {
+        setTogglingId(null);
+      }
+    },
+    []
+  );
+
+  const handleDelete = useCallback(
+    async (schedule: ScheduleWithProject) => {
+      try {
+        await deleteSchedule(schedule.projectId, schedule.id);
+        setSchedules((current) =>
+          current.filter((entry) => entry.id !== schedule.id)
+        );
+        if (runsFor?.id === schedule.id) {
+          setRunsFor(null);
+          setRuns([]);
+        }
+      } catch (err) {
+        setError(
+          err instanceof Error ? err.message : "Failed to delete schedule"
+        );
+      }
+    },
+    [runsFor]
+  );
+
+  const openRuns = useCallback((schedule: ScheduleWithProject) => {
+    setRunsFor(schedule);
+    setRuns([]);
+    setRunsError(null);
+    setRunsLoading(true);
+    // Bump the request id so a slow earlier response can't overwrite
+    // a newer one. The IIFE captures its own id and only writes if it
+    // still matches. (P3 review on #303.)
+    const requestId = runsRequestIdRef.current + 1;
+    runsRequestIdRef.current = requestId;
+    void (async () => {
+      try {
+        const list = await fetchScheduleRuns(schedule.projectId, schedule.id);
+        if (runsRequestIdRef.current !== requestId) return;
+        setRuns(list);
+      } catch (err) {
+        if (runsRequestIdRef.current !== requestId) return;
+        setRunsError(
+          err instanceof Error ? err.message : "Failed to load runs"
+        );
+      } finally {
+        if (runsRequestIdRef.current === requestId) {
+          setRunsLoading(false);
+        }
+      }
+    })();
+  }, []);
+
+  return (
+    <div className="space-y-3">
+      <div className="flex items-center justify-end">
+        <Button
+          size="sm"
+          onClick={() => setCreateOpen(true)}
+          data-testid="schedule-new"
+          className="gap-1"
+        >
+          <Plus className="h-3.5 w-3.5" />
+          New schedule
+        </Button>
+      </div>
+
+      {loading && schedules.length === 0 && (
+        <div className="flex items-center gap-2 py-4 text-sm text-muted-foreground">
+          <Loader2 className="h-4 w-4 animate-spin" />
+          Loading schedules...
+        </div>
+      )}
+
+      {error && (
+        <div
+          className="rounded-md border border-destructive/30 bg-destructive/10 px-3 py-2 text-xs text-destructive"
+          data-testid="schedule-error"
+        >
+          {error}
+        </div>
+      )}
+
+      {failedProjectNames.length > 0 && (
+        <div
+          className="flex items-start gap-2 rounded-md border border-amber-500/40 bg-amber-500/10 px-3 py-2 text-xs text-amber-200"
+          data-testid="schedule-partial-error"
+        >
+          <AlertTriangle className="mt-0.5 h-3.5 w-3.5 shrink-0" />
+          <div>
+            <div className="font-medium">
+              Couldn&apos;t load schedules from{" "}
+              {failedProjectNames.length === 1
+                ? "1 project"
+                : `${failedProjectNames.length} projects`}
+            </div>
+            <div className="mt-0.5 break-words text-amber-200/80">
+              {failedProjectNames.join(", ")}
+            </div>
+          </div>
+        </div>
+      )}
+
+      <div className="space-y-2">
+        {schedules.map((schedule) => (
+          <ScheduleRow
+            key={`${schedule.projectId}:${schedule.id}`}
+            schedule={schedule}
+            onToggle={(enabled) => void handleToggle(schedule, enabled)}
+            onDelete={() => setDeleting(schedule)}
+            onViewRuns={() => openRuns(schedule)}
+            toggling={togglingId === schedule.id}
+          />
+        ))}
+
+        {!loading && schedules.length === 0 && (
+          <div
+            className="rounded-lg border border-dashed border-border p-6 text-center"
+            data-testid="schedule-empty"
+          >
+            <p className="text-sm text-muted-foreground">
+              No schedules yet. Create one to start a session later or on a
+              recurring basis.
+            </p>
+          </div>
+        )}
+      </div>
+
+      <CreateScheduleDialog
+        open={createOpen}
+        onOpenChange={setCreateOpen}
+        projects={projects}
+        loadWorktrees={worktreesFor}
+        onCreated={async (created) => {
+          setCreateOpen(false);
+          // The cross-project list re-fetches from the server, so the
+          // new row's `projectName` is denormalised consistently.
+          await load();
+          void created;
+        }}
+      />
+
+      <AlertDialog
+        open={deleting !== null}
+        onOpenChange={(open) => {
+          if (!open) setDeleting(null);
+        }}
+      >
+        <AlertDialogContent>
+          <AlertDialogHeader>
+            <AlertDialogTitle>Delete this schedule?</AlertDialogTitle>
+            <AlertDialogDescription>
+              {deleting && (
+                <>
+                  Schedule on <span className="font-medium">{deleting.projectName}</span>{" "}
+                  and its run history will be removed. This cannot be undone.
+                </>
+              )}
+            </AlertDialogDescription>
+          </AlertDialogHeader>
+          <AlertDialogFooter>
+            <AlertDialogCancel>Cancel</AlertDialogCancel>
+            <AlertDialogAction
+              variant="destructive"
+              data-testid="schedule-delete-confirm"
+              onClick={() => {
+                const target = deleting;
+                setDeleting(null);
+                if (target) void handleDelete(target);
+              }}
+            >
+              Delete
+            </AlertDialogAction>
+          </AlertDialogFooter>
+        </AlertDialogContent>
+      </AlertDialog>
+
+      <Dialog
+        open={runsFor !== null}
+        onOpenChange={(open) => {
+          if (!open) {
+            setRunsFor(null);
+            setRuns([]);
+            setRunsError(null);
+          }
+        }}
+      >
+        <DialogContent className="max-w-xl">
+          <DialogHeader>
+            <DialogTitle className="flex items-center gap-2">
+              <Clock className="h-4 w-4" />
+              Runs
+            </DialogTitle>
+            {runsFor && (
+              <DialogDescription>
+                {runsFor.projectName} ·{" "}
+                {runsFor.cron
+                  ? `cron=${runsFor.cron} (${runsFor.timezone})`
+                  : runsFor.runAt
+                    ? `one-shot at ${runsFor.runAt}`
+                    : ""}
+              </DialogDescription>
+            )}
+          </DialogHeader>
+          {runsLoading ? (
+            <div className="flex items-center gap-2 py-6 text-sm text-muted-foreground">
+              <Loader2 className="h-4 w-4 animate-spin" />
+              Loading runs...
+            </div>
+          ) : runsError ? (
+            <div className="rounded-md border border-destructive/30 bg-destructive/10 px-3 py-2 text-xs text-destructive">
+              {runsError}
+            </div>
+          ) : runs.length === 0 ? (
+            <div className="rounded-lg border border-dashed border-border p-4 text-center text-sm text-muted-foreground">
+              No runs yet.
+            </div>
+          ) : (
+            <div className="max-h-80 overflow-y-auto rounded-md border border-border divide-y divide-border">
+              {runs.map((run, idx) => (
+                <div
+                  key={`${run.firedAt}-${idx}`}
+                  className="flex flex-col gap-1 px-3 py-2 text-xs"
+                >
+                  <div className="flex items-center justify-between gap-2">
+                    <span className="font-mono text-foreground">
+                      {formatDate(run.firedAt)}
+                    </span>
+                    {run.error ? (
+                      <Badge variant="destructive" className="text-[10px]">
+                        error
+                      </Badge>
+                    ) : run.sessionId ? (
+                      <button
+                        type="button"
+                        className="rounded font-mono text-primary hover:underline disabled:no-underline disabled:opacity-50"
+                        data-testid={`schedule-run-session-${idx}`}
+                        disabled={!onOpenSession}
+                        onClick={() => {
+                          if (!onOpenSession || !run.sessionId || !runsFor) return;
+                          onOpenSession({
+                            sessionId: run.sessionId,
+                            worktreeId: runsFor.worktreeId,
+                            projectId: runsFor.projectId,
+                          });
+                        }}
+                        title={
+                          onOpenSession
+                            ? "Open this session"
+                            : "Session deep-link unavailable"
+                        }
+                      >
+                        {run.sessionId.slice(0, 8)}
+                      </button>
+                    ) : (
+                      <Badge variant="outline" className="text-[10px]">
+                        no session
+                      </Badge>
+                    )}
+                  </div>
+                  {run.error && (
+                    <div className="break-words text-destructive">
+                      {run.error}
+                    </div>
+                  )}
+                </div>
+              ))}
+            </div>
+          )}
+          <DialogFooter>
+            <Button variant="outline" onClick={() => setRunsFor(null)}>
+              Close
+            </Button>
+          </DialogFooter>
+        </DialogContent>
+      </Dialog>
+    </div>
+  );
+}
+
+interface ScheduleRowProps {
+  schedule: ScheduleWithProject;
+  toggling: boolean;
+  onToggle: (enabled: boolean) => void;
+  onDelete: () => void;
+  onViewRuns: () => void;
+}
+
+export function ScheduleRow({
+  schedule,
+  toggling,
+  onToggle,
+  onDelete,
+  onViewRuns,
+}: ScheduleRowProps) {
+  const triggerLabel = schedule.cron
+    ? `cron: ${schedule.cron}`
+    : schedule.runAt
+      ? `one-shot: ${formatDate(schedule.runAt)}`
+      : "no trigger";
+  return (
+    <div
+      className="flex flex-col gap-2 rounded-lg border border-border p-3 md:flex-row md:items-start md:gap-3"
+      data-testid={`schedule-row-${schedule.id}`}
+    >
+      <div className="min-w-0 flex-1">
+        <div className="flex flex-wrap items-center gap-2">
+          <Badge variant="outline" className="text-[10px]" title="Project">
+            {schedule.projectName}
+          </Badge>
+          <Badge variant="secondary" className="text-[10px]">
+            {schedule.cron ? "cron" : "runAt"}
+          </Badge>
+          <Badge variant="secondary" className="text-[10px]">
+            {schedule.source}
+          </Badge>
+          {!schedule.enabled && (
+            <Badge variant="destructive" className="text-[10px]">
+              disabled
+            </Badge>
+          )}
+        </div>
+        <p className="mt-1 line-clamp-2 break-words text-xs text-foreground">
+          {schedule.prompt}
+        </p>
+        <div className="mt-1 flex flex-wrap gap-x-3 gap-y-0.5 text-[11px] text-muted-foreground">
+          <span>worktree: {schedule.worktreeId.slice(0, 8)}</span>
+          <span>{triggerLabel}</span>
+          <span>next: {formatDate(schedule.nextRunAt)}</span>
+          {schedule.lastRunAt && (
+            <span>last: {formatDate(schedule.lastRunAt)}</span>
+          )}
+        </div>
+        {schedule.lastError && (
+          <div className="mt-1 flex items-start gap-1 rounded border border-destructive/30 bg-destructive/10 px-2 py-1 text-[11px] text-destructive">
+            <AlertTriangle className="mt-0.5 h-3 w-3 shrink-0" />
+            <span className="break-words">{schedule.lastError}</span>
+          </div>
+        )}
+      </div>
+      <div className="flex shrink-0 items-center gap-2">
+        <Button
+          size="sm"
+          variant="ghost"
+          data-testid={`schedule-runs-${schedule.id}`}
+          onClick={onViewRuns}
+          className="gap-1 text-xs"
+        >
+          <Clock className="h-3.5 w-3.5" />
+          Runs
+        </Button>
+        <label className="flex items-center gap-1.5 text-xs text-muted-foreground">
+          <span className="sr-only">Enabled</span>
+          {toggling ? (
+            <Loader2 className="h-3.5 w-3.5 animate-spin text-muted-foreground" />
+          ) : (
+            <Switch
+              checked={schedule.enabled}
+              onCheckedChange={(checked) => onToggle(checked)}
+              data-testid={`schedule-toggle-${schedule.id}`}
+            />
+          )}
+        </label>
+        <Button
+          size="icon-sm"
+          variant="ghost"
+          data-testid={`schedule-delete-${schedule.id}`}
+          onClick={onDelete}
+          className="text-muted-foreground hover:text-destructive"
+          title="Delete schedule"
+        >
+          <Trash2 className="h-3.5 w-3.5" />
+        </Button>
+      </div>
+    </div>
+  );
+}
+
+interface CreateScheduleDialogProps {
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  projects: Project[];
+  loadWorktrees: (projectId: string) => Promise<Worktree[]>;
+  onCreated: (schedule: Schedule) => void | Promise<void>;
+}
+
+export function CreateScheduleDialog({
+  open,
+  onOpenChange,
+  projects,
+  loadWorktrees,
+  onCreated,
+}: CreateScheduleDialogProps) {
+  const [projectId, setProjectId] = useState("");
+  const [worktreeId, setWorktreeId] = useState("");
+  const [worktrees, setWorktrees] = useState<Worktree[]>([]);
+  const [worktreesLoading, setWorktreesLoading] = useState(false);
+  const [prompt, setPrompt] = useState("");
+  const [triggerType, setTriggerType] = useState<"runAt" | "cron">("runAt");
+  const [runAt, setRunAt] = useState("");
+  const [cron, setCron] = useState("");
+  const [timezone, setTimezone] = useState("UTC");
+  const [saving, setSaving] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  // Reset the form on close, and seed the project picker the first time
+  // the dialog opens with a real project list available.
+  useEffect(() => {
+    if (!open) {
+      setProjectId("");
+      setWorktreeId("");
+      setWorktrees([]);
+      setPrompt("");
+      setTriggerType("runAt");
+      setRunAt("");
+      setCron("");
+      setTimezone("UTC");
+      setError(null);
+      setSaving(false);
+      return;
+    }
+    setProjectId((current) => current || projects[0]?.id || "");
+  }, [open, projects]);
+
+  // Load the worktrees for the currently-selected project whenever it
+  // changes (or the dialog opens). Worktrees are cached in the parent's
+  // `loadWorktrees` so re-picking the same project is instant.
+  useEffect(() => {
+    if (!open || !projectId) {
+      setWorktrees([]);
+      return;
+    }
+    let cancelled = false;
+    setWorktreesLoading(true);
+    void (async () => {
+      try {
+        const list = await loadWorktrees(projectId);
+        if (!cancelled) {
+          setWorktrees(list);
+          // Reset the worktree selection if it doesn't belong to the
+          // newly-loaded project.
+          setWorktreeId((current) =>
+            list.some((w) => w.id === current) ? current : list[0]?.id ?? ""
+          );
+        }
+      } catch (err) {
+        if (!cancelled) {
+          setError(
+            err instanceof Error ? err.message : "Failed to load worktrees"
+          );
+        }
+      } finally {
+        if (!cancelled) setWorktreesLoading(false);
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [open, projectId, loadWorktrees]);
+
+  const canSave = useMemo(() => {
+    if (!projectId || !worktreeId || !prompt.trim()) return false;
+    if (triggerType === "runAt") return runAt.trim().length > 0;
+    return cron.trim().length > 0;
+  }, [projectId, worktreeId, prompt, triggerType, runAt, cron]);
+
+  const handleSubmit = async () => {
+    setSaving(true);
+    setError(null);
+    try {
+      const body: ScheduleInput = {
+        worktreeId,
+        prompt: prompt.trim(),
+        createdBy: "ui",
+      };
+      if (triggerType === "runAt") {
+        const parsed = new Date(runAt);
+        if (Number.isNaN(parsed.getTime())) {
+          throw new Error("Invalid date — pick a valid timestamp");
+        }
+        body.runAt = parsed.toISOString();
+      } else {
+        body.cron = cron.trim();
+        body.timezone = timezone;
+      }
+      const created = await createSchedule(projectId, body);
+      await onCreated(created);
+    } catch (err) {
+      setError(
+        err instanceof Error ? err.message : "Failed to create schedule"
+      );
+    } finally {
+      setSaving(false);
+    }
+  };
+
+  return (
+    <Dialog open={open} onOpenChange={onOpenChange}>
+      <DialogContent className="max-w-lg">
+        <DialogHeader>
+          <DialogTitle>New schedule</DialogTitle>
+          <DialogDescription>
+            Start a session on a worktree at a specific time (one-shot) or
+            on a recurring cron expression.
+          </DialogDescription>
+        </DialogHeader>
+        <CreateScheduleForm
+          projects={projects}
+          projectId={projectId}
+          onProjectChange={setProjectId}
+          worktrees={worktrees}
+          worktreeId={worktreeId}
+          onWorktreeChange={setWorktreeId}
+          worktreesLoading={worktreesLoading}
+          prompt={prompt}
+          onPromptChange={setPrompt}
+          triggerType={triggerType}
+          onTriggerTypeChange={setTriggerType}
+          runAt={runAt}
+          onRunAtChange={setRunAt}
+          cron={cron}
+          onCronChange={setCron}
+          timezone={timezone}
+          onTimezoneChange={setTimezone}
+          error={error}
+        />
+        <DialogFooter>
+          <Button
+            type="button"
+            variant="outline"
+            onClick={() => onOpenChange(false)}
+            disabled={saving}
+          >
+            <X className="h-3.5 w-3.5" />
+            Cancel
+          </Button>
+          <Button
+            onClick={() => void handleSubmit()}
+            disabled={!canSave || saving}
+            data-testid="schedule-form-save"
+          >
+            {saving ? (
+              <Loader2 className="mr-1.5 h-3.5 w-3.5 animate-spin" />
+            ) : (
+              <Check className="mr-1.5 h-3.5 w-3.5" />
+            )}
+            Create schedule
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+}
+
+interface CreateScheduleFormProps {
+  projects: Project[];
+  projectId: string;
+  onProjectChange: (id: string) => void;
+  worktrees: Worktree[];
+  worktreeId: string;
+  onWorktreeChange: (id: string) => void;
+  worktreesLoading: boolean;
+  prompt: string;
+  onPromptChange: (value: string) => void;
+  triggerType: "runAt" | "cron";
+  onTriggerTypeChange: (value: "runAt" | "cron") => void;
+  runAt: string;
+  onRunAtChange: (value: string) => void;
+  cron: string;
+  onCronChange: (value: string) => void;
+  timezone: string;
+  onTimezoneChange: (value: string) => void;
+  error: string | null;
+}
+
+/**
+ * Form body for the create-schedule dialog. Extracted from the dialog
+ * wrapper so the field markup is observable to `renderToStaticMarkup`
+ * (Dialog uses a portal that does not render in SSR) and so the
+ * regression test can assert on the field-level test ids directly.
+ */
+export function CreateScheduleForm({
+  projects,
+  projectId,
+  onProjectChange,
+  worktrees,
+  worktreeId,
+  onWorktreeChange,
+  worktreesLoading,
+  prompt,
+  onPromptChange,
+  triggerType,
+  onTriggerTypeChange,
+  runAt,
+  onRunAtChange,
+  cron,
+  onCronChange,
+  timezone,
+  onTimezoneChange,
+  error,
+}: CreateScheduleFormProps) {
+  return (
+    <div className="space-y-3">
+      <div>
+        <label className="mb-1 block text-xs font-medium text-muted-foreground">
+          Project
+        </label>
+        <select
+          value={projectId}
+          onChange={(e) => onProjectChange(e.target.value)}
+          data-testid="schedule-form-project"
+          className="w-full rounded-md border border-border bg-transparent px-3 py-2 text-sm focus:outline-none focus:ring-1 focus:ring-ring"
+          disabled={projects.length === 0}
+        >
+          {projects.length === 0 && (
+            <option value="">No projects available</option>
+          )}
+          {projects.map((p) => (
+            <option key={p.id} value={p.id}>
+              {p.name}
+            </option>
+          ))}
+        </select>
+      </div>
+      <div>
+        <label className="mb-1 block text-xs font-medium text-muted-foreground">
+          Worktree
+        </label>
+        <select
+          value={worktreeId}
+          onChange={(e) => onWorktreeChange(e.target.value)}
+          data-testid="schedule-form-worktree"
+          className="w-full rounded-md border border-border bg-transparent px-3 py-2 text-sm focus:outline-none focus:ring-1 focus:ring-ring"
+          disabled={worktreesLoading || worktrees.length === 0}
+        >
+          {worktreesLoading && <option value="">Loading worktrees…</option>}
+          {!worktreesLoading && worktrees.length === 0 && (
+            <option value="">No worktrees available</option>
+          )}
+          {worktrees.map((w) => (
+            <option key={w.id} value={w.id}>
+              {w.name}
+            </option>
+          ))}
+        </select>
+      </div>
+      <div>
+        <label className="mb-1 block text-xs font-medium text-muted-foreground">
+          Prompt
+        </label>
+        <textarea
+          value={prompt}
+          onChange={(e) => onPromptChange(e.target.value)}
+          rows={3}
+          data-testid="schedule-form-prompt"
+          placeholder="The prompt to send when the schedule fires"
+          className="w-full rounded-md border border-border bg-transparent px-3 py-2 text-sm focus:outline-none focus:ring-1 focus:ring-ring"
+        />
+      </div>
+      <div>
+        <span className="mb-1 block text-xs font-medium text-muted-foreground">
+          Trigger
+        </span>
+        <div className="flex gap-2">
+          <Button
+            type="button"
+            size="sm"
+            variant={triggerType === "runAt" ? "default" : "outline"}
+            onClick={() => onTriggerTypeChange("runAt")}
+            data-testid="schedule-form-trigger-runAt"
+          >
+            One-shot
+          </Button>
+          <Button
+            type="button"
+            size="sm"
+            variant={triggerType === "cron" ? "default" : "outline"}
+            onClick={() => onTriggerTypeChange("cron")}
+            data-testid="schedule-form-trigger-cron"
+          >
+            Recurring
+          </Button>
+        </div>
+      </div>
+      {triggerType === "runAt" ? (
+        <div>
+          <label className="mb-1 block text-xs font-medium text-muted-foreground">
+            Run at (local time)
+          </label>
+          <input
+            type="datetime-local"
+            value={runAt}
+            onChange={(e) => onRunAtChange(e.target.value)}
+            data-testid="schedule-form-runAt"
+            className="w-full rounded-md border border-border bg-transparent px-3 py-2 text-sm focus:outline-none focus:ring-1 focus:ring-ring"
+          />
+        </div>
+      ) : (
+        <div className="space-y-2">
+          <div>
+            <label className="mb-1 block text-xs font-medium text-muted-foreground">
+              Cron expression
+            </label>
+            <input
+              type="text"
+              value={cron}
+              onChange={(e) => onCronChange(e.target.value)}
+              placeholder="*/5 * * * *"
+              data-testid="schedule-form-cron"
+              className="w-full rounded-md border border-border bg-transparent px-3 py-2 font-mono text-sm focus:outline-none focus:ring-1 focus:ring-ring"
+            />
+          </div>
+          <div>
+            <label className="mb-1 block text-xs font-medium text-muted-foreground">
+              Timezone
+            </label>
+            <select
+              value={timezone}
+              onChange={(e) => onTimezoneChange(e.target.value)}
+              data-testid="schedule-form-timezone"
+              className="w-full rounded-md border border-border bg-transparent px-3 py-2 text-sm focus:outline-none focus:ring-1 focus:ring-ring"
+            >
+              {COMMON_TIMEZONES.map((tz) => (
+                <option key={tz} value={tz}>
+                  {tz}
+                </option>
+              ))}
+            </select>
+          </div>
+        </div>
+      )}
+      {error && (
+        <div
+          className="rounded-md border border-destructive/30 bg-destructive/10 px-3 py-2 text-xs text-destructive"
+          data-testid="schedule-form-error"
+        >
+          {error}
+        </div>
+      )}
+    </div>
+  );
+}
+
+/**
+ * Render a date in a stable, short form. We avoid `toLocaleString` so SSR
+ * (static markup) and CSR match — the Settings regression test renders
+ * server-side and a locale-dependent string would fail across machines.
+ */
+function formatDate(iso: string): string {
+  const date = new Date(iso);
+  if (Number.isNaN(date.getTime())) return iso;
+  // YYYY-MM-DD HH:mm in UTC. Compact enough to fit on a row, but precise
+  // enough to disambiguate near-future runs.
+  const pad = (n: number) => String(n).padStart(2, "0");
+  return (
+    `${date.getUTCFullYear()}-${pad(date.getUTCMonth() + 1)}-${pad(
+      date.getUTCDate()
+    )} ` +
+    `${pad(date.getUTCHours())}:${pad(date.getUTCMinutes())} UTC`
+  );
+}
diff --git a/client/src/pages/Settings.tsx b/client/src/pages/Settings.tsx
index 4d81ab8a..f58f7a9f 100644
--- a/client/src/pages/Settings.tsx
+++ b/client/src/pages/Settings.tsx
@@ -4,8 +4,14 @@ import { AgentsSection } from "../components/agents-section.tsx";
 import { IntegrationsSection } from "../components/integrations-section.tsx";
 import { SkillsSection } from "../components/skills-section.tsx";
 import { ShortcutsSection } from "../components/shortcuts-section.tsx";
+import { SchedulesSection } from "../components/schedules-section.tsx";
 
-export type SettingsSection = "agents" | "integrations" | "skills" | "shortcuts";
+export type SettingsSection =
+  | "agents"
+  | "integrations"
+  | "skills"
+  | "shortcuts"
+  | "schedules";
 
 interface SectionSpec {
   id: SettingsSection;
@@ -39,12 +45,40 @@ const SECTIONS: SectionSpec[] = [
     shortLabel: "Shortcuts",
     description: "Customise Controller Mode keyboard shortcuts.",
   },
+  {
+    id: "schedules",
+    label: "Schedules",
+    shortLabel: "Schedules",
+    description:
+      "Schedule future or recurring sessions on any project's worktree.",
+  },
 ];
 
 interface SettingsPageProps {
   section: SettingsSection;
   onSectionChange: (section: SettingsSection) => void;
   onClose: () => void;
+  /**
+   * Id of the active project. Optional — only used by sections that
+   * are project-scoped. The Schedules section is now cross-project
+   * (per review feedback) and ignores it. Kept on the page type so
+   * future project-scoped sections can opt in without another prop
+   * churn.
+   */
+  projectId?: string;
+  /**
+   * Forwarded to the Schedules section so a fired schedule's `sessionId` can
+   * navigate the main view to that session. Mirrors the `controller://`
+   * deep-link path the transcript already uses. `projectId` is required by
+   * the cross-project Schedules section to land in the right project; the
+   * signature makes it optional so other (single-project) surfaces can opt
+   * in without a breaking change.
+   */
+  onOpenSession?: (params: {
+    sessionId: string;
+    worktreeId?: string;
+    projectId?: string;
+  }) => void;
 }
 
 /*
@@ -57,7 +91,12 @@ interface SettingsPageProps {
  * appears next to the page title. On desktop (≥md) we keep the original
  * two-column layout with the section nav on the left.
  */
-export function SettingsPage({ section, onSectionChange, onClose }: SettingsPageProps) {
+export function SettingsPage({
+  section,
+  onSectionChange,
+  onClose,
+  onOpenSession,
+}: SettingsPageProps) {
   const active = SECTIONS.find((s) => s.id === section) ?? SECTIONS[0];
 
   return (
@@ -149,6 +188,9 @@ export function SettingsPage({ section, onSectionChange, onClose }: SettingsPage
           {active.id === "integrations" && <IntegrationsSection />}
           {active.id === "skills" && <SkillsSection />}
           {active.id === "shortcuts" && <ShortcutsSection />}
+          {active.id === "schedules" && (
+            <SchedulesSection onOpenSession={onOpenSession} />
+          )}
         </div>
       </div>
     </div>
diff --git a/scripts/dev-server-with-port-bump.mjs b/scripts/dev-server-with-port-bump.mjs
index 1078f98f..c6b30f97 100755
--- a/scripts/dev-server-with-port-bump.mjs
+++ b/scripts/dev-server-with-port-bump.mjs
@@ -10,10 +10,20 @@
  * VITE_API_PORT. The Vite dev server shares the same env (via
  * concurrently), so its /api proxy target lands on the same port
  * without any coordination step.
+ *
+ * If `.env.local` exists in the working directory, we load it first
+ * so the port preference written by `.coding-orchestrator/setup.sh`
+ * is honoured. Without this, calling `npm run dev` from a clean
+ * shell (no exported `VITE_API_PORT`) would fall back to the
+ * packaged-app default (3102) and the Vite proxy — which DOES read
+ * `.env.local` via Vite's loadEnv — would point at a different port
+ * and every request would 404 or hit the wrong backend.
  */
 
 import { spawn } from "node:child_process";
 import { createServer } from "node:net";
+import { readFileSync, existsSync } from "node:fs";
+import { resolve as resolvePath } from "node:path";
 
 const DEV_API_BASE_PORT = 3102;
 const MAX_PORT_SEARCH_OFFSET = 100;
@@ -26,6 +36,41 @@ function parseEnvPort(name) {
   return Number.isInteger(parsed) && parsed > 0 && parsed <= 65535 ? parsed : null;
 }
 
+/*
+ * Minimal `.env.local` loader — `KEY=value` lines, comments with `#`,
+ * optional surrounding quotes. Vite has its own richer loader; we
+ * only need the port keys, so a hand-rolled parser is simpler than
+ * pulling in `dotenv`. Only used as a fallback when the parent
+ * shell didn't export the port (e.g. raw `npm run dev` from a fresh
+ * terminal).
+ */
+function loadEnvLocal() {
+  const path = resolvePath(process.cwd(), ".env.local");
+  if (!existsSync(path)) return;
+  const content = readFileSync(path, "utf8");
+  for (const rawLine of content.split("\n")) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    const eq = line.indexOf("=");
+    if (eq === -1) continue;
+    const key = line.slice(0, eq).trim();
+    let value = line.slice(eq + 1).trim();
+    if (
+      (value.startsWith('"') && value.endsWith('"')) ||
+      (value.startsWith("'") && value.endsWith("'"))
+    ) {
+      value = value.slice(1, -1);
+    }
+    // Don't clobber values the parent shell already set — the
+    // run-script (`run.sh`) exports them on purpose, and that wins.
+    if (process.env[key] === undefined) {
+      process.env[key] = value;
+    }
+  }
+}
+
+loadEnvLocal();
+
 function tryBindPort(port, timeoutMs = BIND_TIMEOUT_MS) {
   return new Promise((resolve) => {
     const probe = createServer();