@saadnvd1/agent-os 0.3.479 → 0.3.481

package/README.md

@@ -745,6 +745,22 @@ next minute until the brake lifts or a newer run is due (Run now obeys them
 too, once). A schedule whose project has moved to another workspace fails
 until it's edited. Removing a schedule keeps its history.
 
+**One-off schedules.** Pick **Once** in the form (a date and time in the
+schedule's zone), or `aos schedule add --at "tomorrow 10am" ...` (an ISO time,
+`in 2h`, a weekday; America/Chicago unless `--tz`). It works with every kind,
+runs once and then turns itself off; the run stays in its history, marked
+done, and the schedule moves to the **Done** group. Upcoming one-offs are
+listed first with their run time, how far off it is and who made it (you or an
+orchestrator), each with Run now, Edit and Cancel; the count shows in the
+sidebar menu and the orchestrator's header. The same claim-in-SQLite rule
+applies, so it never runs twice, and one AgentOS missed while off runs when it
+returns, marked **caught up**. Pause holds a one-off until you resume rather
+than skipping it, and the brakes apply as for any run. A past time is refused.
+Run now uses up its only run; edit it to a new time to run it again. An
+orchestrator makes its own with `remind_me`: at least ten minutes ahead, 20
+pending at most, in its own workspace, and it arrives as a scheduled prompt,
+never an approval.
+
 Task and session schedules run at most hourly, message schedules at most
 every 10 minutes and skip a run (`still working`) while their session is
 still busy, mid-turn or holding a queued message. A task schedule waits
@@ -993,7 +1009,7 @@ it may do on its own, and the lines that always come back to you as asks.
   workspace, or the project already at that path moves in from no workspace;
   folders that hold secrets and projects of another workspace are refused),
   `note`,
-  `rule_add`, `rule_remove`, `review`, `sign_off`, `arm`, `disarm` and `ask_saad`. All are served in-process to its chat, refuse
+  `rule_add`, `rule_remove`, `review`, `sign_off`, `arm`, `disarm`, `remind_me`, `reminders`, `cancel_reminder` and `ask_saad`. All are served in-process to its chat, refuse
   any target outside its workspace, and validate their arguments. The one
   exception is other orchestrators: `orchestrators` lists every workspace and
   whether it has one, and `message_orchestrator` messages another workspace's

package/app/api/schedules/route.ts

