Omniscio

Send Later (scheduled responses)

Send Later queues a reply you write now for delivery at a time you pick, carrying whatever images, PDFs and pasted text were in the composer when you scheduled it. It uses the same time picker as Snooze, is reachable from the local control server, and raises an inbox alert if delivery finally fails.

On this page

What it is

Send Later lets you queue a response to a session for future delivery — the message you wrote now will be typed into the session at the time you picked, with whatever images, PDFs, text docs, and pasted-text chips were in the composer at scheduling time. Useful for batch-replying the night before, holding a reply until business hours, or staggering agent work so you don't burn rate-limit tokens all at once. Shares the same time picker UI and phrasing parser as Snooze (so "tomorrow 9 am", "in 2 hours", or a specific datetime all work). If delivery fails (e.g., Omniscio was offline at the scheduled time), Omniscio retries up to three times — after the third failure it gives up, inserts a system message in the session, and raises a visible inbox alert so a failed scheduled reply is never silent. If the session's working folder is missing (its worktree was cleaned up, or the drive was unmounted / retired), a resume can never succeed, so Omniscio skips the retries, surfaces the same alert immediately, and does not resurface the (often archived) session.

CLI-reachable. Send Later is exposed through Omniscio's local control server (127.0.0.1:19519) as POST /session/:id/schedule-response, so an external script or an AI driving Omniscio over the CLI can queue a scheduled reply. The JSON body is { "text": "<message>", "sendAt": "<ISO-8601>", "force"?: true } plus the composer's own attachments — images[] and pastedTexts[] — and at least one of text / images / pastedTexts must be present. sendAt is a strict ISO-8601 time at least 30 seconds in the future, and force: true overwrites an already-scheduled reply (otherwise the route returns 409 with the existing schedule). Because delivery injects a real (paid, at delivery time) turn, the route requires a source session (X-AMC-Source-Session-Id) and is refused without one, exactly like /message; success returns { "ok": true, "data": { "sessionId", "sendAt" } }.

A body that carries a live CLI credential — a scoped agent-session token, an in-app session token, an mcp-capability token, a cloud-session token, or the install-wide key — is refused with 400 before anything is stored, for text and for every pastedTexts block alike. The refusal names the field and never the value (refusalCode: "live_token_in_body"), because a credential pasted into a scheduled turn would be replayed into the transcript and delivered later; name the variable ($AMC_CLI_TOKEN) instead and let the receiving session read its own value. The queue route and this one share that one detector.

Where to find it

How to use it

  1. Draft your reply. Type the message you want sent later into the session's input field just like a normal reply. Attach files (images, PDFs, text docs) and paste blocks the same way you would for an immediate send — the chip strip above the textarea is part of what gets scheduled.
  2. Open the scheduler. When your draft has text the Send button becomes a split button with a small ▾ caret on its right. Four ways in: click the ▾ caret → a small send-options menu opens (Send Later · Send as aside) — choose Send Later; or press and hold the Send button (~½ second, mouse or touch) for the same menu; or press Ctrl+Shift+L, or choose Send Later from the session's overflow (⋯) menu (or its pinned header button, if you pinned it) — these open the picker directly. The Snooze palette opens in "send-later" mode — same pill UI but labeled for scheduling a send instead of a pause — and on desktop it opens right beside what you used: just above the chat box for the ▾ menu, the hold and Ctrl+Shift+L (so your draft stays visible), just under the header button for the ⋯ menu or a pinned Send Later, and next to the scheduled message for Reschedule. It stays fully inside the window and re-fits as its list changes; on a phone it stays at the top, clear of the on-screen keyboard.
  3. Pick a time. Type a natural-language duration ("tomorrow 9am", "in 90 minutes", "Friday 2pm") or pick from the preset pills. You can also punch in an exact datetime. Confirm. A typed time is always what Enter picks. While the agent is working, the picker also offers "After the agent finishes" as its first row (see queue-a-message.md); it is never offered on an idle or brand-new session, where it would just send right away — so Send Later on a session you haven't started yet always waits for the time you pick.
  4. See it queued. The session shows a small "scheduled" badge with the send time; the session row in the sidebar marks it with a scheduled-response indicator. The original message stays visible in your input in case you want to cancel or edit. Scheduling also advances you to the next session exactly like a normal reply, snooze, or archive — it follows your post-send navigation setting, so batch-scheduling replies walks you straight down your queue instead of stranding you on the one you just handled. (This runs the same post-send navigation as every other action; the timing contract lives in inbox-navigation-contract.md.)
  5. Cancel or replace if needed. Click the scheduled badge → Cancel removes the scheduled response and restores the draft — including the attachment chips so a re-schedule doesn't lose them. To pick a different time instead, click Reschedule on the scheduled message: the picker opens beside it with the same text and attachments, and the new time replaces the old one. If you type a new reply and hit Send before the scheduled time, the old one is cancelled automatically.

