opencode-scheduled 0.1.0

package/README.md

@@ -0,0 +1,58 @@
+# OpenCode Scheduled
+
+Schedule prompts from inside OpenCode with `/schedule`.
+
+## Install
+
+Recommended:
+
+```bash
+opencode plugin -g opencode-scheduled
+```
+
+Manual install:
+
+For a global manual install, add the plugin to both `~/.config/opencode/opencode.json` and `~/.config/opencode/tui.json`.
+
+`~/.config/opencode/opencode.json`
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": ["opencode-scheduled"]
+}
+```
+
+`~/.config/opencode/tui.json`
+
+```json
+{
+  "$schema": "https://opencode.ai/tui.json",
+  "plugin": ["opencode-scheduled"]
+}
+```
+
+For local development, point both plugin lists at this checkout path.
+
+## Use It
+
+Open the scheduler with either:
+
+- `/schedule`
+- `/schedule <prompt>`
+- `/schedule in 30m <prompt>`
+- `/schedule at 3:30am <prompt>`
+- `/schedule today 14:00 <prompt>`
+- `/schedule tomorrow 9am <prompt>`
+- Command palette -> `Schedule Prompt`
+
+Inside the dialog, choose when the prompt should be sent, review pending items, and cancel schedules. Pending items are shown by task ID and date.
+
+The sidebar also shows pending prompts for the current session by task ID and date. Use the scheduler dialog to pause or resume delivery. When paused, due prompts stay pending until the scheduler is resumed.
+
+## Notes
+
+- Schedules are stored locally in the platform state directory. Set `OPENCODE_SCHEDULED_HOME` to override the storage directory.
+- Delivery targets the OpenCode session that was active when the prompt was scheduled.
+- Delivery requires OpenCode to be running. If OpenCode is closed at the scheduled time, the prompt will not send until OpenCode is opened again and the plugin timer runs.
+- Failed deliveries are marked as failed rather than retried automatically.

package/index.ts

@@ -0,0 +1 @@
+export { default } from "./src/server.ts";

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "opencode-scheduled",
+  "version": "0.1.0",
+  "description": "OpenCode plugin for scheduling prompts from the TUI.",
+  "type": "module",
+  "main": "./index.ts",
+  "module": "./index.ts",
+  "exports": {
+    ".": {
+      "import": "./index.ts"
+    },
+    "./server": {
+      "import": "./src/server.ts"
+    },
+    "./tui": {
+      "import": "./src/tui.tsx"
+    }
+  },
+  "files": [
+    "index.ts",
+    "src",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Dylan-Liew/opencode-scheduled.git"
+  },
+  "homepage": "https://github.com/Dylan-Liew/opencode-scheduled#readme",
+  "bugs": {
+    "url": "https://github.com/Dylan-Liew/opencode-scheduled/issues"
+  },
+  "keywords": [
+    "opencode",
+    "plugin",
+    "schedule",
+    "prompt",
+    "tui"
+  ],
+  "author": "Dylan Liew",
+  "license": "MIT",
+  "scripts": {
+    "test": "tsc -p tsconfig.json --noEmit"
+  },
+  "devDependencies": {
+    "@opencode-ai/plugin": "^1.17.4",
+    "@opentui/core": "^0.3.4",
+    "@opentui/keymap": "^0.3.4",
+    "@opentui/solid": "^0.3.4",
+    "@types/bun": "latest",
+    "@types/node": "^24.3.0",
+    "typescript": "^5.9.3"
+  }
+}

package/src/constants.ts

@@ -0,0 +1,3 @@
+export const PLUGIN_ID = "opencode-scheduled";
+export const SCHEDULE_COMMAND_OPEN = "plugin.scheduled.open";
+export const HANDLED_SENTINEL = "__SCHEDULED_HANDLED__";

package/src/format.ts

@@ -0,0 +1,14 @@
+import type { ScheduledPrompt } from "./types.ts";
+
+export function taskID(job: ScheduledPrompt): string {
+  return `#${job.id.slice(0, 8)}`;
+}
+
+export function formatCompactDate(runAt: number): string {
+  return new Intl.DateTimeFormat(undefined, {
+    month: "short",
+    day: "numeric",
+    hour: "numeric",
+    minute: "2-digit",
+  }).format(new Date(runAt));
+}

package/src/scheduler-events.ts

