Tasks (markdown outliner, in development) (part 3)
Snoozing tucks the task into a "Snoozed" section. Once a task is snoozed into the future, it leaves the list and collects under a single collapsible ⏰ Snoozed (N) row pinned at the bottom — so the list stays focused on what's actually actionable, while the count tells you at a glance what's parked.
On this page
What it is
This is part 3 of the Tasks (markdown outliner, in development) page. It carries the next stretch of the material on that page, moved here because a single page is capped at 40,000 characters.
Where to find it
Reach this part through Tasks (markdown outliner, in development) — it lists every part and explains where the feature lives in the product. Everything below is reached from the same place.
How it behaves
Everything below is the behaviour, detail and edge cases that belong to this stretch of the Tasks (markdown outliner, in development) page.
Keyboard: two modes (writing vs command) (continued 3)
Snoozing tucks the task into a "Snoozed" section. Once a task is snoozed into the future, it leaves the list and collects under a single collapsible ⏰ Snoozed (N) row pinned at the bottom — so the list stays focused on what's actually actionable, while the count tells you at a glance what's parked. Open the section to see each snoozed task rendered just like a regular task row — it's numbered (1./2./3., the same as the list above), shows its full text, its wake date on the usual alarm-clock chip, and a "+N sub-tasks" count if it has any. Its 🕐 clock header lines up in the same column as those task numbers and the add-row's "+", so the section reads as part of the list instead of sitting off to the side. To bring one back early, open the row's ⋯ menu and choose Wake now — the old always-on button is gone, so the rows stay calm and read like any other task. When the snooze time passes the task returns to its place in the list on its own — and Omniscio also drops a reminder in your Inbox so you don't miss it (see Deadline & snooze reminders). If every task in a list is snoozed, the section still shows (with an "all snoozed" note), so nothing is ever out of reach. With a search or filter on, an empty main list says "No tasks match" with a Clear filters button instead, even when a matching task is waiting in the Snoozed or Waiting section below. The consolidated "All Projects" view now behaves the same way — each project group carries its own collapsible ⏰ Snoozed (N) section at its bottom (same numbering + the ⋯ Wake now). These snoozed tasks used to stay inline in that view as a slim ⏰ stub; they're now tucked into the section like everywhere else.
A task that came back is marked so you can see it was snoozed. When a snooze time
passes and the task returns to the list, it carries a small alarm-clock icon (the same
one the rest of Omniscio uses for snooze) instead of the old "⏰ Yesterday"-style stale date. If
it's been snoozed more than once, a ×2 / ×3 badge rides beside the icon, and
hovering lists every snooze — each as "Snoozed Jul 1 → until Jul 5" (both the moment you
snoozed it and the wake time you picked). A still-waiting task is unchanged — it keeps
its "Snoozed until Friday" wording so you know when it's back; only the emoji was swapped for
that same alarm-clock icon. This history is recorded per task on every genuine snooze (editing
an already-set snooze's time or clearing it doesn't inflate the count) and is capped at the 25
most recent; tasks already snoozed when this shipped are backfilled with one entry so they read
right immediately. Undoing a snooze restores the count too, so it can never drift. Stored in
the tasks_v2.snooze_history_json column.
Fold a task that has sub-items. Any task with sub-items shows a small chevron (▸/▾)
just to the left of its number (so the arrow hugs the item) — click it (or press F, or use the right-click Collapse sub-items
row) to fold its subtree out of sight; a quiet count shows how many items are tucked away, and
folding again unfolds them. The fold is remembered across restarts (it's saved like the
collapsed-project state), works in both the giant "All Projects" view and a single-project
list, and keyboard navigation skips folded rows. It only changes what's on screen — it never
moves, edits, deletes, or exports a task — and a folded parent is still fully covered by
whole-project actions (its hidden children still count). Drilling into or adding a sub-item under
a folded task automatically unfolds it so you always see what you just touched, and while a filter
is active folding is paused so a filtered-in match is never hidden.
The command line reuses the same plain-English reader that parses a typed capture
line ("call vendor due friday #work !high") when you create a task, plus a small
phrase layer for "high priority" / "move to <list>" / "done" — so dates
("tomorrow", "next week", "in 3 days"), priority, and tags all just work,
and a line it can't read is shown back to you (nothing is written on a misread).
It also takes note <text> (adds a note to the task — the whole text is the note's body and its first 120 characters its title, exactly like a note added from the context menu), duplicate / dup / copy (adds a copy of the task's
own line right below at once — not a clipboard copy, and unlike Ctrl/Cmd+D it leaves the sub-tasks and notes behind), remind me <time> / hide until <time> (same as
snooze), complete / finish / mark done (same as done), and delegate research / delegate draft / delegate summarize (or assign instead of delegate — how the AI would do the task; see Handing a task to an agent). Tags and repeats you type
replace the task's current ones — #a #b leaves exactly #a and #b — so include any tag you
want to keep; Ctrl/Cmd+Z undoes the whole line.
Removing isn't a typed command — a bare Delete (or Ctrl/Cmd+Delete) files the task away into Archived without marking it done (reversible),
so a typed line can never destroy a task. New keys only fire when a task is highlighted
and you're not mid-typing, so they never eat your keystrokes.
This keyboard drives both views the same way — the default giant "All Projects"
view and a single-project filtered view — because both mount one shared
implementation (useTaskV2CommandKeys). In the giant view the focus nav steps across
project groups, Alt+Shift+↑/↓ reorders the task up/down — and at its sibling-group edge a nested
(child) row nests into the visually-adjacent SAME-PROJECT item (move-down → first child of the item
below, move-up → last child of the item above; depth preserved), while a top-level row at a
project's top / bottom edge instead carries into the neighboring project (move-down → top of the
next project, move-up → bottom of the previous), and a multi-selected block at that edge crosses together as a set (appended to the target, one undo) — and Tab/Shift+Tab — or the OneNote
aliases Alt+Shift+→/← — indent/outdent the focused row (or, with multiple rows selected, the WHOLE selected block together as one undo) within its own project (scoped so neither indent nor a child's nest ever crosses projects); only
Backspace-merge and drill-in differ (no-ops in the merged view — see
The giant all-projects view). In the giant
view the up/down nav also stops on each project name (header), so you can act on a whole
project — see Select a project & act on the whole thing.
Backspace only merges a row that is empty on screen. In a single project's list, a plain Backspace in an empty row joins it into the row just above it on screen, and the cursor lands there. That is never a task you cannot see: not a sub-item tucked inside a folded task, and not a task parked in the Snoozed or Waiting section at the bottom. Whether the row is empty is read from what is typed in the box right now, not from the saved copy, which catches up only after a short pause in typing. So a quick Backspace to fix a typo in a brand-new task deletes one letter, never the task. The join uses that same on-screen text, so clearing a row quickly and pressing Backspace again removes the row and leaves the row above exactly as it was; the words you just erased never reappear there. A row that has sub-items is never merged (there is no server-side merge to move them safely); you are asked to move or delete them first.
"The row above" means the row you can see above. Backspace joins an empty row into the row drawn just above it on screen, never into a sub-item hidden inside a folded task or a task moved down into the Snoozed or Waiting section. Moving a selection that spans a nesting boundary (Alt+Shift+Up/Down with several rows picked) also lands next to the row you can see, so the block never disappears into a folded task. In the All Projects view, a task's fold arrow and hidden count only count the sub-items that would show under it, so a task whose only sub-item is snoozed shows no arrow (the per-project list already worked this way).
Tab and Move up/down skip tasks you can't see. When the task just above is snoozed, waiting, or hidden because it is completed, Tab tucks the task under the next task you CAN see above it instead of under the hidden one, so it never vanishes into the Snoozed or Waiting section. Alt+Shift+Up/Down and the Move up / Move down menu items swap with the neighbor on screen, so a move always visibly moves the task, and a sub-task at the edge of its group nests into the visible neighbor group. The saved order matches what you see, so the move stays put after a reload. With no visible task above it, Tab does nothing, exactly as for the first task in a list.
A multi-row indent, outdent or move speaks only after it is saved. Picking two or more rows and
pressing Tab, Shift+Tab, Alt+Shift+Up/Down or Cmd/Ctrl+Z-shaped move announces the restructure to a
screen reader only once the write has landed, so a refused or rolled-back write is never described
as a success. Those block actions report their result in three shapes rather than a plain boolean:
the store write's save (a promise of true/false) when the block really restructured, 'edge'
when the press was a clean no-op at the group edge, and false when the selection was a single row
so the caller falls through to the single-row path. The single-row indent, outdent and move report
their save the same way. The 'edge' answer is decided synchronously from the tree, because it says
whether the press was handled at all, and only the announcement waits on the save.
Holding a key down acts once. Holding the finish or drop key, paste, Enter or Shift+Enter a little too long finishes, drops, pastes or adds exactly one task; the extra presses the keyboard sends while the key is held are ignored. Only moving keeps going while held: the cursor keys and the move-a-task keys (Shift+W/S/A/D) repeat, so you can hold them to travel down the list or carry a task several rows.
Tab on a single row moves just that row, not its sub-tasks. Indenting one task that has sub-tasks moves only that row in one level; its sub-tasks stay at the depth they were and now sit directly under it as its siblings. With several rows selected, Tab moves each selected row together with its sub-tasks. To move one task together with its sub-tasks, reorder it with Alt+Shift+↑/↓ instead.
While your cursor is in the Tasks list, the list owns its keys: Omniscio's app-wide shortcuts stand down for these bare keys (and for Ctrl/Cmd+Z / Ctrl/Cmd+Y, which run the list's own universal undo / redo — see Archive & universal undo), so a command-mode key never also fires an app-wide action behind the list — exactly how the Mind Map and Notes panels work. App-wide combos that aren't list keys (Ctrl+1-9 jump to a project, Ctrl+T new session) still work from the list. Ctrl/Cmd+K is now a list key — it inserts a link (see the keyboard table) rather than opening global search from Tasks, the same way the Notes editor claims Ctrl+K for its own insert-link.
Keyboard: two modes (writing vs command) — Caught — AI suggestions in their own view
Catching is off by default. Nothing is scanned until you turn on Catch follow-ups when a session ends in the Caught follow-ups group on the Tasks settings page (search Settings for it). With it on, the end of a session's transcript and the titles of your open tasks are sent to an outside AI service. The scan takes the same one door every other Tasks AI call does: it runs first on your own Claude account, and only when that account cannot answer is it paid for in the order you set (an OpenRouter or Claude key, then credits). transcript and the titles of your open tasks are sent to your own Claude account first, with the default model you chose; when that cannot answer they go to your own saved OpenRouter or Anthropic key, then your Omniscio credits.
When one of your agent sessions ends, a quick AI pass reads the end of its transcript (the last ~12,000 characters, roughly the final few exchanges of a long session, so a follow-up mentioned early in a long session is not seen; a very long agent message is trimmed to its start and end so it cannot push your own words out, and the AI is told when earlier text was left out) for follow-up tasks you still owe and stages them as suggestions — nothing files itself. They live in their own Caught entry in the project rail (with a count of how many are waiting); the entry appears only while there are suggestions to review, and opens a plain numbered list, just like a normal task list (this replaced the old strip that used to sit above the list).
Each row shows the suggestion, a quiet link back to the session it came from, and the name of the
project it will be filed into (if the project it was proposed for has since been deleted, the row shows and files into your default project instead). On the row you're pointing at or have focused, Keep ✓ and
Dismiss ✕ appear. Keep files it straight into the project the row names; to file it
somewhere else, press the small arrow beside Keep (Pick destination) and choose a
project. Dismiss asks to confirm and stays undoable: the struck-through "removed" line with its
Undo button appears only after the dismiss actually saved (a failed one shows just the error
toast and the row comes back), and a failed Undo leaves that strip in place so you can try it
again (dismissCaught / undoDismissCaught return whether they succeeded). At rest a row reads as a clean
numbered item, so the list never feels like a form. A row that says you have already finished an
existing task works differently: it shows no project and a Check off button instead of Keep, and
Check off (or Enter) checks that task off rather than adding a new one.
It's keyboard-first, so you can clear it without a mouse: ↑ / ↓ (or j / k) move
between suggestions, Home / End jump to the first / last, Enter keeps the focused row straight into the project it shows (no picker), and Delete opens the Dismiss confirm. The keys act only while
the row itself is focused, so a key pressed on the Keep or Dismiss button is never hijacked; the active row
shows a focus ring, and after you keep or dismiss, focus moves to the neighbouring suggestion
rather than being lost. Clear the last one and a friendly "you're all caught up" note takes its
place (TaskV2CaughtView.tsx). If the suggestions themselves fail to load, the view names that
subject — "Couldn't load your suggestions", under its own taskV3CaughtLane.loadErrorTitle
key, never a flat "Something went wrong" — and offers Retry. That title is deliberately NOT the
shared tasks.view.errorTitle ("Couldn't load tasks"), which belongs to the whole-Tasks
failed-first-load card and the Mission Control Tasks side panel.
Batch Keep all / Dismiss all. Ctrl/Cmd+click picks suggestions, Shift+click picks a range, Ctrl/Cmd+A picks them all, and Esc clears the pick. Picking several is a desktop-app gesture: there is no touch way to pick a second suggestion, so on a phone or in a browser on Omniscio web access the selection bar and its Keep all / Dismiss all never appear, and you keep or dismiss suggestions one at a time. With two or more picked, the selection bar offers Keep all and Dismiss all. A batch Dismiss all asks once and cannot be undone — only a single dismiss gets the Undo strip. Screen readers hear "N items kept" / "N items dismissed" only when every write actually landed. If any of the writes is refused you get one error message (counting how many failed when more than one did), the refused rows come back into the lane, and nothing is announced as a success.
Dismiss all (the whole lane). The Dismiss all button above the list clears every waiting
suggestion at once — including older ones the lane no longer shows, and recent ones past the 500
the lane renders at most. Both the count in its prompt and its "Dismissed N" message total every
pending suggestion the app holds (freshCount plus agedCount on the caught-list response), never
just the rendered page, so each names the number it really clears. It asks first, offers Triage
for me instead, and dismissed suggestions never become tasks. There is no undo for a bulk
dismiss. Recently dismissed below lists every suggestion dismissed in the last 14 days, 50 at a
time; press Show more to load the next 50.
A suggestion made from an email also loses the email's text and sender straight away when it is
cleared by Dismiss all, so bringing that one back returns a suggestion stripped of its email.
Recently dismissed. At the bottom of Caught (also under the "all caught up" note) a Recently dismissed toggle lists the suggestions dismissed in the last 14 days, newest first, 50 at a time with Show more. Each has a Bring back button that returns it to the lane as a pending suggestion (it uses the same undo-dismiss step as the Undo strip). With nothing dismissed it says "Nothing dismissed in the last 14 days."; if the list cannot load it says so and offers Try again. The list refreshes itself while open when the lane changes. The list shows the last 14 days.
A dismissed row is hidden from the app once your Data Retention window has passed (never sooner than 14 days after you answered it), and its text is erased one more Data Retention window after that; a dismissed email suggestion loses its source message and sender a day after it was dismissed.
Control what gets caught. In the Caught follow-ups group on the Tasks settings page (search Settings for it)
you can turn catching on or off, or give it guidance — tell the AI, in your own words, what
counts as a follow-up worth catching ("only things I still owe someone", "skip anything about
code"). The guidance steers which suggestions are kept but can't break the feature (the format it
returns stays fixed). Catching can also be limited to sessions from chosen projects with Only catch from these projects on the same page (empty = every
session, so it never silently stops). Look back for missed sessions (1 to 14 days, default 3; tasksV2CatchesLookbackDays) sets how far back the hourly sweep goes to scan ended sessions the live trigger missed. A session is only given up on as too old once it ended more than 14 days ago, so raising the setting later still picks up sessions inside the new window.
How the Tasks settings page is laid out. The page is headed Tasks and splits its rows into eight groups, each under its own sub-heading: Caught follow-ups (the catch switch, the look-back days, the guidance, the triage-session switch, and the Only catch from these projects filter), AI planning (the Set up Tasks row, memory, the Plan My Day switch and its load labels, the Right now AI card, the breakdown interview, the looks-big nudges and the AI-arrange switch, then the Model for arranging your day picker), Daily rhythm (the daily check-in switch and hour, then the Evening wrap-up note switch and hour), Reminders & alerts (the due-soon alert and the email, text and phone reminder switches), Privacy & retention (sharing task files with agents, and the 30-day deleted purge), Tasks display (the Right now card, urgency, checkbox and density options, quick-add position, the calendar options and the collapsed-panel text) and Tips (the milestone nudges). Every row lives in exactly one group, and a row no group lists still renders, under More Tasks settings. The page has no permanent sidebar row while Tasks is behind its Lab flag, so you reach it from Settings search or a deep link. Its switches are harmless while the feature is off, and the page needs no separate "turn it on" note. Every row now has a group, so the More Tasks settings heading stays hidden: the Plan My Day switch sits in AI planning, right after memory.
Catching is selective by design. A session is scanned only when you actually typed in it — purely agent-driven sessions (background lanes, cron and recipe runs, peer-messaged workers) are skipped entirely, so the agents' own to-do chatter never lands in Caught (and no AI call is spent on them). A scanned session stages at most 8 new follow-up suggestions across three detection layers — up to 3 explicit (Layer 1), 3 implicit action items (Layer 2), and 2 pattern-based (Layer 3) — and most stage none. On top of those, the same scan can add up to 3 finished-task rows (open tasks the session shows you already did, each with Check off), so one session adds at most 11 rows to Caught. The bar is a real next step you own, never the agent's own workflow steps (running tests, merging a branch, re-running a session…). A suggestion you've already seen in the last two weeks — kept, dismissed, or still pending from another session — won't be staged again, so five sessions on the same piece of work can't each re-suggest "send Sam the deck".
What else each scan sends to the AI. Besides the session itself, every scan sends the titles of
up to 40 of your open tasks from any project, each cut to about 120 characters, so it can
spot ones you've finished, the text of the previously caught suggestions still waiting for you, and,
once Tasks has enough history, a short note on how often you keep suggestions and which tasks you
keep carrying over. When you have more than 40 open tasks, it sends the ones tied to that session's
own task first, then your most recently changed ones, plus a few that share words with the session.
Every one of those pieces — the session transcript, the open-task titles and the
previously caught suggestions — has email addresses and phone numbers blanked out ([email] /
[phone]) before it leaves your computer, along with the other identifiers the shared masker covers
(stripPiiPatterns in pm-pii-redaction.ts), because the scan only needs to spot what you still
have to do. This happens for any session you typed in, whatever its project. Leave catching off in
the Caught follow-ups group on the Tasks settings page (search Settings for it) if you'd rather not.
A failed scan is tried again; a finished one is never paid for twice. A session whose scan
finished, even with nothing to stage, is remembered, so ending and then archiving it costs no
second AI call — and that memory is saved in the database (tasks_v2_catch_scans), so it holds
across an app restart and a bulk archive of old sessions cannot pay for the same scan again.
That memory is per Omniscio account — the table is keyed by session and account — so when a
second person signs in to Omniscio on the same computer, a session the first one already scanned is
scanned again for them, because the suggestions land in their own Caught lane. The hourly sweep
that re-queues ended sessions with no scan record asks the same per-account question (listUnscannedEndedSessionIds
in queries-tasks-v2-catch-scans.ts), so neither
account's scan record nor its caught rows hide that session from the other account's lane. A scan row
written before the table was keyed per account carries no account and is still honoured for everyone,
so upgrading never pays twice for a scan already made; a row the upgrade could attribute is filed to
the account whose catches it produced, or to the only account on a single-account install. If the AI call itself fails (a timeout or a network error), the scan does not count
as finished: the extract reports the failure (status: 'error' from makeCatchExtract), the
scan throws, and the catch queue retries it a few times, waiting longer after each attempt. Once
those retries are spent — or the failure is one a retry would only repeat — the session is recorded
as handled too, so the hourly sweep below stops paying for it, and it is counted in the "sessions
were not checked" notice instead. If Tasks AI is
turned off (status: 'over-cap'), the scan is neither retried straight
away nor remembered, and it logs a "scan deferred" line. A sweep shortly after the app starts and
then every hour re-queues sessions that ended in the last three days and still have no scan record
(20 at a time, newest first, honoring the project filter), so a skipped session is checked once
AI is back on. The sweep leaves alone a session that is already waiting
for its own retry, and a session the app has already given up on, so a session whose notes keep
failing spends one retry cycle rather than a fresh one every hour. A single check that hangs for ten
minutes is abandoned and retried later, so it can never block every other session's check. No Tasks AI call is ever refused for what was already spent: there is no Tasks daily budget.
Scans that keep failing say so. When three scans in a row are lost — out of retries, or pushed
out of a full queue — with no successful scan between them, one inbox card says some finished
sessions were not checked for follow-ups. Nothing is needed from you: the next successful scan
clears the card, including one left over from before a restart, and the type can be muted like any
other alert. A session skipped because the AI key was missing, rejected or out of credit is not
given up on: the next check that goes through re-runs it straight away, and the hourly sweep offers
it again, so a fixed key needs no restart — and the card stays up until those sessions are caught.
Agents read the same counters — the scan queue, pending retries and lost sessions
(catchScans) — in GET /diag/resources.
Catching can be limited to some projects. On the Settings Tasks page (no sidebar row; open it
from Settings search for "Tasks"), Only catch from these projects picks the projects whose ended sessions are scanned (tasksV2CatchesProjectIds). Empty,
the default, scans every project. When projects are picked, a session in any other project, or in
no project, is skipped. A Catch from every project button appears whenever the list holds
anything, and clears it in one click, even when the list only holds a project that has since been
deleted. Only projects that can run a session are offered; inbox-style surfaces such as Gmail are
left out. The filter fails closed: if every picked project has since been deleted or archived,
nothing is scanned rather than every project, and one warning is logged for that setting until it
changes.
A one-time look back at recent work. The very first of those sweeps (about two minutes after the
app starts with Tasks on) runs once with its own batch: it queues up to 10 sessions that ended
inside your Look back for missed sessions window (3 days by default) and were never scanned, so a
new Tasks user's Caught view can fill with real
follow-ups from recent work instead of starting empty. It goes through the same checks as any scan
(sessions you typed in, your project filter) and is remembered
in the internal setting tasksV2CatchLookBackDone, so it never runs again. While catching is off,
Tasks is off, or Tasks AI is turned off, the look-back is skipped and tried again at the
next app start. The four starter tasks a brand-new Tasks list begins with are not affected.
Scans that keep failing say so. When three scans in a row are lost — out of retries, or pushed
out of a full queue — with no successful scan between them, one inbox card says some finished
sessions were not checked for follow-ups. Nothing is needed from you: the next successful scan
clears the card, including one left over from before a restart, and the type can be muted like any
other alert. Agents read the same counters — the scan queue, pending retries and lost sessions
(catchScans), and the delegation captures and failures (tasksDelegations) — in
GET /diag/resources.
Suggestions re-check themselves, so the list doesn't go stale. The most common reason a good suggestion gets dismissed is simply that you already did it — the work closes long before you next open the lane. So when a later session is scanned, the AI also looks at the suggestions still waiting here and flags any the transcript shows you've since finished. A flagged row is not removed: it sinks to the bottom of the list, renders faded under a "Looks already done since this was caught" line, and shows the quote it based that on — so the top of the lane is only what's still genuinely live, and a wrong guess is visible instead of silently trusted. You still click, and Keep on a flagged row clears the flag (keeping it means you disagreed). This costs no extra AI call — it rides the scan that was already running — and it never touches anything if there's nothing waiting.
Older suggestions fade out, then are cleared. Suggestions older than 30 days are
automatically hidden from the active Caught list so the lane stays focused on recent, actionable
items. They are not dismissed for you — they stay pending (the lane's Dismiss all also
clears them — its warning counts every pending suggestion, aged ones included, and the confirmation
reports the number actually dismissed) — but once a hidden suggestion has been out of the lane for
your Data Retention window as well (30 days by default), the daily cleanup removes it. When any
suggestions are hidden — aged out, or recent ones past the 500-row display cap — a subtle banner at
the bottom of the list says how many are not shown, and a Show older suggestions link below it opens them in place: newest first, 100 at a time with Show more, each with Keep (or Check off for a finished-task row) and Dismiss. "Older" means every pending suggestion the main list does not show, the ones past 30 days and the ones past the 500 cap alike (listOlderPendingCaughtAsync, view: 'older' on tasks-v2:caught-list). If they cannot load it says "Couldn't load older suggestions." with Try again.
Sending an email to Tasks
You can turn an email into a Caught suggestion yourself. In the built-in Gmail viewer, press the Send to Tasks button in the thread header; in Supermail, use the triage bar's Create Task action. Either one shows "Sent to Caught in Tasks" and the email appears in the Caught view like any other suggestion, with its subject as the task text and from sender under it (the sender's plain email address). Nothing becomes a task until you press Keep. An email that restates a task you already have open is not staged (BUG-B029): it goes through the same open-task check as Caught's session and meeting catches, and Gmail's Send to Tasks shows You already have this task: "…" instead. The CLI route POST /tasks-v2/caught/from-email answers that case 422 (UNPROCESSABLE, the app's authored-refusal code) with the same sentence, not a 409, so the sentence reaches the reader as written even when the task name holds a word like "timeout". A finished task or a meeting with the same name does not block the email.
This is a desktop action. Both controls are offered on a computer only: a phone does not show Send to Tasks in Gmail, because the send runs over a channel the mobile and web bridge does not serve, and the Supermail triage bar's Create Task has no working route there either. Treat it as a computer-only action wherever you are reading this.
When you keep it, the email's text is attached to the new task as a note called Email, and Caught drops its own copy. The email text is stored only when Tasks could read a sender address, so that erasing a person's data can always find and remove it. An email with no subject reads "(No subject)". The buttons show only while Tasks is available.
Inbox triage card (paid)
When more than 10 unsorted inbox tasks accumulate (UNSORTED_THRESHOLD = 10 in src/renderer/src/stores/unsorted-inbox-items.ts, the one place that decides it), an inbox card appears automatically offering to organize them. The card stays hidden while the Triage your Inbox list with an AI session setting is off or Tasks itself is off: the count it reads (getUnsortedInboxCount in inbox-triage-service.ts) answers 0 then. Its title reads "You have {count} unsorted items" with a subtitle "Want to organize these?". Clicking the card opens the same Triage this for me chooser the Caught view uses; a paid Claude session starts only when you pick an option and press Start (it costs real tokens). The session runs in Omni while it is turned on, and in the Tasks workspace while it is off. Landing on the card any other way — the inbox moving its cursor after a reply, an archive, a dismiss or a snooze — starts nothing and opens nothing. Moving onto it with J/K or a swipe opens the chooser, which Escape closes. The card is listed in your inbox where its click lands: under Omni (or its custom name) while Omni is turned on, and under Tasks while it is off.
"Triage this for me" button (paid)
The Caught view's toolbar above the list carries a "Triage this for me" button. Clicking it opens a modal with two options: "Set up sorting rules" (starts a session with Omni to define how you want things organized; it files your current caught backlog by those rules, but nothing is saved, so items caught later are not sorted automatically) and "Group these for me" (Omni analyzes the caught items and suggests how to organize them). Choosing either option launches a paid Claude session — there is no free/local fallback. The modal sends only the chosen mode (CAUGHT_TRIAGE_SPAWN_SESSION with { mode: 'sorting-rules' | 'group-items' }); the main process builds the prompt in inbox-triage-service.ts, refuses the start when Triage caught items with an AI session (tasksV2InboxTriageEnabled) is off, and applies the same shared Tasks daily launch budget (launchVolumeGate) and double-click guard (boundedPaidSpawn) as the Inbox triage card. The session runs in the background under the Tasks workspace project (TASKS_WORKSPACE_PROJECT_ID) with source caught-triage. This is a real paid operation that costs tokens.
Cut & paste a task
Move a task with Ctrl/Cmd+X (cut) then Ctrl/Cmd+V (paste) — the same cut/paste you know from files. Cut is a move; Copy (Ctrl/Cmd+C or the ⋯ / right-click Copy row) now pastes too, as a duplicate — the original stays put and a copy lands where you paste, into the same project or any other (a brand-new one included). A copy of a repeating task repeats on its own — even when the original was already finished and had spawned its next occurrence, the copy starts fresh and spawns its own next one when you finish it. (Duplicate, Ctrl/Cmd+D, works only on a task still in your list, and its copy repeats on the same schedule.) Cut and copy share one clipboard (arming one clears the other), and both paste the same way (below the highlighted row, or into a project heading):
- Ctrl/Cmd+X marks the highlighted task (or a multi-selection) to move. With multiple rows selected, only the topmost selected tasks are cut — a parent+child selection keeps the child's nesting under the parent (same rule as Finish / Move). The row dims and gets a dashed outline and a small ✂ cut tag (hover it for the paste/cancel hint). The task does not move or vanish — if you never paste, nothing changes (cut only marks).
- Ctrl/Cmd+V moves the cut task(s) to right below the highlighted task — in the project list
and the All Projects view (Today shows your cross-project plate and does not host cut/paste;
pasting a link onto a focused Today task still works). A
single-project list, the All Projects giant view, and moving a task between projects all
land it directly under the highlighted row now (carried into that row's project when they
differ). Nesting under a cut parent is preserved. The cut mark then clears. A cut task that is
finished, filed away or deleted somewhere else (the Inbox, an agent, another window) drops its
cut mark on the next sync, so a project heading click is never swallowed by a paste of a task
that is gone. One exception: a
group cut (several tasks) in one project can't be pasted into a different single-project
view, because that view only holds its own project's rows. Omniscio says so and points you to
Move to project or to pasting from All projects (where every row is on screen) instead of
a "try again" that could never work; the refusal is also logged (
group paste refused). A single cut task still moves between projects from a single-project view. - Copy → paste is a DUPLICATE. Copy a task (Ctrl/Cmd+C or the Copy row), then paste it (Ctrl/Cmd+V / Paste here / onto a project heading) to drop a copy in that spot — the original is untouched, so you can paste the same task into several projects, or into a brand-new one. Unlike a cut, a copy stays on the clipboard after pasting (paste it again) and survives even if you later archive the original — but it stops pasting a task once you copy something else. If you copy a chat message, a note or anything else outside Tasks after copying a task, the paste in Tasks becomes a no-op instead of dropping an old copy of the task; copy the task again to paste it. Copy carries the task's own line (not its sub-items or notes); to copy a task with everything under it, use Duplicate (Ctrl/Cmd+D, below).
- Paste into a fresh blank row. After you copy or cut task(s), you can press Enter to add a new task and then Ctrl/Cmd+V — Omniscio drops the copied/cut tasks into that spot and clears away the empty new-task line, so the paste lands exactly where you started the new task. (Typing anything into the row first, or having nothing on the clipboard, keeps Ctrl/Cmd+V a normal text paste. So does pasting into any other box on the Tasks screen, such as Add a task: the takeover only happens when the box you paste into is that blank row's own editor.)
- Onto a project HEADING instead (All Projects) — drop the cut task straight INTO a project, even an empty one (appended, since a heading has no task to sit below). Two ways: with the keyboard, land the cursor on another project's heading and press Ctrl/Cmd+V; with the mouse or on a phone, just CLICK that project's heading while a task is cut — the click drops it in instead of folding the project (and a collapsed target opens so you see it land). That click is how you fill an empty project without a keyboard. Clicking a project you can't move into — the synthetic (Unfiled) heading, or the task's own project — just folds it as usual (and pasting a task onto itself is a no-op). With nothing cut, clicking a heading folds it exactly as before.
- Prefer a picker? Press
Von a task to choose the destination project from a small menu — the same as the ⋯ / right-click Move to project. Handy in a single-project view, where there's no other project on screen to paste onto. - Esc cancels a pending cut; cutting another task moves the mark; archiving or deleting the cut task clears it. A failed or not-allowed paste keeps the mark so you can retry.
- It also lives in the ⋯ menu and the right-click menu as Cut and Paste here, so it
works with a mouse and on a phone (no Ctrl key there). The keys (cut / paste / move-to-project)
are rebindable (Settings → Keyboard Shortcuts → Tasks) and show in the
?cheat-sheet. - Precise within-project paste needs the manual sort with no filter (the same rule as drag / Move up-down — under another sort the on-screen order is just a view); if you're sorted or filtered, Omniscio tells you instead of dropping the task somewhere misleading. While you're typing in a row, Ctrl/Cmd+X/V stay the normal text cut/paste.
Duplicate a task with everything under it (Ctrl/Cmd+D)
Ctrl/Cmd+D on a highlighted task puts a full copy right below it: the task and its open sub-tasks (at every level), each keeping its text, dates, priority, estimate, energy, context and tags, plus the notes, links and other context items on the task and on each sub-task. The copies are new, independent tasks — editing a copied sub-task never touches the original. The cursor moves to the new copy, and one Ctrl/Cmd+Z removes the whole copy.
- Text you are still typing is saved first, so the copy carries the words on screen, not the last saved version.
- It also lives in the ⋯ menu and the right-click menu as Duplicate, so it works with a mouse and on a phone (no Ctrl key there). That row runs the same copy as the key, and its tooltip names the key. Ctrl/Cmd+D itself is fixed — unlike cut / paste / move-to-project, you don't rebind it.
- Archived sub-tasks (finished or dropped) are left out — only what is still in your list is copied.
- Attached files are not copied (the stored copies in the Attachments strip stay with the original), and the copy starts with no snooze history and is not on Today's plate.
- With several tasks selected, each topmost selected task is copied with its sub-tasks; a selected sub-task of a selected parent is copied once, inside its parent's copy.
- Size limit: a task with more than 500 sub-tasks under it, at any depth, isn't copied, and Omniscio says so — copy a smaller part instead.
- The whole copy is written in one step, so it either all lands or none of it does. The
:command line'sduplicateand Copy → paste still copy just the task's own line.
Paste a link onto selected words → a hyperlink
Select some words in a task and paste a link (any http(s) URL) — the selected words
turn into a clickable hyperlink to that address, instead of the raw URL landing as plain
text beside them. It's the same gesture every notes app and chat box uses: highlight
the spec, paste https://…, and the row now shows the spec as a link. Works in both the
"+" quick-add row and when editing an existing task; undo with Ctrl/Cmd+Z.
- On an existing task the row drops straight back to its rendered view after the paste, so
you see the finished clickable link immediately instead of the raw
[words](url)markdown source. (In the "+" quick-add row the text stays as you type and becomes the link on Enter.) - It only kicks in when you have text selected and the clipboard is just a URL. Paste a URL with nothing selected and it drops in as an ordinary (still clickable) link; paste plain text and nothing special happens — your paste is never hijacked.
- Want to type the label yourself, or add a link without selecting first? Ctrl/Cmd+K opens the Insert-link popover (see the shortcuts table). The paste gesture is just the fast path for the common case.
- Non-web schemes (
mailto:,ftp:,javascript:) are never turned into a link.
Edit a link you already added
Got a link in a task and need to fix where it points or change its wording? Right-click the link and pick Edit link. A small box opens pre-filled with the link's current address and text — change either, hit Save, and just that one link is rewritten in place (the rest of the row is untouched). Like every other link edit, it's Ctrl/Cmd+Z-undoable.
- Edit link sits right next to Copy link in the menu that pops up when you right-click a link — so a link's own right-click menu is where you copy it OR edit it.
- It finds the exact link you clicked even when a row has several, and even when a pasted-URL link's on-screen text was shortened to keep the row tidy (the full address is still there to edit).
- This is a Tasks thing — links in chat and the inbox keep their usual right-click menu.
A bare link → its title
Add a task whose text is just a link — a YouTube/Vimeo video or any other web page — and,
a beat later, it becomes a clickable link labeled with the page's real title:
https://youtu.be/dQw4w9WgXcQ turns into Rick Astley - Never Gonna Give You Up, and a bare
article / GitHub / docs link turns into that page's headline. Under the hood it's stored as a markdown
link ([title](link)) and the row renders task text as markdown, so you get the readable title and
keep the click-through — never dead, un-clickable text. The raw link is always kept inside the
titled link, so nothing is ever lost, and Ctrl/Cmd+Z snaps a just-pasted link back to raw.
It fires no matter how the link got there — including links already in your list. Paste a video link into the "+" row or a task title and you get an instant spinner + Ctrl+Z; type any link, or hit Enter before the title loads, and it still gets titled a beat later (titling is keyed off the saved task, not the typing box). Links you already had — added before this feature, dropped in by an agent, or created any other way — now get titled automatically when the list loads (a one-time, per-session background pass). And for any bare-link row you can right-click (or open its ⋯ menu) and pick Get link title on demand.
- It only fires when the task text IS the whole link. A link dropped into the middle of other
words is left alone, and non-web schemes (
mailto:,data:, …) aren't touched. Twitter/X isn't auto-titled from a paste (a tweet has no "title" that reads as a task). - While a title loads a small spinner shows in the row's trailing edge; if the fetch fails or times out (offline, a private/blocked page, a page with no title), it quietly keeps the raw link — no error popup, and the link is still a perfectly good task.
- It's free and safe — a video title comes from YouTube/Vimeo's public oEmbed (with an
og:titlepage fallback for Vimeo's firewall); any other page's title comes from the same security-hardened fetcher the chat link-preview uses (it blocks private/internal addresses, follows redirects safely, caps size + time, and is rate-limited). Both run in the main process (the renderer can't make outbound calls) and cache results, so a re-load never re-hits the site. - The backfill never disturbs you. It tries each link once per session, never re-touches a link it already titled, keeps the raw link on any failure, and — importantly — doesn't touch your Undo history, so Ctrl+Z always undoes your last edit, not a background titling.
- Never clobbers what you wrote. The title lands only while the row still holds exactly that link; edit it in the meantime and the title is quietly dropped so your text wins.
Paste an internal link → attach it to the task
Copied a link to a session — or to a specific comment/message inside one (the "Copy link"
on a session's menu, or "Copy link to this message")? Or a link to a project, a chat
message, a KMS note, a super prompt, a mind map, a setting, a shared
conversation? Paste it into a task and that entity is attached to the task — the same
kind of link the "Attach" picker makes — instead of the raw omniscio://… address landing as
text. It appears under the task's 📎
Context attachments (click the chip to open it), and a toast with Undo
takes it right back.
- On a task you're editing, it attaches the instant you paste and the raw link is dropped. In the "+" add-a-task row, pasting a link fills the row with a label (session name / project name / a friendly noun like "Chat message") as a starter title and attaches it when you press Enter to create the task (type your own title over it if you'd rather). On a focused task in command mode, paste it straight onto the task the same way.
- A link to a comment attaches its parent session (there's no separate "attach a comment");
session and project links attach as rich session/project context items, and any other internal
link attaches as a clickable link item that opens the entity when clicked. Older
agentmc://…links work too. - It only fires when the clipboard is the whole link — a link pasted into the middle of other words is left alone, and a normal web/video link still does its own thing (see A bare link → its title). Already attached? It won't add a duplicate.
- No new setting — Undo is the off-switch (same as the bare-link titling above).
Archive & universal undo
Finishing a task marks it done and files it into Archived in one step — completing and clearing it off your list together (think email Archive vs. Trash; Delete still exists separately).
Two outcomes, so Archived reads as a real ledger. Complete says you did it. Drop files the task away without marking it done, for the things that stopped mattering rather than got completed. Both clear the task and its sub-tasks off your list; only the record differs. Drop is on the row's Drop button (the box icon beside the checkmark), the ⋯ and right-click menus, the bulk bar, and Shift+X (X finishes, Shift+X drops). With several tasks selected, both keys act on the whole selection as one undoable step, and the highlight moves to the next task still on your list (or the one above, at the end). Undo restores the exact outcome — a dropped task that you undo and redo comes back dropped, never quietly finished. Dropping a repeating task asks first: Just this one drops this copy and the next one still comes, Stop repeating ends the series, Cancel drops nothing. Finishing always rolls it forward.
Deleting one task from its menu. The ⋯ More actions and right-click menus have a Delete row right after Drop. It really deletes the task and its sub-tasks: they go to Recently deleted (restorable for 30 days), not Archived, and the toast's Undo or Ctrl/Cmd+Z brings them straight back. There is no "are you sure?" step because the undo is there. The bare Delete key is unchanged and still means Drop. Deleting a repeating task asks first, in Delete words: Just this one deletes this copy and the next one still comes, Stop repeating deletes it and no more come, Cancel deletes nothing. Undo removes the next copy again (if it is untouched) and brings the deleted one back. If "Just this one" could not make a next copy (say the task has no due date), a warning says it won't come back.
Undoing a finish of several repeating tasks removes their next repeats and reopens the
originals. The undo only counts as done when the originals really come back: if the save
answers that it restored nothing, or set a task aside because it was deleted on another
device, the undo reports a failure instead of quietly succeeding. It then puts the next
repeats back and says which way it went: either nothing changed and the next repeats are
still there, or the next repeats could not be brought back and the tasks are only in
Archived for now. Pressing Ctrl/Cmd+Z again retries; the retry removes the next repeats
again only when they really came back, so a task never ends up live next to its own next
repeat after a retry. When the next repeats cannot be put back, the app also logs a warning
naming them.
The Archived area badges every item Done or Dropped, with a filter to see just one. Anything archived before this shipped is badged a neutral Archived: back then archiving always wrote "done", so that flag can't tell whether you finished the task or abandoned it, and the ledger won't claim an outcome it cannot know.
The number beside Archived in the projects rail counts items the way the Archived area lists them: a task archived together with its sub-tasks counts once, and a sub-task archived on its own while its parent stays on your list counts once too.
The panel pages the ledger, and judges a row's place from the whole archive rather than the
page it happens to have loaded. Rows arrive newest-archived first, 500 at a time, and a task
archived together with its sub-tasks shares one archive timestamp — so a single subtree can
straddle a page boundary. The list read therefore hands the panel childIds: the rows on that
page whose parent is itself archived, read from the parentArchived flag the archived-list query
sets on every row (listArchivedTasksV2), the same root test the rail's count uses
(countArchivedTasksV2). A sub-task whose parent sits on the next page is
never presented as its own archived item, and never restored into the top level of its list on
the mistaken belief that its parent is gone.
The count in the panel's own header says the same thing as the rail entry you opened it from. While older pages are still unloaded it names both numbers, what you have loaded against the rail's total, so "(500 of 1,234)" means 500 archived items are on screen and the archive holds 1,234. Once the last page is in, it shows the bare total, so the header and the rail entry never disagree. With a project filter, an outcome filter, or a search active the header counts only what matches, which is narrower than the archive-wide total on purpose.
The panel's two filters are scoped by each other: the outcome choices are the outcomes present among the project-filtered groups, and the project choices are those still holding a row of the chosen outcome, so neither control offers a choice that yields nothing. The outcome control itself stays visible archive-wide, so picking a project cannot make it disappear.
Restoring from Archived brings a task back exactly as it was before you archived it. A task that was still open when you finished it comes back open; one that was already checked off comes back done; each sub-task gets back its own earlier state. A task archived before this behavior shipped has no remembered state, so it comes back open — you restore a task to work on it, and the ledger never knew whether it was finished. Dropping a task you had already checked off keeps it marked done in the ledger: a drop never erases the fact that you finished it. A sub-task you had snoozed is spared when you finish its parent and moves to the top of the project; restoring the parent puts it back under it (unless you moved it somewhere yourself in the meantime). A sub-task you archived on its own keeps up with its parent: if you move the parent to another project, the archived sub-task moves too, and restoring it puts it back in the parent's project.
You finish a task three ways, all equivalent (they finish the task and its sub-tasks):
- Check the box — the primary gesture. The task's text is struck through at once and stays on screen for a moment (~0.4s), then the row smoothly collapses + fades (~0.2s), is marked done, and tucks into Archived. (Under reduced-motion or low-power mode the pause and the collapse are skipped and the row finishes instantly.)
- The Complete row in a focused task's ⋯ menu (works on touch + keyboard).
- The
xorekey on the highlighted task (command mode).
Middle-clicking a row is not one of them, though it is the fastest way to clear a row away: it drops the task — filed into Archived without being marked done — and asks first when the task repeats. (Omniscio suppresses the browser's middle-click scroll "compass" so the gesture is clean.) Right-click opens the row's full action menu, where Complete is one of the options.
Every finish shows a small "Task complete" toast with an Undo button, so a
mistaken check is one click to take back. That button runs the same undo as Ctrl/Cmd+Z and
takes it off the undo list, so pressing Ctrl/Cmd+Z afterwards never undoes the same finish
twice. (A Drop shows no toast, except "Archived. Next one <date>" with Undo when you keep a
repeating task going. When a repeating task stops repeating, the warning toast
carries the same Undo button.)
Finished tasks leave your lists, counts, and the tasks-v2.md mirror and
collect in a browsable Archived area — open it from the "Archived" entry pinned at
the bottom of the project rail (it shows a count of what's inside) or the header ⋯
More → Archived. It opens as a dedicated tab that takes over the main area — your
active task list and the "Add a task" box are hidden while it's open, so finished items
never linger beneath it; click Done (or pick a project in the rail) to return. Inside,
items are grouped by project, with a project filter dropdown to show just one
project's archive, and each row shows when it was archived (the exact time on hover).
The Search archived box matches the way the main find bar does: any line of a task's
text, its tags (work or #work), and its archived sub-tasks, so a match on a sub-task
shows the task it was archived under.
Search and the filters narrow the whole archive, not just the page on screen. The
Archived area still opens one page at a time (500 items), but the Search archived box,
the project filter (including Unfiled) and the outcome filter — the ledger's twin of the
project filter, "what did I actually finish?" against "what did I drop?" — travel with each
page request, so a match older than the pages you have already loaded comes back instead of
reading as missing, and Load more keeps walking the narrowed list rather than the whole
archive. The choices themselves stay local view state, never saved, and the panel also
narrows the rows it already holds, so picking one takes effect before the fresh page
arrives. The Load more button stays available whenever older pages exist, including when the
search or a filter matches nothing among the rows you have, so an old item is one click away
instead of reported missing.
Each row's Restore button sits on the left and appears on hover (always visible
on touch); Restore brings the task back active and unchecked (if a task's original
parent is gone, Restore returns it to the top of its project so it never dangles).
Restoring a parent brings back the sub-tasks that were archived with it, still nested
under it, whichever way you restore it (the Archived area or the CLI). A sub-task you
archived on its own, earlier, stays in Archived until you restore it.
A bare Delete — or Ctrl/Cmd+Delete — archives here too. Ctrl/Cmd+Delete used to be a
separate soft-delete that stranded the task (no toast, not browsable), and a bare Delete did
nothing; both now land in Archived like every other remove gesture, filed away without being marked done. Only checking a task off, Complete, or the x / e keys finish it, so only those count as done today; a middle-click files away too. The bare Delete works only
in command mode (never while editing a row's text) and never on a project heading, so it can't
wipe a whole project — and it's Delete only, not Backspace. On a Mac laptop, whose delete key sends Backspace, Cmd+Backspace does what Cmd+Delete does, under the same command-mode-only rule. Ctrl/Cmd+Delete is also
command-mode only: while you are typing in a task it erases the next word, like it does in any
other text box, and never archives the task out from under you.
A deleted task is kept for 30 days, then it's gone. Deleting a task hides it and keeps everything it carried — its text, its context, the sub-tasks deleted with it, the day it was on — for 30 days.
Recently deleted — bring a deleted task or project back. Open Recently deleted from ⋯ More → View → Recently deleted. It lists the tasks and projects you deleted in the last 30 days, newest first, grouped by project, with how many days each one has left and a Restore button (or press Enter on a row). Type in Search recently deleted to narrow the list. It loads the 500 most recent tasks and the 100 most recent projects first; once there are more tasks than that it says "Showing the 500 most recent." and a Load older deletions button loads the next page. Each task row also has a Delete forever button (the X). After you confirm, it removes that task, its notes and its attached files right away, skipping the 30-day wait; it cannot be undone, and it works even when Permanently remove deleted tasks after 30 days is off. With the 30-day purge switch off, the list also shows deletions older than 30 days. Restore puts a task back in its project with the sub-tasks, notes and files that were deleted with it. A sub-task whose parent is gone comes back at the top of its project; a task that was archived when you deleted it goes back to Archived; and a task inside a deleted project comes back when you restore the project, which is listed at the top with its task count. Deleting a project also shows a "Deleted …" toast with an Undo button, and right after any delete Ctrl/Cmd+Z works too. For a task you might want past those 30 days, archive it instead — it goes to Archived, where Restore works any time. Recently deleted works on a paired phone too (⋯ More → Recently deleted): the same list, the same Restore button and the same Delete forever action, and only for the account you are signed in to, so another account's deleted tasks never show up and can never be restored from your phone. When the phone is set to ask for your account sign-in, Restore asks for it first, the same as other changes made from the phone. Files attached to a deleted task stay with it, so Restore brings them back, and they are erased from disk when the task is permanently removed. A file you remove yourself from a task that is still around waits the same 30 days and is then erased from disk, and it follows the same Tasks switch: a shorter Data Retention setting never takes it sooner, and with that switch off the file is kept indefinitely. Past those 30 days the task is permanently removed, including its lines in the day journal, so a task you delete does not live on in the app's database or in your backups forever. Undoing a delete inside the window clears its clock: a task you brought back is a normal active task and is never removed. Nothing to configure and nothing to remember to do — the sweep runs once a day on its own. It is one switch if you ever want it off — Permanently remove deleted tasks after 30 days, under Privacy & retention on the Tasks settings page (search Settings for it), on by default: with it off, deleted tasks and their attached files are kept indefinitely.
A deleted task waits in Recently deleted for 30 days, where you can bring it back; after 30 days it is removed for good.
Your tasks travel between computers through Backup Mirror, not Cross-Device Sync. If you use Tasks on more than one computer, turn on Backup Mirror (Settings → Backup & Restore → Backup Mirror) with Automatic sync on, on each of them: your tasks, projects and day journal ride its archive. Cross-Device Sync does not carry Tasks yet, so keep Backup Mirror on even after you switch to it. Caught suggestions stay on the computer that caught them.
The same daily cleanup clears a few other things too. It permanently removes:
- a project you deleted, 30 days after you deleted it, once none of its tasks are left (a shorter or longer Data Retention setting does not change this);
- a link on another task that pointed at a task which was permanently removed;
- a check-in you deleted, after 30 days;
- a check-in conversation that is more than 90 days old, whether or not you deleted it — the same daily cleanup that trims the day journal clears these on the same 90-day window, so your planning chats do not accumulate forever;
- a note or link you removed from a task, or a breakdown interview you started over, after 30 days — even while the task itself is still around;
- the written conversation and plan of any check-in older than 30 days (its day and whether you accepted it stay until the 90-day cleanup above removes the check-in, so your accept rate does not change);
- what Tasks learned about you, 30 days after you reset it (a shorter or longer Data Retention setting does not change this). Resetting what Tasks learned also erases your check-in conversations there and then rather than only flagging them — the reset dialog's promise to "clear the history it draws from" covers them, and the rows are gone from the database immediately, not after a further wait;
- a Caught suggestion you already kept or dismissed, once your Data Retention window has passed (never sooner than 14 days after you answered it, so a short window cannot bring back a suggestion you dismissed: the same text is not suggested again for 14 days, which is
CAUGHT_DEDUPE_WINDOW_DAYSinqueries-tasks-v2-caught.ts, shared by the scan and the sweep; the window exists because several agent sessions on one piece of work all surface the same follow-up, for example the same line from four channel rooms, and a suggestion you already dismissed must not come back from the next session end). At that point the row is only hidden and its source message and sender are erased; the suggestion text stays until one more Data Retention window has gone by, so with the default 30-day window it is gone about 60 days after you answered it (about 120 days for a suggestion you dismissed as not a task, which waits at least 90 days); - a Caught suggestion you never acted on: it leaves the lane 31 days after it was caught, is hidden from the app once your Data Retention window has passed on top of that, and its text is erased one more Data Retention window later (about 91 days after it was caught with the default 30-day window).
Turning off the deleted-task switch keeps the deleted tasks themselves, the projects you deleted, and the files attached to them — and nothing else: deleted check-ins, the conversation and plan of older check-ins (until the 90-day cleanup above removes the check-in), removed notes, restarted interviews and reset learnings are still cleared by the same daily cleanup. It does not keep Caught suggestions you already decided on or left hidden either. Those are always cleared.
A task you deleted stays deleted — on every computer you sync. Once a deleted task is permanently removed, no backup restore or Backup Mirror sync can bring it back, even from another computer that still has it. And when you delete a task on one computer, your other synced computers never delete it on their own: the next time one of them syncs, it shows an inbox notice — "'Buy milk' was deleted on LAPTOP. Delete here too?" — with Yes / No (or Yes to all / No to all when several tasks were deleted). Yes deletes the task on that computer too: it goes to that computer's Recently deleted, where you can restore it for 30 days (this delete has no undo step). No keeps it, and you are never asked about that task again.
Universal undo — Ctrl/Cmd+Z. Nearly every change you make in Tasks — add, rename,
check-off, archive, delete, reorder, indent, move-to-project, a pick on the class chip — can be undone with
Ctrl/Cmd+Z, and you can keep pressing it to walk back through your recent changes
(up to 100 steps per session). It is a real undo: it puts the data back in the database (so it
sticks), not a screen repaint. A continuous run of typing on a row counts as one undo
step — so undoing a rename reverts the whole edit at once, never one letter per press. A
rename also puts back the Looks due date the old wording carried, since replacing the
wording is what changed it.
Undoing a class-chip pick puts back the class the task showed before and whether you or the dials
had set it, so a class you chose yourself comes back as yours.
Undoing a delete brings back the task's notes, attachments, delegations and interview along
with it; undoing anything else (a check-off, move, reorder, archive or edit) leaves alone a note
or attachment you had deleted from that task yourself, so it never reappears.
An undo puts back only what that action changed. Undoing a check-off puts the tick back and
leaves the task's wording, due date and note as they stand now, so an edit made in the meantime —
in another window, from the CLI, or by an AI agent — is never rolled back. Moves, reorders,
archives, deletes and bulk edits work the same way. Undoing a finished repeating task also
clears the internal stamp that marks its next occurrence as already created, so finishing the
restored task again still creates the next one.
Undo never brings back a task that was deleted somewhere else (another window, an agent, the
CLI) — only undoing your own delete does that. Undoing a text or field edit is also
skipped when the task changed somewhere else after your edit, so the newer change is kept: you
see "Couldn't undo that." and the list refreshes to show the task as it is now. That skipped
step is dropped from your history, so Redo never brings your older version back over the newer change.
Four honest limits: (1) undo history is per session and per view — it
starts fresh whenever you switch to another project or view (All Projects, Today, a single project)
and when you quit and reopen Omniscio (surviving a restart is a separate, later feature);
(2) undo keeps at most your most recent 100 changes, and fewer after several large bulk
actions (see the 5,000-row budget below) — older ones drop off, so Ctrl/Cmd+Z stops there; (3) when a bulk operation touches more than 2,000 tasks and sub-tasks, the
Finish-all, Delete-all, and selection Finish/Drop/Delete confirmation dialogs tell you
the operation cannot be undone — the toast drops its Undo button, and older undo
history is cleared so Ctrl/Cmd+Z cannot replay a stale entry against the changed data.
Operations without a confirmation dialog — keyboard shortcuts (Ctrl/Cmd+Delete),
Complete/Drop with skip-confirm, and drag-and-drop bulk moves — are undoable up to
2,000 tasks and sub-tasks as well. Past that they still run, with no warning and no
Undo step, and the drag's Moved to toast shows no Undo either: the tasks go to
Archived, where you restore them by hand. Below that, a 5,000-row budget evicts
only the oldest entries.
This keeps memory bounded so a heavy day of bulk archiving/deleting never grows the renderer
indefinitely.
(4) Some changes never go on the undo history: Keep on a Caught suggestion and the free
Re-arrange today button on Today. Pressing Ctrl/Cmd+Z right after either one undoes your
previous change instead, and what they added or moved stays put, so remove or move those tasks by
hand. Accepting an AI step is undoable: Accept plan in Plan my day, Accept focus in the
check-in and Add N subtasks in Break it down each put one undo step on the history, and so
does Arrange today with AI.
While you're typing in a row, Ctrl/Cmd+Z is the normal text undo; the task-level undo
runs in command mode (a highlighted, non-editing row) — and a mouse-only archive
(middle-click, the checkbox, or the ⋯ menu) keeps keyboard focus on the list so Ctrl/Cmd+Z
lands right after it, including from the "No tasks yet" screen when you archive your last
task. It works from the project list too, so Ctrl/Cmd+Z right after deleting a project brings
it and its tasks back without clicking into the task list first, whether you deleted it from the ⋯
button or by right-clicking the project. It also works right after you add a task: the cursor stays
in the empty "Add a task" (or Today's "+ Add to today") box, and while you have typed nothing there
yet, Ctrl/Cmd+Z undoes the add and Ctrl/Cmd+Y redoes it. Once you type in the box, those keys
are the box's own text undo again, even if you delete what you typed. (Under the hood every undoable action records its exact inverse and replays it as a real
operation — v2 only; the older Tasks list and Tasks are untouched.)
An undo that fails stays put, and says where things stand. If an undo cannot be saved, the
step stays on the undo history, so pressing Ctrl/Cmd+Z again retries it — it is never quietly
used up, and Ctrl/Cmd+Y never replays a change that did not happen. When the undo is slow
enough that the app stops waiting (a save that times out) the undo's outcome is unknown
rather than failed: the change stays undone on screen, no "Couldn't undo that" appears, and the
list reloads from the database to show what actually happened — the step does not go back on
the undo history, so it is never replayed twice. Two undos also tell you
exactly what state you are left in: undoing a deleted project says the project and its tasks
are still deleted, and undoing a finished recurring task that only got halfway (the next
repeat was removed but the finished task could not come back) says the task is only in
Archived, where you can restore it, and a retry picks up from the step that failed.
An undo whose tasks are already gone fails out loud. If the tasks an undo would bring back no longer exist (removed elsewhere, or by another device), the undo reports that it couldn't be done and the screen goes back to how it was, instead of showing a task that isn't really there.
Redo — Ctrl/Cmd+Y. Anything you undo, you can redo with Ctrl/Cmd+Y (or
Ctrl/Cmd+Shift+Z) — it re-applies the change you just took back. You can redo everything you
just undid, up to the same 100 steps as undo, and it's a real redo that persists to
the database. Starting a new change clears the redo trail (the standard "once you do
something new, there's nothing left to redo" rule). Redoing a typed word re-applies the whole
word at once, and redoing an added task or a finished recurring task brings back the
same row / the same next occurrence — never a duplicate. While you're typing in a
row, Ctrl/Cmd+Y is the normal text redo; the task-level redo runs in command mode, exactly
like undo.
Projects, the Inbox and a few small helpers
- Renaming the Inbox only changes its label. Tasks remembers which project is your Inbox, so a renamed Inbox still catches new tasks that have no project, and naming another project "Inbox" does not move the role to it.
- Deleting a project tells you everything it removes. The confirm counts the open, finished and archived tasks inside, for example "Deleting "Garden" also deletes 7 tasks: 1 open, 4 finished and 2 archived."
- A blank project name is explained. Pressing Enter with no name shows "Name your project first." instead of doing nothing.
- Unsent text stays with its project. Text you typed in a project's add row, but did not save, stays with that project when you switch away, and is there when you come back.
- Zooming into a snoozed or waiting task says so. A note under the breadcrumb reads "Snoozed, wakes Thursday, Nov 5 (in 3 days)" with Wake now, or "Waiting on Sam" with Clear.
- Old shortcut settings clean themselves up. A saved shortcut for a Tasks command that was renamed or removed is dropped, and one notice says so, so its keys are free to use again.
- "Use my calendar" (Customize, and Settings search) controls whether Today and Plan my day read your Google Calendar. It is on by default once a calendar is connected; meeting names are only sent if "Show meeting names in AI planning" is also on (off by default). With it off, Plan my day never reads your calendar. Both also need the Google Calendar integration itself switched on: with that switch off, Today and Plan my day never read your calendar or send it to the AI, even when Google is connected for Gmail.
- A file with no tasks is refused clearly. Importing a file that holds only blank space shows "This file has no tasks in it."
- Per account, not per computer. Your answer to the "move to Mission Control" suggestion and your Tasks milestones belong to the Omniscio account you are signed in with.
Related
The overview, the other parts, and everything else worth reading next all sit on Tasks (markdown outliner, in development).
Last verified 2026-11-03