@@ -28,6 +28,7 @@ export async function POST(request: NextRequest) {
             from: body.from ? String(body.from) : null,
             every: body.every,
             cron: body.cron,
+            at: body.at,
             prompt: String(body.prompt ?? ""),
             name: body.name,
             timezone: body.timezone,

package/components/Orchestrator/OrchestratorBar.tsx

@@ -8,6 +8,8 @@ import { usePauseOrchestrator } from "@/data/orchestrators";
 import { useOrchestratorHeader } from "@/hooks/useOrchestratorHeader";
 import { headerParts } from "@/lib/orchestrator/header-line";
 import { cn } from "@/lib/utils";
+import { useSchedulesGlance } from "@/components/SessionList/useSchedulesGlance";
+import { schedulesUiActions } from "@/stores/schedulesUi";
 import { NO_PASSKEYS_HERE, passkeysHere } from "@/data/presence";
 import { AsksList } from "./AsksList";
 
@@ -21,6 +23,7 @@ export const OrchestratorBar = memo(function OrchestratorBar({
 }) {
   const { overview, counts } = useOrchestratorHeader(workspaceId);
   const pause = usePauseOrchestrator(workspaceId);
+  const { upcomingText } = useSchedulesGlance(workspaceId);
   const [open, setOpen] = useState(true);
   const canProve = useSyncExternalStore(
     () => () => {},
@@ -73,6 +76,15 @@ export const OrchestratorBar = memo(function OrchestratorBar({
           {counts.paused ? "Resume" : "Pause"}
         </Button>
       </div>
+      {upcomingText && (
+        <button
+          type="button"
+          onClick={() => schedulesUiActions.open(workspaceId)}
+          className="text-muted-foreground hover:text-foreground flex min-h-11 w-full items-center px-1 text-left text-xs md:min-h-8"
+        >
+          {upcomingText}
+        </button>
+      )}
       {counts.paused && (
         <p className="text-muted-foreground px-1 text-xs">
           Paused: events wait and it won&apos;t start, merge or message anything

package/components/Schedules/ScheduleForm.tsx

@@ -31,8 +31,10 @@ import {
   minGapMinutes,
   nextRuns,
   presetCron,
+  wall,
   type PresetKind,
 } from "@/lib/schedules/cron";
+import { parseWhen, relativeTime } from "@/lib/schedules/when";
 
 const KINDS: { value: ScheduleKind; label: string; hint: string }[] = [
   {
@@ -57,7 +59,10 @@ const KINDS: { value: ScheduleKind; label: string; hint: string }[] = [
   },
 ];
 
-const PRESETS: { value: PresetKind | "custom"; label: string }[] = [
+type Preset = PresetKind | "custom" | "once";
+
+const PRESETS: { value: Preset; label: string }[] = [
+  { value: "once", label: "Once" },
   { value: "every", label: "Every…" },
   { value: "hourly", label: "Hourly" },
   { value: "daily", label: "Daily" },
@@ -115,6 +120,17 @@ function Segmented<T extends string>({
   );
 }
 
+const pad = (n: number) => String(n).padStart(2, "0");
+
+// The date and time inputs' values for an instant, as the zone's wall clock.
+function wallParts(ms: number, tz: string) {
+  const w = wall(ms, tz);
+  return {
+    date: `${w.y}-${pad(w.m)}-${pad(w.d)}`,
+    time: `${pad(w.h)}:${pad(w.mi)}`,
+  };
+}
+
 const Field = ({
   label,
   children,
@@ -148,7 +164,8 @@ export function ScheduleForm({
   const update = useUpdateSchedule();
   const mutation = existing ? update : create;
 
-  const initialPreset = existing ? cronPreset(existing.cron) : null;
+  const initialPreset =
+    existing && existing.run_at == null ? cronPreset(existing.cron) : null;
   const [wsId, setWsId] = useState(
     existing?.workspace_id ?? workspaceId ?? workspaces[0]?.id ?? ""
   );
@@ -161,9 +178,24 @@ export function ScheduleForm({
   );
   const [projectId, setProjectId] = useState(existing?.project_id ?? "");
   const [prompt, setPrompt] = useState(existing?.prompt ?? "");
-  const [preset, setPreset] = useState<PresetKind | "custom">(
-    existing ? (initialPreset?.kind ?? "custom") : draft ? "every" : "weekdays"
+  const [preset, setPreset] = useState<Preset>(
+    existing?.run_at != null
+      ? "once"
+      : existing
+        ? (initialPreset?.kind ?? "custom")
+        : draft
+          ? "every"
+          : "weekdays"
+  );
+  // A new one-off starts an hour out.
+  const [initialAt] = useState(() =>
+    wallParts(
+      existing?.run_at ?? Date.now() + 3_600_000,
+      existing?.timezone ?? DEFAULT_TIMEZONE
+    )
   );
+  const [atDate, setAtDate] = useState(initialAt.date);
+  const [atTime, setAtTime] = useState(initialAt.time);
   const [every, setEvery] = useState(initialPreset?.every ?? 30);
   const [hour, setHour] = useState(initialPreset?.hour ?? 9);
   const [minute, setMinute] = useState(initialPreset?.minute ?? 0);
@@ -197,12 +229,14 @@ export function ScheduleForm({
     .sort((a, b) => a.name.localeCompare(b.name));
   const target = targets.find((s) => s.id === targetId)?.id ?? "";
 
-  const cron =
-    preset === "custom"
+  const once = preset === "once";
+  const cron = once
+    ? ""
+    : preset === "custom"
       ? custom.trim()
       : presetCron({ kind: preset, hour, minute, weekday, every });
   const tzOk = isTimezone(timezone);
-  const cronProblem = cronError(cron);
+  const cronProblem = once ? null : cronError(cron);
   // The preview counts from now, kept fresh while the form is open.
   const [openedAt, setOpenedAt] = useState(() => Date.now());
   useEffect(() => {
@@ -214,13 +248,32 @@ export function ScheduleForm({
     [cron, cronProblem, timezone, tzOk, openedAt]
   );
 
+  // The picked wall time in the zone, or null while it's incomplete.
+  const runAt = useMemo(() => {
+    if (!once || !tzOk || !atDate || !atTime) return null;
+    try {
+      return parseWhen(`${atDate}T${atTime}`, timezone);
+    } catch {
+      return null;
+    }
+  }, [once, tzOk, atDate, atTime, timezone]);
+  // Saving a done one-off at its old time can't reopen it; a new time must be ahead.
+  const atProblem =
+    once && tzOk
+      ? runAt === null
+        ? "Pick a date and time"
+        : runAt <= openedAt && runAt !== existing?.run_at
+          ? "That time has passed"
+          : null
+      : null;
+
   const submit = (e: React.FormEvent) => {
     e.preventDefault();
     const input = {
       workspaceId: workspace,
       projectId: project || null,
       name,
-      cron,
+      ...(once ? { at: runAt } : { cron }),
       timezone,
       prompt,
       kind,
@@ -242,10 +295,11 @@ export function ScheduleForm({
   const tooOften = useMemo(
     () =>
       minGap > 0 &&
+      !once &&
       !cronProblem &&
       tzOk &&
       minGapMinutes(cron, timezone, openedAt) < minGap,
-    [minGap, cron, cronProblem, timezone, tzOk, openedAt]
+    [minGap, once, cron, cronProblem, timezone, tzOk, openedAt]
   );
 
   const ready =
@@ -253,6 +307,7 @@ export function ScheduleForm({
     prompt.trim() &&
     workspace &&
     !cronProblem &&
+    !atProblem &&
     tzOk &&
     !tooOften &&
     (kind === "message" ? target : kind === "orchestrator" || project);
@@ -362,7 +417,24 @@ export function ScheduleForm({
             setPreset(v);
           }}
         />
-        {preset === "custom" ? (
+        {once ? (
+          <div className="flex flex-wrap gap-2">
+            <Input
+              type="date"
+              aria-label="Date"
+              value={atDate}
+              onChange={(e) => setAtDate(e.target.value)}
+              className="h-11 w-44 md:h-9"
+            />
+            <Input
+              type="time"
+              aria-label="Time"
+              value={atTime}
+              onChange={(e) => setAtTime(e.target.value)}
+              className="h-11 w-32 md:h-9"
+            />
+          </div>
+        ) : preset === "custom" ? (
           <Input
             aria-label="Cron expression"
             value={custom}
@@ -450,10 +522,20 @@ export function ScheduleForm({
           className="text-muted-foreground h-11 md:h-8 md:text-xs"
         />
         <div className="bg-primary/[0.06] rounded-lg px-3 py-2.5 text-sm">
-          {cronProblem || !tzOk ? (
+          {cronProblem || !tzOk || atProblem ? (
             <p className="text-destructive">
-              {cronProblem ?? `Unknown time zone "${timezone}"`}
+              {!tzOk
+                ? `Unknown time zone "${timezone}"`
+                : (cronProblem ?? atProblem)}
             </p>
+          ) : once && runAt !== null ? (
+            <>
+              <p className="font-medium">{formatRunTime(runAt, timezone)}</p>
+              <p className="text-muted-foreground mt-1 text-xs">
+                Runs once, {relativeTime(runAt, openedAt)}, then turns itself
+                off.
+              </p>
+            </>
           ) : (
             <>
               <p className="font-medium">{describeCron(cron)}</p>

package/components/Schedules/SchedulesPanel.tsx

@@ -25,6 +25,7 @@ import {
 } from "@/data/schedules";
 import type { ScheduleView } from "@/lib/schedules";
 import { formatRunTime } from "@/lib/schedules/cron";
+import { relativeTime } from "@/lib/schedules/when";
 import { schedulesUi, schedulesUiActions } from "@/stores/schedulesUi";
 import { ScheduleForm } from "./ScheduleForm";
 import { OutcomeChip, RunHistory } from "./RunHistory";
@@ -50,10 +51,14 @@ const where = (s: ScheduleView) =>
       : "";
 
 function NextRun({ s }: { s: ScheduleView }) {
+  if (s.done_at) return <>Done {formatRunTime(s.done_at, s.timezone)}</>;
   if (!s.enabled) return <>Off</>;
   if (s.paused) return <>Paused with the orchestrator</>;
   return s.nextRunAt ? (
-    <>Next {formatRunTime(s.nextRunAt, s.timezone)}</>
+    <>
+      {s.oneOff ? "Runs" : "Next"} {formatRunTime(s.nextRunAt, s.timezone)}
+      {s.oneOff && ` (${relativeTime(s.nextRunAt)})`}
+    </>
   ) : (
     <>No upcoming run</>
   );
@@ -98,15 +103,44 @@ function ScheduleRow({ s, onOpen }: { s: ScheduleView; onOpen: () => void }) {
           </span>
         </div>
         <p className="text-muted-foreground truncate text-xs">
-          {s.description} · <NextRun s={s} />
+          {s.oneOff ? (
+            <NextRun s={s} />
+          ) : (
+            <>
+              {s.description} · <NextRun s={s} />
+            </>
+          )}
+          {s.oneOff && ` · by ${s.createdBy.name}`}
         </p>
       </div>
       {s.lastRun && <OutcomeChip run={s.lastRun} />}
-      <EnableSwitch s={s} />
+      {!s.done_at && <EnableSwitch s={s} />}
     </div>
   );
 }
 
+function Group({
+  title,
+  rows,
+  onOpen,
+}: {
+  title: string;
+  rows: ScheduleView[];
+  onOpen: (id: string) => void;
+}) {
+  if (rows.length === 0) return null;
+  return (
+    <section className="space-y-2">
+      <h4 className="text-muted-foreground px-1 text-xs font-medium">
+        {title} · {rows.length}
+      </h4>
+      {rows.map((s) => (
+        <ScheduleRow key={s.id} s={s} onOpen={() => onOpen(s.id)} />
+      ))}
+    </section>
+  );
+}
+
 function Detail({
   id,
   onEdit,
@@ -134,11 +168,12 @@ function Detail({
       <div className="space-y-1">
         <div className="flex items-center gap-2">
           <h3 className="min-w-0 flex-1 truncate font-semibold">{s.name}</h3>
-          <EnableSwitch s={s} />
+          {!s.done_at && <EnableSwitch s={s} />}
         </div>
         <p className="text-muted-foreground text-sm">
           {KIND_LABEL[s.kind]}
           {where(s)} · {s.description}
+          {s.oneOff && ` · by ${s.createdBy.name}`}
         </p>
         <p className="text-muted-foreground text-xs">
           <NextRun s={s} /> · {s.timezone}
@@ -151,7 +186,7 @@ function Detail({
         <Button
           size="sm"
           className="h-11 md:h-8"
-          disabled={run.isPending}
+          disabled={run.isPending || !!s.done_at}
           onClick={() => run.mutate(s.id)}
         >
           <Play className="h-3.5 w-3.5" />
@@ -174,7 +209,7 @@ function Detail({
             disabled={archive.isPending}
             onClick={() => archive.mutate(s.id, { onSuccess: onGone })}
           >
-            Remove (keeps history)
+            {s.oneOff && !s.done_at ? "Cancel it" : "Remove (keeps history)"}
           </Button>
         ) : (
           <Button
@@ -184,7 +219,7 @@ function Detail({
             onClick={() => setConfirm(true)}
           >
             <Trash2 className="h-3.5 w-3.5" />
-            Remove
+            {s.oneOff && !s.done_at ? "Cancel" : "Remove"}
           </Button>
         )}
       </div>
@@ -300,13 +335,24 @@ export function SchedulesPanel() {
               </p>
             </div>
           )}
-          {schedules.map((s) => (
-            <ScheduleRow
-              key={s.id}
-              s={s}
-              onOpen={() => setView({ mode: "detail", id: s.id })}
-            />
-          ))}
+          {(() => {
+            const open = (id: string) => setView({ mode: "detail", id });
+            const upcoming = schedules
+              .filter((s) => s.oneOff && !s.done_at)
+              .sort((a, b) => (a.run_at ?? 0) - (b.run_at ?? 0));
+            const done = schedules.filter((s) => s.done_at);
+            return (
+              <>
+                <Group title="Upcoming" rows={upcoming} onOpen={open} />
+                <Group
+                  title="Recurring"
+                  rows={schedules.filter((s) => !s.oneOff)}
+                  onOpen={open}
+                />
+                <Group title="Done" rows={done} onOpen={open} />
+              </>
+            );
+          })()}
           {!isPending && <PhoneLine />}
         </div>
       )}

package/components/SessionList/SidebarHeader.tsx

@@ -97,7 +97,7 @@ export function SidebarHeader(props: SidebarHeaderProps) {
             // Opens Settings > Schedules.
             menuItem("Schedules", () => schedulesUiActions.open(workspaceId), {
               icon: Clock,
-              description: schedules.nextText,
+              description: schedules.upcomingText ?? schedules.nextText,
               badge: schedules.failed > 0 && (
                 <span className="text-destructive flex items-center gap-1.5 text-xs font-medium tabular-nums">
                   <span aria-hidden className={failedDot} />

package/components/SessionList/useSchedulesGlance.ts

@@ -3,12 +3,13 @@
 import { useSchedulesQuery } from "@/data/schedules";
 import { schedulesBadge } from "@/lib/schedules/badge";
 import { formatRunTime } from "@/lib/schedules/cron";
+import { relativeTime } from "@/lib/schedules/when";
 
 // Schedules at a glance for the header's menu: how many failed their last
 // run (a red badge) and when the next one runs (a line under the item).
 export function useSchedulesGlance(workspaceId: string | null) {
   const { data: schedules = [] } = useSchedulesQuery(workspaceId);
-  const { next, failed } = schedulesBadge(schedules);
+  const { next, failed, upcoming, nextUpcoming } = schedulesBadge(schedules);
   const failedText = failed
     ? `${failed} schedule${failed === 1 ? "" : "s"} failed last run`
     : null;
@@ -17,5 +18,8 @@ export function useSchedulesGlance(workspaceId: string | null) {
     : schedules.length
       ? "Nothing scheduled to run"
       : "No schedules yet";
-  return { failed, failedText, nextText };
+  const upcomingText = upcoming
+    ? `${upcoming} upcoming${nextUpcoming ? ` · next ${relativeTime(nextUpcoming.at)}` : ""}`
+    : null;
+  return { failed, failedText, nextText, upcoming, upcomingText };
 }

package/lib/chat/drivers/demo.ts

@@ -64,7 +64,8 @@ export function demoConversation(stepMs = 40): ChatConversation {
     const words = DEMO_REPLY.split(/(?<= )/);
     let i = 0;
     for (; i < words.length && !stopped && !closed; i++) {
-      await sleep(stepMs);
+      // A step of 0 (tests) streams with no timer per word.
+      if (stepMs) await sleep(stepMs);
       out.push({ type: "delta", id, text: words[i] });
     }
     out.push({

package/lib/chat/test-touch.ts

@@ -1,17 +1,63 @@
-// For tests of file watching.
+// For tests that wait on async work or stand in for file watching.
+
+import fs from "fs";
+import { vi } from "vitest";
 
 export const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
 
-// Makes a change, and again every 2s until it's seen: macOS can be slow, and
-// drops an event while another watcher in the process opens or closes.
-// Returns how many times it changed things.
-export async function touchUntil(touch: () => void, seen: () => boolean) {
-  for (let n = 1; n <= 15; n++) {
-    touch();
-    for (let t = 0; t < 100; t++) {
-      if (seen()) return n;
-      await sleep(20);
-    }
+// Polls until `check` holds. The ceiling is generous: it only matters when
+// something is really broken, and a loaded machine never reaches it.
+export async function until(check: () => boolean, ceilingMs = 10_000) {
+  const end = Date.now() + ceilingMs;
+  while (!check()) {
+    if (Date.now() > end) throw new Error("condition never held");
+    await sleep(10);
   }
-  throw new Error("never seen");
+}
+
+export interface FakeWatch {
+  path: string;
+  recursive: boolean;
+  closed: boolean;
+  // Delivers an event as the OS would (null: no file name given).
+  fire(name: string | null): void;
+}
+
+// Replaces fs.watch with handles the test fires by hand: the OS's own events
+// arrive when it likes, which under load is never inside a test's wait.
+export function fakeFsWatch() {
+  const handles: FakeWatch[] = [];
+  const spy = vi.spyOn(fs, "watch").mockImplementation(((
+    p: unknown,
+    o: unknown,
+    listener: (e: string, name: string | null) => void
+  ) => {
+    const h: FakeWatch = {
+      path: String(p),
+      recursive: !!(o as { recursive?: boolean } | null)?.recursive,
+      closed: false,
+      fire: (name) => listener("rename", name),
+    };
+    handles.push(h);
+    return {
+      on() {},
+      close() {
+        h.closed = true;
+      },
+    };
+  }) as unknown as typeof fs.watch);
+  return {
+    all: handles,
+    open: () => handles.filter((h) => !h.closed),
+    // The live handle on `p`.
+    at(p: string, recursive?: boolean) {
+      return handles.find(
+        (h) =>
+          !h.closed &&
+          h.path === p &&
+          (recursive === undefined || h.recursive === recursive)
+      );
+    },
+    restore: () => spy.mockRestore(),
+  };
 }

package/lib/db/migrations.ts

@@ -1445,6 +1445,20 @@ const migrations: Migration[] = [
       );
     },
   },
+  {
+    id: 63,
+    name: "one_off_schedules",
+    up: (db) =>
+      db.transaction(() => {
+        // A one-off has a run time (epoch ms, UTC) and no cron; done_at is
+        // set once its single run settles. Recurring rows leave both NULL.
+        db.exec(`ALTER TABLE schedules ADD COLUMN run_at INTEGER`);
+        db.exec(`ALTER TABLE schedules ADD COLUMN done_at INTEGER`);
+        db.exec(
+          `CREATE INDEX IF NOT EXISTS idx_schedules_run_at ON schedules(run_at) WHERE run_at IS NOT NULL`
+        );
+      })(),
+  },
 ];
 
 // `upTo`: stop after this id (tests that start from an older database).

package/lib/orchestrator/brief.ts

@@ -107,6 +107,9 @@ Acting:
 - \`${TOOL_NAMES.note}\` (text): a line in this workspace's decision log, shown in your chat. Note each decision that matters, with why.
 - \`${TOOL_NAMES.rule_add}\` (text): keep a standing rule for this workspace, in your brief on every start. Saad sees and edits them in Settings → Workspaces.
 - \`${TOOL_NAMES.rule_remove}\` (id): remove a standing rule you kept (Saad's are his to remove).
+- \`${TOOL_NAMES.remind_me}\` (at, prompt, name?): a one-off reminder to yourself ("tomorrow 10am", "in 2h"); it reaches you once as a scheduled prompt, not an approval, even if AgentOS was off. At least 10 minutes ahead. Prefer it to remembering to check back.
+- \`${TOOL_NAMES.reminders}\` (): your upcoming reminders and the last few that ran.
+- \`${TOOL_NAMES.cancel_reminder}\` (id): cancel a reminder you set.
 - \`${TOOL_NAMES.review}\` (target, fresh?): review a task's PR, or an external PR (#N, owner/repo#N or URL), at its head commit, or read the stored verdict.
 - \`${TOOL_NAMES.sign_off}\` (task): merge a task's PR or an external PR through the gates.
 - \`${TOOL_NAMES.arm}\` (task): merge a task's PR by itself the moment every gate passes; one event when it merges or a gate fails.

package/lib/orchestrator/reminders.ts

@@ -0,0 +1,91 @@
+/**
+ * remind_me, reminders and cancel_reminder: the orchestrator's one-off
+ * schedules. A reminder is a schedule that messages the workspace's own
+ * orchestrator once, so it arrives as a scheduled prompt and never as an
+ * approval. Every call is scoped to the caller's workspace, and only reminders
+ * an orchestrator made can be cancelled here: Saad's are his to change.
+ */
+
+import {
+  archiveSchedule,
+  createSchedule,
+  getSessionRow,
+  listSchedules,
+  type Schedule,
+} from "../schedules/store";
+import { reminderName } from "../schedules";
+import { DEFAULT_TIMEZONE, formatRunTime } from "../schedules/cron";
+import { parseWhen, relativeTime } from "../schedules/when";
+import { getOrchestrator } from "./home";
+import { addNote } from "./notes";
+
+const SHOW_DONE = 3;
+
+const line = (s: Schedule) =>
+  `${s.id.slice(0, 8)}  ${s.name}: ${formatRunTime(s.run_at ?? 0, s.timezone)} (${relativeTime(s.run_at ?? 0)})`;
+
+const madeByOrchestrator = (s: Schedule) =>
+  getSessionRow(s.created_by_session_id ?? "")?.role === "orchestrator";
+
+export function remindMe(
+  w: string,
+  at: string,
+  prompt: string,
+  name?: string
+): string {
+  const me = getOrchestrator(w);
+  if (!me) throw new Error("This workspace has no orchestrator");
+  const runAt = parseWhen(at, DEFAULT_TIMEZONE);
+  const schedule = createSchedule({
+    workspaceId: w,
+    name: name?.trim() || reminderName(w, runAt, DEFAULT_TIMEZONE),
+    at: runAt,
+    timezone: DEFAULT_TIMEZONE,
+    prompt,
+    kind: "orchestrator",
+    createdBySessionId: me.id,
+  });
+  addNote(
+    w,
+    `Reminder set: ${schedule.name}, ${line(schedule).split(": ")[1]}`
+  );
+  return `Reminder ${schedule.id.slice(0, 8)} set for ${formatRunTime(runAt, DEFAULT_TIMEZONE)} (${relativeTime(runAt)}). It reaches you as a scheduled prompt, not an approval.`;
+}
+
+export function listReminders(w: string): string {
+  const all = listSchedules(w).filter((s) => s.run_at != null);
+  const upcoming = all
+    .filter((s) => s.enabled && !s.done_at)
+    .sort((a, b) => (a.run_at ?? 0) - (b.run_at ?? 0));
+  const done = all
+    .filter((s) => s.done_at)
+    .sort((a, b) => (b.done_at ?? 0) - (a.done_at ?? 0))
+    .slice(0, SHOW_DONE);
+  if (!upcoming.length && !done.length) return "No reminders.";
+  return [
+    upcoming.length
+      ? `Upcoming:\n${upcoming.map(line).join("\n")}`
+      : "None upcoming.",
+    done.length
+      ? `Recently done:\n${done.map((s) => `${s.id.slice(0, 8)}  ${s.name}`).join("\n")}`
+      : "",
+  ]
+    .filter(Boolean)
+    .join("\n\n");
+}
+
+export function cancelReminder(w: string, id: string): string {
+  const ref = id.trim();
+  const matches = listSchedules(w).filter(
+    (s) =>
+      s.run_at != null &&
+      !s.done_at &&
+      (s.id === ref || (ref.length >= 6 && s.id.startsWith(ref)))
+  );
+  // Another workspace's, a done one and one Saad made all read the same.
+  if (matches.length !== 1 || !madeByOrchestrator(matches[0]))
+    throw new Error(`No reminder "${ref}" in this workspace`);
+  archiveSchedule(matches[0].id);
+  addNote(w, `Reminder cancelled: ${matches[0].name}`);
+  return `Reminder ${matches[0].id.slice(0, 8)} cancelled.`;
+}