@@ -0,0 +1,14 @@
+type SchedulerChangeListener = () => void;
+
+const listeners = new Set<SchedulerChangeListener>();
+
+export function onSchedulerChange(listener: SchedulerChangeListener): () => void {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+
+export function emitSchedulerChange(): void {
+  for (const listener of listeners) {
+    listener();
+  }
+}

package/src/scheduler.ts

@@ -0,0 +1,149 @@
+import type { TuiPluginApi } from "@opencode-ai/plugin/tui";
+import { emitSchedulerChange } from "./scheduler-events.ts";
+import { createScheduledPrompt, readStore, updateStore } from "./store.ts";
+import { formatRunAt } from "./time.ts";
+import type { ScheduledPrompt } from "./types.ts";
+
+export const TICK_MS = 15_000;
+export const SIDEBAR_MAX_JOBS = 6;
+
+export interface ScheduleDialogState {
+  jobs: ScheduledPrompt[];
+  paused: boolean;
+}
+
+export function currentSessionID(api: TuiPluginApi): string | undefined {
+  if (api.route.current.name !== "session") {
+    return undefined;
+  }
+
+  const sessionID = api.route.current.params?.sessionID;
+  return typeof sessionID === "string" ? sessionID : undefined;
+}
+
+export function sortPending(left: ScheduledPrompt, right: ScheduledPrompt): number {
+  return left.runAt - right.runAt || left.createdAt - right.createdAt;
+}
+
+export async function loadSchedulerState(): Promise<ScheduleDialogState> {
+  const store = await readStore();
+  return {
+    jobs: store.jobs.filter((job) => job.status === "pending").sort(sortPending),
+    paused: store.settings.paused,
+  };
+}
+
+export async function addScheduledPrompt(api: TuiPluginApi, prompt: string, runAt: number): Promise<void> {
+  const sessionID = currentSessionID(api);
+  if (!sessionID) {
+    api.ui.toast({ message: "Open a session before scheduling a prompt", variant: "error", duration: 3000 });
+    return;
+  }
+
+  const job = createScheduledPrompt({ prompt, runAt, sessionID });
+  await updateStore((store) => ({
+    ...store,
+    jobs: [job, ...store.jobs],
+  }));
+  emitSchedulerChange();
+  api.ui.toast({ message: `Scheduled for ${formatRunAt(runAt)}`, variant: "success", duration: 3000 });
+}
+
+export async function toggleSchedulerPause(api: TuiPluginApi): Promise<boolean> {
+  const store = await updateStore((current) => ({
+    ...current,
+    settings: {
+      paused: !current.settings.paused,
+    },
+  }));
+
+  api.ui.toast({
+    message: store.settings.paused ? "Scheduler paused" : "Scheduler resumed",
+    variant: store.settings.paused ? "warning" : "success",
+    duration: 2500,
+  });
+  emitSchedulerChange();
+
+  return store.settings.paused;
+}
+
+export async function cancelScheduledPrompt(api: TuiPluginApi, job: ScheduledPrompt): Promise<void> {
+  await updateStore((store) => ({
+    ...store,
+    jobs: store.jobs.map((current) =>
+      current.id === job.id
+        ? {
+            ...current,
+            status: "canceled",
+            canceledAt: Date.now(),
+          }
+        : current,
+    ),
+  }));
+  emitSchedulerChange();
+  api.ui.toast({ message: "Scheduled prompt canceled", variant: "success", duration: 2500 });
+}
+
+async function deliverJob(api: TuiPluginApi, job: ScheduledPrompt): Promise<void> {
+  const sessionID = job.sessionID ?? currentSessionID(api);
+  if (!sessionID) {
+    throw new Error("No session available for schedule");
+  }
+
+  const result = await api.client.session.promptAsync({
+    sessionID,
+    parts: [{ type: "text", text: job.prompt }],
+  });
+
+  if (result.error) {
+    throw new Error("Failed to send schedule");
+  }
+}
+
+export async function deliverDuePrompts(api: TuiPluginApi): Promise<void> {
+  const store = await readStore();
+  if (store.settings.paused) {
+    return;
+  }
+
+  const now = Date.now();
+  const due = store.jobs.filter((job) => job.status === "pending" && job.runAt <= now);
+  for (const job of due) {
+    try {
+      await deliverJob(api, job);
+      await updateStore((current) => ({
+        ...current,
+        jobs: current.jobs.map((item) =>
+          item.id === job.id
+            ? {
+                ...item,
+                status: "sent",
+                sentAt: Date.now(),
+                lastAttemptAt: Date.now(),
+                error: undefined,
+              }
+            : item,
+        ),
+      }));
+      emitSchedulerChange();
+      api.ui.toast({ message: "Scheduled prompt sent", variant: "success", duration: 2500 });
+      void api.attention.notify({ message: "Scheduled prompt sent", sound: { name: "done", when: "blurred" }, notification: { when: "blurred" } });
+    } catch (error) {
+      await updateStore((current) => ({
+        ...current,
+        jobs: current.jobs.map((item) =>
+          item.id === job.id
+            ? {
+                ...item,
+                status: "failed",
+                lastAttemptAt: Date.now(),
+                error: error instanceof Error ? error.message : String(error),
+              }
+            : item,
+        ),
+      }));
+      emitSchedulerChange();
+      api.ui.toast({ message: "Scheduled prompt failed", variant: "error", duration: 3000 });
+    }
+  }
+}

package/src/server.ts

@@ -0,0 +1,41 @@
+import type { Hooks, PluginInput, PluginModule } from "@opencode-ai/plugin";
+import { HANDLED_SENTINEL, PLUGIN_ID, SCHEDULE_COMMAND_OPEN } from "./constants.ts";
+import { saveDraftPrompt } from "./store.ts";
+
+function isScheduleCommand(command: string): boolean {
+  return command.replace(/^\//, "") === "schedule";
+}
+
+async function openScheduler(input: PluginInput, prompt: string): Promise<void> {
+  if (prompt.trim()) {
+    await saveDraftPrompt(prompt);
+  }
+
+  const result = await input.client.tui.executeCommand({
+    body: { command: SCHEDULE_COMMAND_OPEN },
+  });
+
+  if (result.error || result.data !== true) {
+    throw new Error("Scheduled prompt dialog unavailable. Ensure the TUI plugin is loaded.");
+  }
+}
+
+export async function ScheduledPromptPlugin(pluginInput: PluginInput): Promise<Hooks> {
+  return {
+    "command.execute.before": async (input) => {
+      if (!isScheduleCommand(input.command)) {
+        return;
+      }
+
+      await openScheduler(pluginInput, input.arguments);
+      throw new Error(HANDLED_SENTINEL);
+    },
+  };
+}
+
+const module: PluginModule & { id: string } = {
+  id: PLUGIN_ID,
+  server: ScheduledPromptPlugin,
+};
+
+export default module;

package/src/store.ts

@@ -0,0 +1,125 @@
+import { mkdir, readFile, rename, writeFile } from "fs/promises";
+import { dirname, join } from "path";
+import { randomUUID } from "crypto";
+import type { ScheduledPrompt, SchedulerStore } from "./types.ts";
+
+const STORE_FILE = "schedules.json";
+
+function stateRoot(): string {
+  if (process.env.OPENCODE_SCHEDULED_HOME) {
+    return process.env.OPENCODE_SCHEDULED_HOME;
+  }
+
+  if (process.platform === "win32" && process.env.APPDATA) {
+    return join(process.env.APPDATA, "opencode-scheduled");
+  }
+
+  if (process.env.XDG_STATE_HOME) {
+    return join(process.env.XDG_STATE_HOME, "opencode-scheduled");
+  }
+
+  return join(process.env.HOME ?? process.cwd(), ".local", "state", "opencode-scheduled");
+}
+
+export function storePath(): string {
+  return join(stateRoot(), STORE_FILE);
+}
+
+function emptyStore(): SchedulerStore {
+  return {
+    version: 1,
+    jobs: [],
+    settings: {
+      paused: false,
+    },
+  };
+}
+
+function normalizeStore(value: unknown): SchedulerStore {
+  const fallback = emptyStore();
+  if (!value || typeof value !== "object") {
+    return fallback;
+  }
+
+  const record = value as Partial<SchedulerStore>;
+  const jobs = Array.isArray(record.jobs)
+    ? record.jobs.filter((job): job is ScheduledPrompt => {
+        return (
+          Boolean(job) &&
+          typeof job === "object" &&
+          typeof job.id === "string" &&
+          typeof job.prompt === "string" &&
+          typeof job.runAt === "number" &&
+          typeof job.createdAt === "number" &&
+          (job.status === "pending" || job.status === "sent" || job.status === "canceled" || job.status === "failed")
+        );
+      })
+    : [];
+
+  return {
+    version: 1,
+    draftPrompt: typeof record.draftPrompt === "string" ? record.draftPrompt : undefined,
+    jobs,
+    settings: {
+      paused: record.settings?.paused === true,
+    },
+  };
+}
+
+export async function readStore(): Promise<SchedulerStore> {
+  try {
+    const raw = await readFile(storePath(), "utf8");
+    return normalizeStore(JSON.parse(raw));
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+      return emptyStore();
+    }
+
+    throw error;
+  }
+}
+
+export async function writeStore(store: SchedulerStore): Promise<void> {
+  const path = storePath();
+  await mkdir(dirname(path), { recursive: true });
+  const tempPath = `${path}.${process.pid}.tmp`;
+  await writeFile(tempPath, `${JSON.stringify(store, null, 2)}\n`, "utf8");
+  await rename(tempPath, path);
+}
+
+export async function updateStore(update: (store: SchedulerStore) => SchedulerStore): Promise<SchedulerStore> {
+  const next = update(await readStore());
+  await writeStore(next);
+  return next;
+}
+
+export async function saveDraftPrompt(prompt: string): Promise<void> {
+  await updateStore((store) => ({
+    ...store,
+    draftPrompt: prompt.trim() || undefined,
+  }));
+}
+
+export async function takeDraftPrompt(): Promise<string | undefined> {
+  let draft: string | undefined;
+  await updateStore((store) => {
+    draft = store.draftPrompt;
+    return {
+      ...store,
+      draftPrompt: undefined,
+    };
+  });
+
+  return draft;
+}
+
+export function createScheduledPrompt(input: { prompt: string; runAt: number; sessionID?: string }): ScheduledPrompt {
+  return {
+    id: randomUUID(),
+    prompt: input.prompt,
+    runAt: input.runAt,
+    createdAt: Date.now(),
+    status: "pending",
+    sessionID: input.sessionID,
+  };
+}

package/src/time.ts

@@ -0,0 +1,136 @@
+export interface ParsedScheduleRequest {
+  prompt: string;
+  runAt?: number;
+}
+
+const MINUTE_MS = 60_000;
+const HOUR_MS = 60 * MINUTE_MS;
+const DAY_MS = 24 * HOUR_MS;
+
+function setClock(date: Date, hour: number, minute: number): Date {
+  const next = new Date(date);
+  next.setHours(hour, minute, 0, 0);
+  return next;
+}
+
+function parseClock(value: string): { hour: number; minute: number } | undefined {
+  const match = value.trim().match(/^(\d{1,2})(?::(\d{2}))?\s*(am|pm)?$/i);
+  if (!match) {
+    return undefined;
+  }
+
+  let hour = Number(match[1]);
+  const minute = match[2] ? Number(match[2]) : 0;
+  const meridiem = match[3]?.toLowerCase();
+  if (hour > 23 || minute > 59) {
+    return undefined;
+  }
+
+  if (meridiem) {
+    if (hour < 1 || hour > 12) {
+      return undefined;
+    }
+
+    hour = hour % 12;
+    if (meridiem === "pm") {
+      hour += 12;
+    }
+  }
+
+  return { hour, minute };
+}
+
+function capture(match: RegExpMatchArray, index: number): string {
+  return match[index] ?? "";
+}
+
+export function formatRunAt(runAt: number): string {
+  return new Intl.DateTimeFormat(undefined, {
+    dateStyle: "medium",
+    timeStyle: "short",
+  }).format(new Date(runAt));
+}
+
+export function parseTimeSpec(spec: string, now = new Date()): number | undefined {
+  const input = spec.trim().replace(/\s+/g, " ");
+  if (!input) {
+    return undefined;
+  }
+
+  const relative = input.match(/^in\s+(\d+)\s*(s|sec|secs|second|seconds|m|min|mins|minute|minutes|h|hr|hrs|hour|hours|d|day|days)$/i);
+  if (relative) {
+    const amount = Number(capture(relative, 1));
+    const unit = capture(relative, 2).toLowerCase();
+    const multiplier = unit.startsWith("s") ? 1000 : unit.startsWith("m") ? MINUTE_MS : unit.startsWith("h") ? HOUR_MS : DAY_MS;
+    return now.getTime() + amount * multiplier;
+  }
+
+  const dayClock = input.match(/^(today|tomorrow)\s+(.+)$/i);
+  if (dayClock) {
+    const clock = parseClock(capture(dayClock, 2));
+    if (!clock) {
+      return undefined;
+    }
+
+    const base = new Date(now);
+    if (capture(dayClock, 1).toLowerCase() === "tomorrow") {
+      base.setDate(base.getDate() + 1);
+    }
+
+    const target = setClock(base, clock.hour, clock.minute);
+    return target.getTime() > now.getTime() ? target.getTime() : undefined;
+  }
+
+  const clock = parseClock(input.replace(/^at\s+/i, ""));
+  if (clock) {
+    let target = setClock(now, clock.hour, clock.minute);
+    if (target.getTime() <= now.getTime()) {
+      target = new Date(target.getTime() + DAY_MS);
+    }
+
+    return target.getTime();
+  }
+
+  const isoLike = input.match(/^(\d{4}-\d{2}-\d{2})(?:[ t](\d{1,2}:\d{2})(?:\s*(am|pm))?)?$/i);
+  if (isoLike) {
+    const suffix = isoLike[2] ? ` ${isoLike[2]}${isoLike[3] ? ` ${isoLike[3]}` : ""}` : "";
+    const parsed = new Date(`${capture(isoLike, 1)}${suffix}`);
+    return Number.isFinite(parsed.getTime()) && parsed.getTime() > now.getTime() ? parsed.getTime() : undefined;
+  }
+
+  const parsed = new Date(input);
+  return Number.isFinite(parsed.getTime()) && parsed.getTime() > now.getTime() ? parsed.getTime() : undefined;
+}
+
+export function parseScheduleRequest(raw: string, now = new Date()): ParsedScheduleRequest {
+  const input = raw.trim();
+  if (!input) {
+    return { prompt: "" };
+  }
+
+  const relative = input.match(/^(in\s+\d+\s*(?:s|sec|secs|second|seconds|m|min|mins|minute|minutes|h|hr|hrs|hour|hours|d|day|days))\s+(.+)$/i);
+  if (relative) {
+    return {
+      runAt: parseTimeSpec(capture(relative, 1), now),
+      prompt: capture(relative, 2).trim(),
+    };
+  }
+
+  const dayClock = input.match(/^((?:today|tomorrow)\s+\d{1,2}(?::\d{2})?\s*(?:am|pm)?)\s+(.+)$/i);
+  if (dayClock) {
+    return {
+      runAt: parseTimeSpec(capture(dayClock, 1), now),
+      prompt: capture(dayClock, 2).trim(),
+    };
+  }
+
+  const atClock = input.match(/^at\s+(\d{1,2}(?::\d{2})?\s*(?:am|pm)?)\s+(.+)$/i);
+  if (atClock) {
+    return {
+      runAt: parseTimeSpec(capture(atClock, 1), now),
+      prompt: capture(atClock, 2).trim(),
+    };
+  }
+
+  return { prompt: input };
+}

package/src/tui/SchedulerManagerDialog.tsx

@@ -0,0 +1,340 @@
+/** @jsxImportSource @opentui/solid */
+import { TextAttributes, type KeyEvent, type MouseEvent, type Renderable } from "@opentui/core";
+import { useKeyboard, useTerminalDimensions } from "@opentui/solid";
+import type { TuiPluginApi } from "@opencode-ai/plugin/tui";
+import { createEffect, createSignal, For, onCleanup, onMount, Show } from "solid-js";
+import { SCHEDULE_COMMAND_OPEN } from "../constants.ts";
+import { formatCompactDate, taskID } from "../format.ts";
+import type { ScheduledPrompt } from "../types.ts";
+import { clickPrimary } from "./ui.ts";
+
+export interface SchedulerManagerDialogProps {
+  api: TuiPluginApi;
+  initialJobs: ScheduledPrompt[];
+  initialPaused: boolean;
+  loadJobs: () => Promise<{ jobs: ScheduledPrompt[]; paused: boolean }>;
+  onAdd: () => void;
+  onCancel: (job: ScheduledPrompt) => void;
+  onTogglePause: () => Promise<boolean>;
+}
+
+export function SchedulerManagerDialog(props: SchedulerManagerDialogProps) {
+  const theme = props.api.theme.current;
+  const dimensions = useTerminalDimensions();
+  const [jobs, setJobs] = createSignal(props.initialJobs);
+  const [paused, setPaused] = createSignal(props.initialPaused);
+  const [selectedIndex, setSelectedIndex] = createSignal(0);
+  const [busy, setBusy] = createSignal(false);
+  const [hoveredAction, setHoveredAction] = createSignal<string | undefined>();
+  const handledKeys = new WeakSet<KeyEvent>();
+  let root: Renderable | undefined;
+
+  const selected = () => jobs()[selectedIndex()];
+
+  const moveSelection = (direction: number) => {
+    setSelectedIndex((current) => Math.max(0, Math.min(current + direction, Math.max(0, jobs().length - 1))));
+  };
+
+  const loadCurrentJobs = async () => {
+    const state = await props.loadJobs();
+    setJobs(state.jobs);
+    setPaused(state.paused);
+    setSelectedIndex((current) => Math.max(0, Math.min(current, Math.max(0, state.jobs.length - 1))));
+  };
+
+  const addPrompt = () => {
+    if (!busy()) {
+      props.onAdd();
+    }
+  };
+
+  const toggleDialogPause = () => {
+    if (busy()) {
+      return;
+    }
+
+    setBusy(true);
+    void props
+      .onTogglePause()
+      .then((nextPaused) => setPaused(nextPaused))
+      .finally(() => setBusy(false));
+  };
+
+  const cancelSelected = () => {
+    const job = selected();
+    if (job && !busy()) {
+      props.onCancel(job);
+    }
+  };
+
+  onMount(() => {
+    void loadCurrentJobs();
+    setTimeout(() => {
+      if (!root || root.isDestroyed) {
+        return;
+      }
+
+      root.focus();
+    }, 25);
+  });
+
+  createEffect(() => {
+    props.api.ui.dialog.setSize(dimensions().width >= 120 ? "large" : "medium");
+  });
+
+  const handleKeyDown = (event: KeyEvent) => {
+    if (handledKeys.has(event) || event.eventType !== "press" || busy()) {
+      return;
+    }
+
+    const key = event.name.toLowerCase();
+
+    if (!event.ctrl && !event.meta && !event.option && key === "a") {
+      if (event.repeated) {
+        return;
+      }
+
+      handledKeys.add(event);
+      event.preventDefault();
+      event.stopPropagation();
+      addPrompt();
+      return;
+    }
+
+    if (!event.ctrl && !event.meta && !event.option && key === "p") {
+      if (event.repeated) {
+        return;
+      }
+
+      handledKeys.add(event);
+      event.preventDefault();
+      event.stopPropagation();
+      toggleDialogPause();
+      return;
+    }
+
+    if (event.ctrl && key === "d") {
+      if (event.repeated) {
+        return;
+      }
+
+      handledKeys.add(event);
+      event.preventDefault();
+      event.stopPropagation();
+      cancelSelected();
+      return;
+    }
+
+    if (event.defaultPrevented) {
+      return;
+    }
+
+    if (key === "down" || key === "arrowdown") {
+      handledKeys.add(event);
+      event.preventDefault();
+      event.stopPropagation();
+      moveSelection(1);
+      return;
+    }
+
+    if (key === "up" || key === "arrowup") {
+      handledKeys.add(event);
+      event.preventDefault();
+      event.stopPropagation();
+      moveSelection(-1);
+      return;
+    }
+
+    if (key === "return" || key === "enter") {
+      if (event.repeated) {
+        return;
+      }
+
+      handledKeys.add(event);
+      event.preventDefault();
+      event.stopPropagation();
+      cancelSelected();
+    }
+  };
+
+  const disposeKeybinds = props.api.keymap.registerLayer({
+    priority: 10,
+    commands: [
+      {
+        name: "dialog.select.prev",
+        title: "Previous scheduled prompt",
+        category: "Dialog",
+        run: () => moveSelection(-1),
+      },
+      {
+        name: "dialog.select.next",
+        title: "Next scheduled prompt",
+        category: "Dialog",
+        run: () => moveSelection(1),
+      },
+      {
+        name: "dialog.select.submit",
+        title: "Cancel scheduled prompt",
+        category: "Dialog",
+        run: cancelSelected,
+      },
+      {
+        name: `${SCHEDULE_COMMAND_OPEN}.add`,
+        title: "Add scheduled prompt",
+        category: "Dialog",
+        run: addPrompt,
+      },
+      {
+        name: `${SCHEDULE_COMMAND_OPEN}.pause`,
+        title: "Pause scheduled prompts",
+        category: "Dialog",
+        run: toggleDialogPause,
+      },
+      {
+        name: `${SCHEDULE_COMMAND_OPEN}.delete`,
+        title: "Cancel scheduled prompt",
+        category: "Dialog",
+        run: cancelSelected,
+      },
+    ],
+    bindings: [
+      ...props.api.tuiConfig.keybinds.gather("dialog.select", [
+        "dialog.select.prev",
+        "dialog.select.next",
+        "dialog.select.submit",
+      ]),
+      { key: "a", cmd: `${SCHEDULE_COMMAND_OPEN}.add`, desc: "Add scheduled prompt" },
+      { key: "p", cmd: `${SCHEDULE_COMMAND_OPEN}.pause`, desc: "Pause scheduled prompts" },
+      { key: "ctrl+d", cmd: `${SCHEDULE_COMMAND_OPEN}.delete`, desc: "Cancel scheduled prompt" },
+    ],
+  });
+  onCleanup(disposeKeybinds);
+
+  useKeyboard(handleKeyDown);
+
+  return (
+    <box width="100%" flexDirection="column" gap={0} focusable focused onKeyDown={handleKeyDown} ref={(value) => (root = value)}>
+      <box paddingLeft={4} paddingRight={4} paddingBottom={1} flexDirection="column" gap={1}>
+        <box flexDirection="row" justifyContent="space-between">
+          <box flexDirection="column" gap={0}>
+            <text fg={theme.text} attributes={TextAttributes.BOLD}>
+              Scheduled Prompts
+            </text>
+            <text fg={theme.textMuted}>enter cancel · a add · p {paused() ? "resume" : "pause"}</text>
+          </box>
+          <box flexDirection="row" gap={2}>
+            <text
+              fg={hoveredAction() === "add" ? theme.text : theme.primary}
+              onMouseOver={() => setHoveredAction("add")}
+              onMouseOut={() => setHoveredAction(undefined)}
+              onMouseUp={(event: MouseEvent) => {
+                if (clickPrimary(event)) {
+                  addPrompt();
+                }
+              }}
+            >
+              add
+            </text>
+            <text
+              fg={hoveredAction() === "pause" ? theme.text : paused() ? theme.success : theme.warning}
+              onMouseOver={() => setHoveredAction("pause")}
+              onMouseOut={() => setHoveredAction(undefined)}
+              onMouseUp={(event: MouseEvent) => {
+                if (clickPrimary(event)) {
+                  toggleDialogPause();
+                }
+              }}
+            >
+              {paused() ? "resume" : "pause"}
+            </text>
+            <text
+              fg={hoveredAction() === "esc" ? theme.text : theme.textMuted}
+              onMouseOver={() => setHoveredAction("esc")}
+              onMouseOut={() => setHoveredAction(undefined)}
+              onMouseUp={() => props.api.ui.dialog.clear()}
+            >
+              esc
+            </text>
+          </box>
+        </box>
+
+        <Show when={busy()}>
+          <text fg={theme.warning}>Working...</text>
+        </Show>
+      </box>
+
+      <scrollbox paddingLeft={4} paddingRight={4} maxHeight={Math.max(10, Math.floor(dimensions().height * 0.45))}>
+        <Show
+          when={jobs().length > 0}
+          fallback={
+            <box width="100%" paddingTop={2} paddingBottom={2} flexDirection="row" justifyContent="center">
+              <text fg={theme.textMuted}>No scheduled prompts</text>
+            </box>
+          }
+        >
+          <box flexDirection="column" gap={1}>
+            <For each={jobs()}>
+              {(job, index) => {
+                const isSelected = () => index() === selectedIndex();
+                const cardBackground = () => (isSelected() ? theme.backgroundElement : theme.backgroundPanel);
+                return (
+                  <box
+                    paddingLeft={0}
+                    paddingRight={0}
+                    paddingTop={0}
+                    paddingBottom={0}
+                    flexDirection="row"
+                    onMouseMove={() => setSelectedIndex(index())}
+                    onMouseOver={() => setSelectedIndex(index())}
+                    onMouseDown={(event: MouseEvent) => {
+                      if (clickPrimary(event)) {
+                        setSelectedIndex(index());
+                      }
+                    }}
+                    onMouseUp={(event: MouseEvent) => {
+                      if (clickPrimary(event)) {
+                        setSelectedIndex(index());
+                        props.onCancel(job);
+                      }
+                    }}
+                  >
+                    <box width={1} backgroundColor={isSelected() ? theme.primary : theme.borderSubtle} />
+                    <box
+                      paddingLeft={2}
+                      paddingRight={2}
+                      paddingTop={1}
+                      paddingBottom={1}
+                      flexDirection="row"
+                      justifyContent="space-between"
+                      alignItems="center"
+                      flexGrow={1}
+                      backgroundColor={cardBackground()}
+                    >
+                      <text fg={isSelected() ? theme.text : theme.textMuted}>{taskID(job)}</text>
+                      <box flexDirection="row" gap={2}>
+                        <text fg={isSelected() ? theme.text : theme.textMuted}>{formatCompactDate(job.runAt)}</text>
+                        <text
+                          fg={hoveredAction() === `delete:${job.id}` ? theme.text : theme.textMuted}
+                          onMouseOver={() => setHoveredAction(`delete:${job.id}`)}
+                          onMouseOut={() => setHoveredAction(undefined)}
+                          onMouseUp={(event: MouseEvent) => {
+                            if (clickPrimary(event)) {
+                              setSelectedIndex(index());
+                              props.onCancel(job);
+                            }
+                          }}
+                        >
+                          cancel
+                        </text>
+                      </box>
+                    </box>
+                  </box>
+                );
+              }}
+            </For>
+          </box>
+        </Show>
+      </scrollbox>
+    </box>
+  );
+}

package/src/tui/SidebarScheduledPrompts.tsx

@@ -0,0 +1,92 @@
+/** @jsxImportSource @opentui/solid */
+import { TextAttributes, type MouseEvent } from "@opentui/core";
+import type { TuiPluginApi } from "@opencode-ai/plugin/tui";
+import { createSignal, For, onCleanup, onMount, Show } from "solid-js";
+import { formatCompactDate, taskID } from "../format.ts";
+import { onSchedulerChange } from "../scheduler-events.ts";
+import { readStore } from "../store.ts";
+import type { ScheduledPrompt } from "../types.ts";
+import { SIDEBAR_MAX_JOBS, sortPending, TICK_MS } from "../scheduler.ts";
+import { clickPrimary } from "./ui.ts";
+
+export function SidebarScheduledPrompts(props: { api: TuiPluginApi; sessionID: string; onOpenManager: () => void }) {
+  const theme = props.api.theme.current;
+  const [jobs, setJobs] = createSignal<ScheduledPrompt[]>([]);
+  const [paused, setPaused] = createSignal(false);
+  const [expanded, setExpanded] = createSignal(true);
+
+  const refresh = async () => {
+    const store = await readStore();
+    setJobs(
+      store.jobs
+        .filter((job) => job.status === "pending" && job.sessionID === props.sessionID)
+        .sort(sortPending)
+        .slice(0, SIDEBAR_MAX_JOBS),
+    );
+    setPaused(store.settings.paused);
+  };
+
+  onMount(() => {
+    void refresh();
+  });
+
+  const timer = setInterval(() => {
+    void refresh();
+  }, TICK_MS);
+  const disposeSchedulerChange = onSchedulerChange(() => {
+    void refresh();
+  });
+
+  onCleanup(() => {
+    clearInterval(timer);
+    disposeSchedulerChange();
+  });
+
+  return (
+    <box flexDirection="column" gap={0} paddingTop={1} paddingBottom={1}>
+      <box
+        flexDirection="row"
+        gap={1}
+        alignItems="center"
+        onMouseDown={(event: MouseEvent) => {
+          if (clickPrimary(event)) {
+            setExpanded((value) => !value);
+          }
+        }}
+      >
+        <text fg={theme.text}>{expanded() ? "▼" : "▶"}</text>
+        <text fg={theme.text} attributes={TextAttributes.BOLD}>
+          Scheduled
+        </text>
+        <Show when={paused()}>
+          <text fg={theme.warning}>paused</text>
+        </Show>
+      </box>
+
+      <Show when={expanded()}>
+        <Show when={jobs().length > 0} fallback={<text fg={theme.textMuted}>  none</text>}>
+          <scrollbox maxHeight={SIDEBAR_MAX_JOBS}>
+            <box flexDirection="column" gap={0}>
+              <For each={jobs()}>
+                {(job) => (
+                  <box
+                    flexDirection="row"
+                    gap={1}
+                    onMouseDown={(event: MouseEvent) => {
+                      if (clickPrimary(event)) {
+                        props.onOpenManager();
+                      }
+                    }}
+                  >
+                    <text fg={theme.primary}>{`  ${taskID(job)}`}</text>
+                    <text fg={theme.textMuted}>{formatCompactDate(job.runAt)}</text>
+                  </box>
+                )}
+              </For>
+            </box>
+          </scrollbox>
+        </Show>
+      </Show>
+    </box>
+  );
+}

package/src/tui/dialogs.tsx

@@ -0,0 +1,108 @@
+/** @jsxImportSource @opentui/solid */
+import type { TuiPluginApi } from "@opencode-ai/plugin/tui";
+import { formatRunAt, parseScheduleRequest, parseTimeSpec } from "../time.ts";
+import { takeDraftPrompt } from "../store.ts";
+import type { ScheduledPrompt } from "../types.ts";
+import { taskID } from "../format.ts";
+import { addScheduledPrompt, cancelScheduledPrompt, loadSchedulerState, toggleSchedulerPause } from "../scheduler.ts";
+import { SchedulerManagerDialog } from "./SchedulerManagerDialog.tsx";
+
+function openTimePrompt(api: TuiPluginApi, prompt: string): void {
+  const DialogPrompt = api.ui.DialogPrompt;
+  api.ui.dialog.replace(() => (
+    <DialogPrompt
+      title="Schedule Prompt"
+      placeholder="in 30m, at 3:30am, today 14:00, tomorrow 9am"
+      onCancel={() => openManager(api)}
+      onConfirm={async (value) => {
+        const runAt = parseTimeSpec(value);
+        if (!runAt) {
+          api.ui.toast({ message: "Could not understand that time", variant: "error", duration: 3000 });
+          openTimePrompt(api, prompt);
+          return;
+        }
+
+        await addScheduledPrompt(api, prompt, runAt);
+        await openManager(api);
+      }}
+      description={() => (
+        <box flexDirection="column" gap={1}>
+          <text fg={api.theme.current.textMuted}>Prompt captured. Choose when it should send.</text>
+        </box>
+      )}
+    />
+  ));
+}
+
+function openPromptInput(api: TuiPluginApi, value = ""): void {
+  const DialogPrompt = api.ui.DialogPrompt;
+  api.ui.dialog.replace(() => (
+    <DialogPrompt
+      title="Schedule Prompt"
+      value={value}
+      placeholder="Prompt to send later"
+      onCancel={() => openManager(api)}
+      onConfirm={(prompt) => {
+        const parsed = parseScheduleRequest(prompt);
+        if (!parsed.prompt) {
+          api.ui.toast({ message: "Prompt cannot be empty", variant: "error", duration: 2500 });
+          openPromptInput(api, prompt);
+          return;
+        }
+
+        if (parsed.runAt) {
+          void addScheduledPrompt(api, parsed.prompt, parsed.runAt).then(() => openManager(api));
+          return;
+        }
+
+        openTimePrompt(api, parsed.prompt);
+      }}
+    />
+  ));
+}
+
+function confirmCancel(api: TuiPluginApi, job: ScheduledPrompt): void {
+  const DialogConfirm = api.ui.DialogConfirm;
+  api.ui.dialog.replace(() => (
+    <DialogConfirm
+      title="Cancel Prompt"
+      message={`${taskID(job)} at ${formatRunAt(job.runAt)}`}
+      onCancel={() => openManager(api)}
+      onConfirm={() => {
+        void cancelScheduledPrompt(api, job).then(() => openManager(api));
+      }}
+    />
+  ));
+}
+
+export async function openManager(api: TuiPluginApi): Promise<void> {
+  const state = await loadSchedulerState();
+  api.ui.dialog.replace(() => (
+    <SchedulerManagerDialog
+      api={api}
+      initialJobs={state.jobs}
+      initialPaused={state.paused}
+      loadJobs={loadSchedulerState}
+      onAdd={() => openPromptInput(api)}
+      onCancel={(job) => confirmCancel(api, job)}
+      onTogglePause={() => toggleSchedulerPause(api)}
+    />
+  ));
+}
+
+export async function openScheduler(api: TuiPluginApi): Promise<void> {
+  const draft = await takeDraftPrompt();
+  if (draft) {
+    const parsed = parseScheduleRequest(draft);
+    if (parsed.prompt && parsed.runAt) {
+      await addScheduledPrompt(api, parsed.prompt, parsed.runAt);
+      await openManager(api);
+      return;
+    }
+
+    openPromptInput(api, parsed.prompt || draft);
+    return;
+  }
+
+  await openManager(api);
+}

package/src/tui/ui.ts

@@ -0,0 +1,11 @@
+import { MouseButton, type MouseEvent } from "@opentui/core";
+
+export function clickPrimary(event: MouseEvent): boolean {
+  if (event.button !== MouseButton.LEFT) {
+    return false;
+  }
+
+  event.preventDefault();
+  event.stopPropagation();
+  return true;
+}

package/src/tui.tsx

@@ -0,0 +1,47 @@
+/** @jsxImportSource @opentui/solid */
+import type { TuiPlugin, TuiPluginModule } from "@opencode-ai/plugin/tui";
+import { PLUGIN_ID, SCHEDULE_COMMAND_OPEN } from "./constants.ts";
+import { deliverDuePrompts, TICK_MS } from "./scheduler.ts";
+import { openManager, openScheduler } from "./tui/dialogs.tsx";
+import { SidebarScheduledPrompts } from "./tui/SidebarScheduledPrompts.tsx";
+
+const tui: TuiPlugin = async (api) => {
+  const disposeCommands = api.keymap.registerLayer({
+    commands: [
+      {
+        namespace: "palette",
+        name: SCHEDULE_COMMAND_OPEN,
+        title: "Schedule Prompt",
+        category: "Plugin",
+        slashName: "schedule",
+        run: () => {
+          void openScheduler(api);
+        },
+      },
+    ],
+  });
+
+  api.slots.register({
+    order: 180,
+    slots: {
+      sidebar_content(_ctx, props) {
+        return <SidebarScheduledPrompts api={api} sessionID={props.session_id} onOpenManager={() => void openManager(api)} />;
+      },
+    },
+  });
+
+  const timer = setInterval(() => {
+    void deliverDuePrompts(api);
+  }, TICK_MS);
+
+  void deliverDuePrompts(api);
+  api.lifecycle.onDispose(disposeCommands);
+  api.lifecycle.onDispose(() => clearInterval(timer));
+};
+
+const module: TuiPluginModule & { id: string } = {
+  id: PLUGIN_ID,
+  tui,
+};
+
+export default module;

package/src/types.ts

@@ -0,0 +1,25 @@
+export type ScheduleStatus = "pending" | "sent" | "canceled" | "failed";
+
+export interface ScheduledPrompt {
+  id: string;
+  prompt: string;
+  runAt: number;
+  createdAt: number;
+  status: ScheduleStatus;
+  sessionID?: string;
+  sentAt?: number;
+  canceledAt?: number;
+  lastAttemptAt?: number;
+  error?: string;
+}
+
+export interface SchedulerSettings {
+  paused: boolean;
+}
+
+export interface SchedulerStore {
+  version: 1;
+  draftPrompt?: string;
+  jobs: ScheduledPrompt[];
+  settings: SchedulerSettings;
+}