How it behaves

What happens at delivery time, by session status

The scheduled time arrives and Omniscio delivers. Your scheduled message itself appears in the chat as a normal operator message — the same way your manual sends do — followed by the system confirmation. You always see what got sent; user messages are never invisible. What "deliver" means depends on the session's status at that exact moment:

  • needs_you / ready — Sent into the existing session like a normal reply. Your message appears in chat, then system chat says "Scheduled response sent".
  • running (agent is actively generating) — Sent mid-stream, just like if you'd typed the message and hit Send during a busy turn. The CLI may reuse the persistent process if the in-flight turn happens to be done, or it may kill and respawn with the new prompt. Your message appears in chat, then system chat says "Scheduled response sent (interrupted in-progress turn)" so a cut-off turn isn't a silent surprise. The trade-off: your message actually delivers on time instead of waiting forever for the agent to finish.
  • ended / error / stalled — Resumed via a fresh launch with the scheduled text as the first prompt (like clicking Continue). Your message appears in chat, then system chat says "Scheduled response sent".
  • archived — Auto-unarchived first, then resumed via launch. (Exception: if the session's working folder is gone, delivery fails fast with an alert and the session is left archived, not resurfaced — see the failure handling in "How it works".)
  • snoozed — Snooze is cleared first, then delivered per the underlying status above.
  • paused — Auto-unpaused first (DB flips to ended), then resumed via launch. The reasoning: you scheduled the message before pausing, so honour the schedule rather than letting it rot.
  • starting / terminating — Skipped this tick. These are sub-second transient states; the next periodic check (≤60 s) or the event-driven trigger (see below) catches them once they settle.

Special case — a session you stopped (user-closed). If you scheduled a reply and then stopped that session (or it was cascade-stopped by stopping its controller), what happens depends on who scheduled the reply — because a stopped session is otherwise kept closed so automation can't quietly resurrect it:

  • You scheduled it → it reopens and delivers, exactly like typing the message now would. Stopping a session doesn't void a message you deliberately queued — your most recent action wins. (Under the hood the stopped session is settled to ended and resumed via a fresh launch with your scheduled text as the prompt.)
  • Inbox Pilot / automation scheduled it → it is not delivered. The session is finalized (archived) and the dead reply cleared, so a run you stopped on purpose can't crawl back to life on its own.

This mirrors an immediate send: typing a message into a stopped session reopens it too, because a genuine user turn re-engages the session. The split is by the recorded schedule source, so only Inbox-Pilot-scheduled replies are held back. Invariants live in authoritative-user-close-contract.md (never-stranded-active / user-scheduled-send-later-reopens).

How attachments are preserved

Pre-v154 the scheduler only stored scheduled_response text + scheduled_send_at, so any images / PDFs / text docs / pasted-text chips in the composer at scheduling time silently disappeared and only the bare text delivered. Since migration v154 the sessions table carries a third column, scheduled_attachments (JSON TEXT), that captures the same AttachmentPayload shape ({ images: ImageAttachment[], pastedTexts: PastedTextAttachment[] }) the live SESSION_SEND_RESPONSE path uses. NULL on existing rows means "no attachments" (equivalent to the prior behavior); on a Send Later, the renderer rebuilds the payload from pendingImages + pendingPastedTexts and ships it through the scheduling IPC alongside the text.

At delivery time prepareScheduledAttachments in send-later-service.ts re-hydrates the payload, splices the pasted-text chips back into the typed body via spliceTypedTextWithPastedChips, and partitions the images via partitionAttachments into the same three buckets session-service.sendResponse uses (images → inline image blocks, PDFs → document blocks plus workdir save, text docs → workdir save + path injection). The operator message persisted to conversation_messages carries the same pasted_attachments range metadata that a manual send would, so the chat-history chip overlay paints correctly when you scroll back. See chat-attachments.md for the partition / save / splice contract — Send Later is the same pipeline, just deferred.

Cancel restores the draft including chips: SESSION_CANCEL_SCHEDULED_RESPONSE reads the scheduled_attachments JSON before clearing the row and emits a restore-session-input event whose payload now includes the rebuilt images[] and pastedTexts[] arrays. The renderer rehydrates pendingImages and pendingPastedTexts so the chip strip reappears in the composer exactly as it was when the user scheduled.

  • queue-a-message.md — the multi-message sibling: the picker's "After the agent finishes" queues messages that send on turn-completion (not a clock), one at a time, without interrupting
  • snooze-a-session.md — snooze is Send Later's sibling: holds the session instead of a message
  • chat-attachments.md — the partition / save / splice pipeline Send Later replays at delivery time
  • use-quick-responses.md — combine with Quick Responses if you often send the same canned reply at scheduled times

Last verified 2026-10-06