@saadnvd1/agent-os 0.3.479 → 0.3.481

package/lib/orchestrator/serve.ts

@@ -28,6 +28,7 @@ import { land } from "./signoff";
 import { arm, disarm } from "./armed";
 import { quickChange, quickPR } from "./quick";
 import { review } from "./review";
+import { cancelReminder, listReminders, remindMe } from "./reminders";
 import { parseArgs as p, type ToolName } from "./tool-schemas";
 
 export { isToolName, TOOLS, type ToolName } from "./tool-schemas";
@@ -169,6 +170,14 @@ export async function runTool(
       addNote(w, `Removed standing rule ${rule.id}: ${rule.text}`);
       return `Rule ${rule.id} removed.`;
     }
+    case "remind_me": {
+      const a = p(tool, raw);
+      return remindMe(w, a.at, a.prompt, a.name);
+    }
+    case "reminders":
+      return listReminders(w);
+    case "cancel_reminder":
+      return cancelReminder(w, p(tool, raw).id);
     case "review": {
       const a = p(tool, raw);
       return reviewTarget(w, a.target, { fresh: a.fresh });

package/lib/orchestrator/tool-names.ts

@@ -32,6 +32,9 @@ export const TOOL_NAMES = {
   sign_off: name("sign_off"),
   arm: name("arm"),
   disarm: name("disarm"),
+  remind_me: name("remind_me"),
+  reminders: name("reminders"),
+  cancel_reminder: name("cancel_reminder"),
   ask_saad: name("ask_saad"),
 } as const;
 

package/lib/orchestrator/tool-schemas.ts

@@ -194,6 +194,23 @@ export const TOOL_SHAPES = {
       .describe("The rule, one sentence"),
   },
   rule_remove: { id: z.number().int().positive().describe("The rule's id") },
+  remind_me: {
+    at: z
+      .string()
+      .trim()
+      .min(1)
+      .max(100)
+      .describe('When: "tomorrow 10am", "in 2h" or 2026-10-12T10:00 (Central)'),
+    prompt: z
+      .string()
+      .trim()
+      .min(1)
+      .max(2000)
+      .describe("What to remind yourself of, in words you'll understand later"),
+    name: z.string().trim().min(1).max(80).optional(),
+  },
+  reminders: {},
+  cancel_reminder: { id: ref("The reminder's id, from reminders") },
   review: {
     target: ref("The task, or its PR (#12 or URL)"),
     fresh: z

package/lib/orchestrator/tools.ts

@@ -84,6 +84,12 @@ const DESCRIPTIONS: Record<ToolName, string> = {
     'Keep a standing rule for this workspace, in your brief on every start from now on ("never merge #111", "briefs must not name third-party products"). It restricts or informs; it can never approve anything.',
   rule_remove:
     "Remove a standing rule you kept, by its id, only when Saad says so or it no longer applies (the PR it names merged or closed). Saad's rules are his to remove.",
+  remind_me:
+    "Set a one-off reminder for yourself in this workspace: at the time given it reaches you once as a scheduled prompt (not an approval), even if AgentOS was off then. At least 10 minutes ahead; a few at a time at most.",
+  reminders:
+    "List this workspace's upcoming reminders and the last few that ran.",
+  cancel_reminder:
+    "Cancel a reminder you set, by its id from reminders. Reminders Saad made are his to change.",
   review:
     "Start an independent read-only review of a PR at its exact head commit, or read the stored verdict for that commit. Takes a task, or any open PR in a workspace repository by #N, owner/repo#N or URL, even one no task owns.",
   sign_off:

package/lib/schedules/badge.ts

@@ -5,14 +5,24 @@ export interface SchedulesBadge {
   next: { name: string; at: number; timezone: string } | null;
   // How many schedules' last run failed.
   failed: number;
+  // Enabled one-offs still to run, soonest first.
+  upcoming: number;
+  nextUpcoming: { name: string; at: number; timezone: string } | null;
 }
 
 // What the sidebar's Schedules clock says at a glance.
 export function schedulesBadge(schedules: ScheduleView[]): SchedulesBadge {
   let next: SchedulesBadge["next"] = null;
   let failed = 0;
+  let upcoming = 0;
+  let nextUpcoming: SchedulesBadge["nextUpcoming"] = null;
   for (const s of schedules) {
     if (s.lastRun?.outcome === "failed") failed++;
+    if (s.oneOff && s.enabled && !s.done_at) {
+      upcoming++;
+      if (s.nextRunAt && (!nextUpcoming || s.nextRunAt < nextUpcoming.at))
+        nextUpcoming = { name: s.name, at: s.nextRunAt, timezone: s.timezone };
+    }
     if (
       s.enabled &&
       !s.paused &&
@@ -21,5 +31,5 @@ export function schedulesBadge(schedules: ScheduleView[]): SchedulesBadge {
     )
       next = { name: s.name, at: s.nextRunAt, timezone: s.timezone };
   }
-  return { next, failed };
+  return { next, failed, upcoming, nextUpcoming };
 }

package/lib/schedules/cron.ts

@@ -100,7 +100,7 @@ export function isTimezone(tz: string): boolean {
 }
 
 const formatters = new Map<string, Intl.DateTimeFormat>();
-function wall(ms: number, tz: string) {
+export function wall(ms: number, tz: string) {
   let f = formatters.get(tz);
   if (!f) {
     f = new Intl.DateTimeFormat("en-US", {

package/lib/schedules/index.ts

@@ -7,7 +7,13 @@
 
 import { getProject } from "../projects";
 import { resolveSession } from "../bus";
-import { describeCron, everyCron } from "./cron";
+import {
+  DEFAULT_TIMEZONE,
+  describeCron,
+  everyCron,
+  formatRunTime,
+} from "./cron";
+import { parseWhen } from "./when";
 import { runSlot, type RunDeps, type RunResult } from "./run";
 import { nextRunAt } from "./scheduler";
 import { realDeps } from "./start";
@@ -37,12 +43,28 @@ export interface ScheduleView extends Schedule {
   lastRun: ScheduleRun | null;
   // Its workspace's orchestrator is paused, so it skips its slots.
   paused: boolean;
+  oneOff: boolean;
+  // Who made it: Saad, or the agent session (the orchestrator, or another).
+  createdBy: { kind: "saad" | "orchestrator" | "session"; name: string };
+}
+
+function creatorOf(s: Schedule): ScheduleView["createdBy"] {
+  const creator = s.created_by_session_id
+    ? getSessionRow(s.created_by_session_id)
+    : null;
+  if (!creator) return { kind: "saad", name: "Saad" };
+  return creator.role === "orchestrator"
+    ? { kind: "orchestrator", name: "Orchestrator" }
+    : { kind: "session", name: creator.name };
 }
 
 export function scheduleView(s: Schedule, now = Date.now()): ScheduleView {
   return {
     ...s,
-    description: describeCron(s.cron),
+    description:
+      s.run_at != null
+        ? `Once, ${formatRunTime(s.run_at, s.timezone)}`
+        : describeCron(s.cron),
     projectName: s.project_id ? (getProject(s.project_id)?.name ?? null) : null,
     targetName: s.target_session_id
       ? (getSessionRow(s.target_session_id)?.name ?? null)
@@ -50,6 +72,8 @@ export function scheduleView(s: Schedule, now = Date.now()): ScheduleView {
     nextRunAt: nextRunAt(s, now),
     lastRun: lastRun(s.id),
     paused: isPaused(s.workspace_id),
+    oneOff: s.run_at != null,
+    createdBy: creatorOf(s),
   };
 }
 
@@ -65,6 +89,8 @@ export function checkInInput(opts: {
   from?: string | null;
   every?: string;
   cron?: string;
+  // A one-off instead of a cron: "tomorrow 10am", "in 2h", an ISO time.
+  at?: string;
   prompt: string;
   name?: string;
   timezone?: string;
@@ -79,14 +105,26 @@ export function checkInInput(opts: {
     if (sessionWorkspace(creator) !== workspaceId)
       throw new Error(`${session.name} isn't in your workspace`);
   }
-  const cron = opts.cron?.trim() || everyCron(opts.every ?? "30m");
+  if (opts.at && (opts.cron || opts.every))
+    throw new Error("Give a run time (at) or a repeat (every, cron), not both");
+  const tz = opts.timezone?.trim() || DEFAULT_TIMEZONE;
+  const runAt = opts.at ? parseWhen(opts.at, tz) : null;
+  const cron =
+    runAt === null
+      ? opts.cron?.trim() || everyCron(opts.every ?? "30m")
+      : undefined;
   // The workspace's orchestrator is kept as "its orchestrator", not this
   // session's id: each run goes to whichever session is orchestrator then.
   const orchestrator = session.role === "orchestrator";
   return {
     workspaceId,
-    name: opts.name?.trim() || `Check-in: ${session.name}`.slice(0, 80),
+    name:
+      opts.name?.trim() ||
+      (runAt === null
+        ? `Check-in: ${session.name}`.slice(0, 80)
+        : reminderName(workspaceId, runAt, tz)),
     cron,
+    at: runAt,
     timezone: opts.timezone,
     prompt: opts.prompt,
     kind: orchestrator ? "orchestrator" : "message",
@@ -95,12 +133,30 @@ export function checkInInput(opts: {
   };
 }
 
+// "Reminder Tue, Oct 7, 9:00 AM", with a number after it when that's taken.
+export function reminderName(
+  workspaceId: string,
+  runAt: number,
+  tz = DEFAULT_TIMEZONE
+): string {
+  const taken = new Set(
+    listSchedules(workspaceId)
+      .filter((s) => !s.done_at)
+      .map((s) => s.name.toLowerCase())
+  );
+  const base = `Reminder ${formatRunTime(runAt, tz)}`;
+  let name = base;
+  for (let n = 2; taken.has(name.toLowerCase()); n++) name = `${base} (${n})`;
+  return name;
+}
+
 export function scheduleHistory(id: string, limit = 50): ScheduleRun[] {
   return listRuns(id, limit);
 }
 
 // Run now: its own slot, whatever the time and while the last run is still
-// working. Pause holds it like any run.
+// working. Pause holds it like any run. A one-off has one slot, so Run now
+// uses up its only run.
 export async function runNow(
   id: string,
   deps: RunDeps = realDeps
@@ -108,6 +164,11 @@ export async function runNow(
   const schedule = getSchedule(id);
   if (!schedule || schedule.archived_at) throw new Error("Schedule not found");
   const result = await runSlot(schedule, Date.now(), "manual", deps);
-  if (!result) throw new Error("Couldn't claim a run");
+  if (!result)
+    throw new Error(
+      schedule.run_at != null
+        ? "It already ran: edit it to a new time to run it again"
+        : "Couldn't claim a run"
+    );
   return result;
 }

package/lib/schedules/run.ts

@@ -3,6 +3,7 @@ import {
   attachSession,
   brakeRun,
   claimSlot,
+  finishOneOff,
   finishRun,
   lastSettledBefore,
   lastStarted,
@@ -60,8 +61,15 @@ export async function runSlot(
   trigger: RunTrigger,
   deps: RunDeps
 ): Promise<RunResult | null> {
+  // A one-off has one slot, Run now included: the claim is what stops it
+  // running twice.
+  const oneOff = schedule.run_at != null;
+  if (oneOff) slotAt = schedule.run_at!;
   const slot =
-    trigger === "manual" ? `manual:${randomUUID()}` : slotKey(slotAt);
+    trigger === "manual" && !oneOff
+      ? `manual:${randomUUID()}`
+      : slotKey(slotAt);
+  if (oneOff && schedule.done_at) return null;
   const runId = claimSlot(schedule.id, slot, slotAt, trigger);
   if (runId === null) return null;
   const caughtUp = trigger === "catch-up" ? "caught up" : null;
@@ -71,6 +79,7 @@ export async function runSlot(
     sessionId: string | null = null
   ): RunResult => {
     finishRun(runId, outcome, detail, sessionId);
+    if (oneOff) finishOneOff(schedule.id);
     return { runId, outcome, detail, sessionId };
   };
   const joined = (...parts: (string | null)[]) =>
@@ -90,6 +99,16 @@ export async function runSlot(
     return done("failed", why);
   };
 
+  // A recurring run skips while paused; a one-off has only this run, so it's
+  // held like a brake and runs once the workspace resumes.
+  const paused = (): RunResult => {
+    if (!oneOff)
+      return done("skipped", joined(caughtUp, "paused with the orchestrator"));
+    const detail = "held: paused with the orchestrator";
+    brakeRun(runId, detail);
+    return { runId, outcome: "skipped", detail, sessionId: null };
+  };
+
   // Its session is gone and won't come back: the schedule turns itself off
   // and says so once, instead of failing every slot.
   const gone = targetGone(schedule);
@@ -100,9 +119,8 @@ export async function runSlot(
   }
   const target = targetProblem(schedule);
   if (target) return fail(target);
-  if (pausedFor(schedule))
-    return done("skipped", joined(caughtUp, "paused with the orchestrator"));
-  if (trigger !== "manual") {
+  if (pausedFor(schedule)) return paused();
+  if (trigger !== "manual" && !oneOff) {
     const previous = lastStarted(schedule.id, runId);
     if (previous) {
       let busy: boolean;
@@ -128,8 +146,7 @@ export async function runSlot(
   }
 
   // Again: Saad may have paused while the overlap check waited.
-  if (pausedFor(schedule))
-    return done("skipped", joined(caughtUp, "paused with the orchestrator"));
+  if (pausedFor(schedule)) return paused();
   try {
     const started = await deps.start(schedule, (id) =>
       attachSession(runId, id)

package/lib/schedules/scheduler.ts

@@ -23,14 +23,24 @@ export const LATE_MS = 90 * 1000;
 
 // The slot a schedule is due to run now, if any.
 export function dueSlot(schedule: Schedule, now: number): number | null {
-  if (!schedule.enabled || schedule.archived_at) return null;
+  if (!schedule.enabled || schedule.archived_at || schedule.done_at)
+    return null;
+  // A one-off is due from its run time on, whenever AgentOS notices: no
+  // armed_at cut-off, so a run missed while it was off still happens.
+  if (schedule.run_at != null) {
+    if (schedule.run_at > now) return null;
+    return slotTaken(schedule.id, slotKey(schedule.run_at))
+      ? null
+      : schedule.run_at;
+  }
   const slot = prevRun(schedule.cron, now, schedule.timezone);
   if (slot === null || slot <= schedule.armed_at) return null;
   return slotTaken(schedule.id, slotKey(slot)) ? null : slot;
 }
 
 export function nextRunAt(schedule: Schedule, now = Date.now()): number | null {
-  if (!schedule.enabled) return null;
+  if (!schedule.enabled || schedule.done_at) return null;
+  if (schedule.run_at != null) return schedule.run_at;
   return nextRun(
     schedule.cron,
     Math.max(now, schedule.armed_at),

package/lib/schedules/start.ts

@@ -85,15 +85,21 @@ async function startSession(
 // Marked as a schedule's, not something Saad just typed: the orchestrator's
 // brief says it never counts as an approval.
 export function scheduledMessage(
-  schedule: Pick<Schedule, "name" | "prompt">,
+  schedule: Pick<Schedule, "name" | "prompt"> & { run_at?: number | null },
   projectName: string | null,
   // An agent set it up: it's that agent's request, not Saad's.
-  creator?: Pick<Session, "id" | "name"> | null
+  creator?: (Pick<Session, "id" | "name"> & { role?: string | null }) | null
 ): string {
   const where = projectName ? ` for ${projectName}` : "";
-  const who = creator
-    ? `, set up by agent session "${creator.name}" (${creator.id.slice(0, 8)}), not by the user: a peer's request, not an approval`
-    : ", saved in Schedules: a standing prompt, not an approval";
+  const once = schedule.run_at != null;
+  const who =
+    creator?.role === "orchestrator" && once
+      ? ", a reminder you set yourself with remind_me: your own follow-up, not an approval"
+      : creator
+        ? `, set up by agent session "${creator.name}" (${creator.id.slice(0, 8)}), not by the user: a peer's request, not an approval`
+        : once
+          ? ", a one-off reminder saved in Schedules: a prompt, not an approval"
+          : ", saved in Schedules: a standing prompt, not an approval";
   return `[Scheduled message "${schedule.name}"${where}${who}]\n${schedule.prompt}`;
 }
 

package/lib/schedules/store.ts

@@ -10,7 +10,14 @@ import {
   MESSAGE_MIN_GAP_MINUTES,
   MIN_GAP_MINUTES,
   minGapMinutes,
+  formatRunTime,
 } from "./cron";
+import { parseWhen } from "./when";
+
+// Agents can't aim a reminder at themselves sooner than this (a reminder
+// loop), keep more than this many waiting, or set one past a year out.
+export const MAX_AGENT_REMINDERS = 20;
+const MAX_AHEAD_MS = 366 * 86_400_000;
 
 export const SCHEDULE_KINDS = [
   "task",
@@ -29,6 +36,7 @@ export interface Schedule {
   workspace_id: string;
   project_id: string | null;
   name: string;
+  // '' for a one-off (the column is NOT NULL).
   cron: string;
   timezone: string;
   prompt: string;
@@ -41,6 +49,10 @@ export interface Schedule {
   enabled: boolean;
   // Epoch ms: only slots after this run (set on create, enable, cron edit).
   armed_at: number;
+  // A one-off's single run time (epoch ms, UTC), or null when recurring.
+  run_at: number | null;
+  // Set when a one-off's run settled; it's off from then on.
+  done_at: number | null;
   archived_at: string | null;
   created_at: string;
   updated_at: string;
@@ -63,7 +75,10 @@ export interface ScheduleInput {
   workspaceId: string;
   projectId?: string | null;
   name: string;
-  cron: string;
+  // A cron, or `at` for a one-off: exactly one.
+  cron?: string;
+  // A one-off's time: text parseWhen reads (in `timezone`), or epoch ms.
+  at?: string | number | null;
   timezone?: string;
   prompt: string;
   kind: ScheduleKind;
@@ -93,6 +108,30 @@ export function listSchedules(workspaceId?: string | null): Schedule[] {
   return rows.map(toSchedule);
 }
 
+export const isOneOff = (s: Pick<Schedule, "run_at">): boolean =>
+  s.run_at != null;
+
+// One-offs still waiting to run, soonest first.
+export function upcomingOneOffs(workspaceId?: string | null): Schedule[] {
+  return listSchedules(workspaceId)
+    .filter((s) => isOneOff(s) && s.enabled && !s.done_at)
+    .sort((a, b) => a.run_at! - b.run_at!);
+}
+
+// Turns a one-off off once its run settled. True only for the call that did.
+const byOrchestrator = (sessionId: string | null | undefined) =>
+  !!sessionId && getSessionRow(sessionId)?.role === "orchestrator";
+
+export function finishOneOff(id: string, now = Date.now()): boolean {
+  return (
+    db
+      .prepare(
+        `UPDATE schedules SET enabled = 0, done_at = ?, updated_at = datetime('now') WHERE id = ? AND done_at IS NULL`
+      )
+      .run(now, id).changes === 1
+  );
+}
+
 export function getSchedule(id: string): Schedule | null {
   const row = db.prepare(`SELECT * FROM schedules WHERE id = ?`).get(id) as
     | Row
@@ -164,10 +203,18 @@ export function sessionTargetProblem(
   return null;
 }
 
+type Valid = Required<
+  Omit<ScheduleInput, "createdBySessionId" | "cron" | "at">
+> & { cron: string; runAt: number | null };
+
+// `keepPast`: a run time already accepted, allowed to stay once it has passed
+// (renaming a done one-off).
 function validate(
   input: ScheduleInput,
-  selfId?: string
-): Required<Omit<ScheduleInput, "createdBySessionId">> {
+  selfId?: string,
+  now = Date.now(),
+  keepPast: number | null = null
+): Valid {
   const name = input.name?.trim();
   if (!name) throw new Error("Give the schedule a name");
   if (name.length > 80) throw new Error("Keep the name under 80 characters");
@@ -178,11 +225,50 @@ function validate(
   if (!prompt) throw new Error("Write the prompt it runs");
   if (!SCHEDULE_KINDS.includes(input.kind))
     throw new Error("Pick task, session, orchestrator or message");
-  const cron = input.cron?.trim().replace(/\s+/g, " ");
-  const bad = cronError(cron ?? "");
-  if (bad) throw new Error(bad);
   const timezone = input.timezone?.trim() || DEFAULT_TIMEZONE;
   if (!isTimezone(timezone)) throw new Error(`Unknown time zone "${timezone}"`);
+  const cronText = input.cron?.trim().replace(/\s+/g, " ") ?? "";
+  const oneOff = input.at != null && input.at !== "";
+  if (oneOff && cronText)
+    throw new Error("Give a cron or a run time, not both");
+  if (!oneOff && !cronText) throw new Error("Needs a cron or a run time");
+  const runAt = oneOff
+    ? typeof input.at === "number"
+      ? input.at
+      : parseWhen(input.at as string, timezone, now)
+    : null;
+  if (runAt !== null) {
+    if (!Number.isFinite(runAt)) throw new Error("Pick a run time");
+    if (runAt <= now && runAt !== keepPast)
+      throw new Error(
+        `That time has passed (${formatRunTime(runAt, timezone)}): pick a time ahead`
+      );
+    if (runAt - now > MAX_AHEAD_MS)
+      throw new Error("A one-off can be at most a year ahead");
+    if (
+      input.createdBySessionId &&
+      runAt !== keepPast &&
+      runAt - now < MESSAGE_MIN_GAP_MINUTES * 60_000
+    )
+      throw new Error(
+        `A reminder must be at least ${MESSAGE_MIN_GAP_MINUTES} minutes ahead`
+      );
+    // The cap is on the orchestrator's remind_me reminders; a session's own
+    // `aos schedule add --at` isn't counted.
+    if (
+      !selfId &&
+      byOrchestrator(input.createdBySessionId) &&
+      upcomingOneOffs(input.workspaceId).filter((s) =>
+        byOrchestrator(s.created_by_session_id)
+      ).length >= MAX_AGENT_REMINDERS
+    )
+      throw new Error(
+        `At most ${MAX_AGENT_REMINDERS} reminders can wait at once: cancel one first`
+      );
+  }
+  const cron = cronText;
+  const bad = oneOff ? null : cronError(cron);
+  if (bad) throw new Error(bad);
   if (!getWorkspace(input.workspaceId)) throw new Error("Pick a workspace");
   const message = input.kind === "message";
   // A message goes to a session, whatever project it's in.
@@ -208,6 +294,7 @@ function validate(
     throw new Error("A task or session schedule needs a project");
   }
   if (
+    !oneOff &&
     (input.kind === "task" || input.kind === "session") &&
     minGapMinutes(cron, timezone) < MIN_GAP_MINUTES
   )
@@ -218,6 +305,7 @@ function validate(
   const agentCheckIn =
     input.kind === "orchestrator" && !!input.createdBySessionId;
   if (
+    !oneOff &&
     (message || agentCheckIn) &&
     minGapMinutes(cron, timezone) < MESSAGE_MIN_GAP_MINUTES
   )
@@ -225,7 +313,10 @@ function validate(
       `A message schedule runs at most every ${MESSAGE_MIN_GAP_MINUTES} minutes`
     );
   const clash = listSchedules(input.workspaceId).find(
-    (s) => s.id !== selfId && s.name.toLowerCase() === name.toLowerCase()
+    (s) =>
+      s.id !== selfId &&
+      !s.done_at &&
+      s.name.toLowerCase() === name.toLowerCase()
   );
   if (clash)
     throw new Error(`There's already a schedule called "${clash.name}"`);
@@ -239,6 +330,7 @@ function validate(
     kind: input.kind,
     targetSessionId,
     enabled: input.enabled ?? true,
+    runAt,
   };
 }
 
@@ -246,11 +338,11 @@ export function createSchedule(
   input: ScheduleInput,
   now = Date.now()
 ): Schedule {
-  const v = validate(input);
+  const v = validate(input, undefined, now);
   const id = randomUUID();
   db.prepare(
-    `INSERT INTO schedules (id, workspace_id, project_id, name, cron, timezone, prompt, kind, target_session_id, created_by_session_id, enabled, armed_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    `INSERT INTO schedules (id, workspace_id, project_id, name, cron, timezone, prompt, kind, target_session_id, created_by_session_id, enabled, armed_at, run_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
   ).run(
     id,
     v.workspaceId,
@@ -263,7 +355,8 @@ export function createSchedule(
     v.targetSessionId,
     input.createdBySessionId ?? null,
     v.enabled ? 1 : 0,
-    now
+    now,
+    v.runAt
   );
   return getSchedule(id)!;
 }
@@ -281,7 +374,11 @@ export function updateSchedule(
       projectId:
         patch.projectId === undefined ? current.project_id : patch.projectId,
       name: patch.name ?? current.name,
-      cron: patch.cron ?? current.cron,
+      // A patch with a cron makes it recurring; one with `at`, a one-off.
+      cron:
+        patch.cron ??
+        (patch.at != null ? undefined : current.cron || undefined),
+      at: patch.at ?? (patch.cron != null ? null : current.run_at),
       timezone: patch.timezone ?? current.timezone,
       prompt: patch.prompt ?? current.prompt,
       kind: patch.kind ?? current.kind,
@@ -292,17 +389,27 @@ export function updateSchedule(
       enabled: patch.enabled ?? current.enabled,
       createdBySessionId: current.created_by_session_id,
     },
-    id
+    id,
+    now,
+    current.done_at || current.enabled ? current.run_at : null
   );
+  // A one-off moved to a new time opens again, even if it had run.
+  const reopen = v.runAt !== null && v.runAt !== current.run_at;
+  const enabled = reopen
+    ? (patch.enabled ?? true)
+    : v.runAt !== null && current.done_at
+      ? false
+      : v.enabled;
   // A new time or a fresh enable starts counting from now: no slot from
   // before it is "missed".
   const rearm =
     v.cron !== current.cron ||
+    v.runAt !== current.run_at ||
     v.timezone !== current.timezone ||
-    (v.enabled && !current.enabled);
+    (enabled && !current.enabled);
   db.prepare(
     `UPDATE schedules SET workspace_id = ?, project_id = ?, name = ?, cron = ?, timezone = ?,
-       prompt = ?, kind = ?, target_session_id = ?, enabled = ?, armed_at = ?, updated_at = datetime('now')
+       prompt = ?, kind = ?, target_session_id = ?, enabled = ?, armed_at = ?, run_at = ?, done_at = ?, updated_at = datetime('now')
      WHERE id = ?`
   ).run(
     v.workspaceId,
@@ -313,8 +420,10 @@ export function updateSchedule(
     v.prompt,
     v.kind,
     v.targetSessionId,
-    v.enabled ? 1 : 0,
+    enabled ? 1 : 0,
     rearm ? now : current.armed_at,
+    v.runAt,
+    reopen || v.runAt === null ? null : current.done_at,
     id
   );
   return getSchedule(id)!;
@@ -546,6 +655,14 @@ export function failAbandonedClaims(
   now = Date.now()
 ): number {
   const before = Math.floor((now - olderThanMs) / 1000);
+  // A one-off whose only run was cut off won't come round again: finish it
+  // here so it leaves Upcoming and stops counting toward the reminder cap.
+  db.prepare(
+    `UPDATE schedules SET enabled = 0, done_at = ?, updated_at = datetime('now')
+     WHERE run_at IS NOT NULL AND done_at IS NULL AND id IN (
+       SELECT schedule_id FROM schedule_runs
+       WHERE outcome = 'claimed' AND created_at < datetime(?, 'unixepoch'))`
+  ).run(now, before);
   const started = db
     .prepare(
       `UPDATE schedule_runs SET outcome = 'started', detail = 'AgentOS restarted while it was starting'