@@ -29,7 +29,7 @@ export const SchedulingToolkit = Toolkit.make(
     .annotate(Tool.Idempotent, false),
   Tool.make("list_scheduled_prompts", {
     description:
-      "List the latest 100 schedules in this chat, including their IDs, next run, status, last run, and any delivery error. Use to inspect scheduled work before changing it.",
+      "List all active and paused schedules in this chat, plus the latest 100 completed or cancelled schedules, including their IDs, next run, status, last run, and any delivery error. Use to inspect scheduled work before changing it.",
     success: Schema.Struct({ schedules: Schema.Array(ScheduledPrompt) }),
     failure,
     dependencies,
 
@@ -1404,6 +1404,7 @@ export const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand"
         (targetThread.archivedAt !== null ||
           targetThread.latestTurn?.state === "running" ||
           targetThread.session?.status === "starting" ||
+          targetThread.session?.status === "running" ||
           (targetThread.session?.activeTurnId !== null &&
             targetThread.session?.activeTurnId !== undefined) ||
           openRequests(targetThread).size > 0 ||
 
@@ -152,8 +152,12 @@ it.effect("scheduled turn starts cannot steer running or queued work", () =>
         updatedAt: createdAt,
       },
     };
+    const runningWithoutTurn = {
+      ...starting,
+      session: { ...starting.session, status: "running" as const },
+    };
     const archived = { ...target, archivedAt: createdAt };
-    for (const blocked of [starting, archived]) {
+    for (const blocked of [starting, runningWithoutTurn, archived]) {
       const error = yield* decideOrchestrationCommand({
         readModel: { ...readModel, threads: [blocked] },
         command: { ...turnStartCommand, requireIdleAt: createdAt },
 
@@ -328,3 +328,31 @@ it.effect("agents can create, inspect, and cancel a schedule through MCP", () =>
     expect(commands).toHaveLength(0);
   }).pipe(provide),
 );
+
+it.effect("lists older live schedules even after more than 100 terminal schedules", () =>
+  Effect.gen(function* () {
+    const { schedules } = yield* harness;
+    const active = yield* schedules.create(threadId, {
+      prompt: "Keep checking",
+      schedule: { kind: "interval", seconds: 60 },
+    });
+    const paused = yield* schedules.create(threadId, {
+      prompt: "Paused check",
+      schedule: { kind: "interval", seconds: 60 },
+    });
+    yield* schedules.update(threadId, paused.id, "pause");
+    yield* TestClock.adjust("1 second");
+    for (let index = 0; index < 105; index++) {
+      const terminal = yield* schedules.create(threadId, {
+        prompt: "Cancelled check",
+        schedule: { kind: "delay", seconds: 60 },
+      });
+      yield* schedules.update(threadId, terminal.id, "cancel");
+    }
+    const listed = yield* schedules.list(threadId);
+    expect(listed).toHaveLength(102);
+    expect(listed).toContainEqual(expect.objectContaining({ id: active.id, status: "active" }));
+    expect(listed).toContainEqual(expect.objectContaining({ id: paused.id, status: "paused" }));
+    expect(listed.filter((schedule) => schedule.status === "cancelled")).toHaveLength(100);
+  }).pipe(provide),
+);
@@ -133,7 +133,12 @@ export const make = Effect.gen(function* () {
 
   const list = (threadId: ThreadId) =>
     locked(
-      sql<Row>`SELECT * FROM scheduled_prompts WHERE thread_id = ${threadId} ORDER BY created_at DESC LIMIT 100`.pipe(
+      sql<Row>`WITH terminal AS (
+        SELECT * FROM scheduled_prompts WHERE thread_id = ${threadId} AND status IN ('completed', 'cancelled')
+        ORDER BY created_at DESC LIMIT 100
+      )
+      SELECT * FROM scheduled_prompts WHERE thread_id = ${threadId} AND status IN ('active', 'paused')
+      UNION ALL SELECT * FROM terminal ORDER BY created_at DESC`.pipe(
         Effect.map((rows) => rows.map(fromRow)),
       ),
     );
@@ -178,6 +183,7 @@ export const make = Effect.gen(function* () {
             dispatchedThreads.has(row.thread_id) ||
             value.latestTurn?.state === "running" ||
             value.session?.status === "starting" ||
+            value.session?.status === "running" ||
             value.session?.activeTurnId ||
             value.hasPendingApprovals ||
             value.hasPendingUserInput ||
 
@@ -110,6 +110,7 @@ import * as BackgroundPolicy from "./background/BackgroundPolicy.ts";
 import * as ServerConfig from "./config.ts";
 import * as DeviceService from "./device/DeviceService.ts";
 import { HTTP_ROUTER_CONFIG, makeRoutesLayer } from "./server.ts";
+import * as ScheduledPrompts from "./scheduling/ScheduledPrompts.ts";
 import {
   isThreadDetailEvent,
   resolveAvailableEditorsForConfig,
@@ -772,6 +773,7 @@ const buildAppUnderTest = (options?: {
       // Viewed-file marks for a host that keeps none of its own are rows, so the routes want a
       // database. Its own, in memory: nothing here shares a table with the auth store.
       makeRoutesLayer.pipe(
+        Layer.provide(ScheduledPrompts.layer),
         Layer.provide(Layer.mergeAll(serviceLauncherClientLayer, SqlitePersistenceMemory)),
       ),
       {
 
@@ -617,7 +617,6 @@ export const makeRoutesLayer = Layer.mergeAll(
   // Last, so no route layer can replace the server's one TracerDisabledWhen.
   untracedRequestsLayer,
 ).pipe(
-  Layer.provide(ScheduledPrompts.layer),
   // Both transports consume the same service instance, so caches single-flight across clients
   // and mutations observed on WebSocket invalidate patches subsequently read over HTTP.
   Layer.provide(PullRequestServiceLive),
 
@@ -0,0 +1,49 @@
+import { expect, it } from "@effect/vitest";
+import * as Schema from "effect/Schema";
+import { CreateScheduledPromptInput } from "./scheduling.ts";
+
+const decode = Schema.decodeSync(CreateScheduledPromptInput);
+
+it("rejects impossible calendar dates for both exact starts and interval starts", () => {
+  for (const at of [
+    "2026-02-30T09:00:00Z",
+    "2025-02-29T09:00:00Z",
+    "2100-02-29T09:00:00Z",
+    "2026-04-31T09:00:00+02:00",
+    "2026-00-01T09:00:00Z",
+    "2026-01-00T09:00:00Z",
+  ]) {
+    expect(() => decode({ prompt: "Check", schedule: { kind: "once", at } })).toThrow();
+    expect(() =>
+      decode({ prompt: "Check", schedule: { kind: "interval", seconds: 60, startAt: at } }),
+    ).toThrow();
+  }
+});
+
+it("rejects invalid clocks, offsets, and timestamps without an offset", () => {
+  for (const at of [
+    "2026-10-01T24:00:00Z",
+    "2026-10-01T09:60:00Z",
+    "2026-10-01T09:00:60Z",
+    "2026-10-01T09:00:00+24:00",
+    "2026-10-01T09:00:00+02:60",
+    "2026-10-01T09:00:00",
+    "garbageTZ",
+  ]) {
+    expect(() => decode({ prompt: "Check", schedule: { kind: "once", at } })).toThrow();
+  }
+});
+
+it("accepts leap days and explicit offsets without changing the input", () => {
+  for (const at of [
+    "2024-02-29T09:00:00Z",
+    "2000-02-29T09:00:00Z",
+    "2026-10-01T09:00:00.123+02:00",
+    "2026-10-01T09:00:00-07:00",
+  ]) {
+    expect(decode({ prompt: "Check", schedule: { kind: "once", at } }).schedule).toEqual({
+      kind: "once",
+      at,
+    });
+  }
+});
@@ -1,7 +1,21 @@
 import * as Schema from "effect/Schema";
 import { IsoDateTime, TrimmedNonEmptyString } from "./baseSchemas.ts";
 
-const Timestamp = IsoDateTime.check(Schema.isPattern(/T.*(?:Z|[+-]\d{2}:\d{2})$/));
+const timestampPattern =
+  /^(\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])T(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d(?:\.\d{1,3})?(?:Z|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/;
+const Timestamp = IsoDateTime.check(
+  Schema.makeFilter((value) => {
+    const parts = timestampPattern.exec(value);
+    if (parts === null)
+      return "Use a valid calendar timestamp with seconds and an explicit UTC offset.";
+    const year = Number(parts[1]);
+    const month = Number(parts[2]);
+    const day = Number(parts[3]);
+    const leapYear = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+    const daysInMonth = [31, leapYear ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+    return day <= daysInMonth[month - 1]! || "The timestamp contains an impossible calendar date.";
+  }),
+);
 
 const Seconds = Schema.Int.check(Schema.isBetween({ minimum: 60, maximum: 31_536_000 }));