Omniscio

Tasks (markdown outliner, in development) (part 7)

Press / (or Ctrl/Cmd+F), or click the header's Find button (πŸ”), and a find bar opens under the header. Type and the list filters live, in the giant All-Projects view and a single project alike: matches (and their parent tasks) stay visible, the rest drop away, and the matched letters are highlighted.

On this page

What it is

This is part 7 of the Tasks (markdown outliner, in development) page β€” the next stretch of that material, split off because a single page is capped at 40,000 characters.

Where to find it

Reach this part through Tasks (markdown outliner, in development), which lists every part and explains where the feature lives in the product.

How it behaves

Find tasks β€” / or Ctrl+F

Press / (or Ctrl/Cmd+F), or click the header's Find button (πŸ”), and a slim find bar opens under the header. Type, and the list filters live β€” in the giant All-Projects view and in a single project alike. Matches (and their parent tasks, so you can see where they live) stay visible; everything else drops away; matched letters are highlighted in each row. Long lists build rows as they scroll into view, so a row you scroll to is highlighted when it appears. It searches task text and #tags, ignores case and accents ("cafe" finds "CafΓ©"), and shows a live "N found" count (completed matches are left out while Hide completed is on). Start with # to search tags: #work finds every task tagged work. Snoozed tasks are findable too, surfacing in their Snoozed section. Collapsed projects and folded sub-items open for a match while the search is active (your folds come back when it closes).

Press Enter to jump the keyboard onto the results, Esc to close. Closing always clears the query β€” a hidden search can never keep quietly filtering your list. It's a view overlay: searching never changes your saved order (drag-reorder pauses while it's active). The keys are rebindable (Settings β†’ Keyboard Shortcuts β†’ Tasks β†’ "Find tasks").

Select many & act once β€” Ctrl+A + the bulk bar

Build a selection any way you like. Ctrl/Cmd+A selects every visible task (in the giant view: across all open projects). Or use the mouse: Ctrl/Cmd+click adds or removes one task, Shift+click takes everything between the last-clicked task and this one (keyboard Shift+↑/↓ still extends row by row). A plain click goes back to a single highlighted task and drops the group. At 2 or more selected a bulk action bar appears under the header with a live "N selected" pill and one-tap actions.

On a phone or tablet the defaults give you no way to select β€” the shortcuts need a keyboard and a plain tap drops any selection, so the bulk bar and group menu stay out of reach. The one way in on touch is Checkbox selects: the row's checkbox selects on a tap and ticking a second row adds it. Ctrl/Cmd+click and Shift+click work on the checkbox too, not just the row text.

Prefer email-style checkboxes? Turn on Checkbox selects (Customize, or Settings) and a plain box click selects instead of finishing, so one stray click can never clear something. The bar then appears at one checked task rather than two, Done and Dropped move to the bar and the row's hover buttons, and clicking another task's text no longer wipes what you've checked (clear with Esc or the bar's βœ•). Off by default.

Tired of the "are you sure?" step? Turn on Finish without asking (Customize, or Settings β†’ "Finish tasks without asking") and bulk Finish / Drop archive on the spot, covering all three askers β€” the bulk bar, the right-click-a-selection menu and a project header's Finish all β€” at any selection size. An archive whose undo entry fits still fires its Undo toast and Ctrl/Cmd+Z entry and lands in Archived, not deleted; a selection too large for the 2,000-row undo cap is archived with no undo record (no toast, no Ctrl/Cmd+Z) but is still in Archived, restorable by hand. Delete is never covered: a bulk delete has no archive-ledger undo, so Delete all and the selection menu's Delete confirm regardless. Off by default (tasksV2SkipFinishConfirm); a single-task finish never confirmed anyway, so this only bites once a selection exists β€” most visible with Checkbox selects on, where one checked row counts as a selection. Invariant skip-finish-confirm.

Action What it does
Snooze one time picker β†’ every selected task snoozes to it
Add to Today puts every selected task on Today in one step (also Y, or the right-click menu); meetings, finished tasks and tasks already on Today are skipped, and one Undo takes them all off. When all are already on Today it reads Remove from Today and takes them all off
Due one date β†’ set on every selected task; a task whose start date would land after that date has its start pulled back to it
Priority one level β†’ set on every selected task
Estimate one time estimate β†’ set on every selected task: 15m, 30m, 1h, 2h or 4h, a duration you type (e.g. 1h 30m), or None to clear it
Move pick a project β†’ every selected task moves there (sub-items travel with their parents)
Finish done + archived, the whole selection at once
Drop archived without being marked done β€” "I'm not doing these" (the honest exit)
βœ• clear the selection (Esc does too)

Only Finish counts as done. "Done today" (Plan My Day, the evening close-out, the check-in recap and the day log) counts only tasks you actually finished. Anything filed away unfinished β€” Drop, the Delete key, a middle-click, or Drop task on a Tasks reminder or trickle card (its toast says "Task dropped.") β€” never counts.

Selections are smart about nesting: selecting a task and its sub-item acts on the parent once β€” the sub-item rides along, never twice. Every bulk action is one Ctrl/Cmd+Z. (While you're typing in a row, Ctrl+A stays select-all-text.)

The move keys (Shift+W/Shift+S, Alt+Shift+↑/↓) and the β‹― Move up / Move down rows move a multi-selection as one unit that stays together, order preserved. A block at one level shifts within it; a selection spanning a grouped item (a sub-item plus the row below its group) still moves together β€” a sub-item pulled above its group becomes a top-level task so nothing is left behind β€” and never crosses into another project. A block already at the top / bottom stays put; one move is one Ctrl/Cmd+Z. While the list is sorted by due date, start date or priority, those keys move a row by taking the value of the row next to it on screen and landing it on the far side of that row, the same as dragging it there, read inside the row's own project β€” the last row of one project pressing down, or the first pressing up, stays put rather than picking up a neighbor project's date.

Every keyboard row action acts on the whole selection. With 2+ selected, Tab/Shift+Tab (or Alt+Shift+←/β†’, Shift+A/Shift+D) indent/outdent the whole block, finishing (x / e / Delete) finishes every selected task in one undoable batch, and Ctrl/Cmd+D duplicates each topmost selected task with its open sub-tasks (a selected sub-item of a selected parent is copied once, inside the parent's copy; one undo). This holds in all three surfaces (the giant view, a single project, Today); a single highlighted row still acts on just that row.

Right-click the group β€” or tap the bar's three-dot button. The bar's More actions button (the only route on a phone or tablet, which has no right-click) or a right-click on any task in the selection opens the full menu β€” the same menu a single task gets, but every action runs across the group: Finish Β· Delete (asks first) Β· Snooze Β· Due Β· Priority Β· Move to project Β· Star / Bold / Highlight Β· Copy Β· Cut. Right-clicking a task outside the selection drops the group and acts on that one. Cut the group and Paste it below any task β€” or onto a project heading β€” to move the whole set at once, across projects; Copy and paste duplicates it (the originals stay). Paste into a brand-new blank row replaces that row: the tasks land in its place and level β€” below the row above it, or at its parent's first slot when nothing sits above. That only works while the clipboard still holds what you copied; once it has moved on, a paste types ordinary text.

Launch agent on a group opens a small launch popup β€” the task count, a repo picker (pre-set to the project's "Run agents in" code project when every selected task shares one, otherwise the hidden Tasks workspace or one of your real repos) and an explicit Launch button (the cost gate a batch launch previously lacked; Ctrl/Cmd+Enter also launches). It starts one session seeded with all the selected tasks as context (never one per task); each task's id and saved notes and files ride along in the hidden half so the agent can file subtasks and notes under the right task, capped at 25 (over 25 the popup says so and Launch stays disabled). From the CLI, POST /tasks-v2/launch-agent-batch holds the same 25-id cap (MAX_BATCH_LAUNCH_TASKS, more is a 400) and takes an optional projectId. If a selected task was deleted or archived meanwhile, the launch is refused and names the missing tasks.

Repeating tasks β€” "every monday"

A task can repeat on any of the schedules below β€” daily through yearly, on one or several weekdays, on an interval, or on a weekday of the month β€” optionally until an end date, and optionally counted from when you finish rather than from the due date. Every N weeks counts from your Calendar week-start day setting (Monday by default, or Sunday) β€” the week the This week filter and the DUE <WEEKDAY> label use β€” so a rule including Sunday groups it with the Monday before it. Set it two ways:

  • Type it β€” the new-task boxes and the : command line understand these phrases (capitals don't matter):
You type It repeats
daily Β· every day every day
weekdays Β· every weekday Monday to Friday
weekly Β· every week weekly, on the due date's weekday
every monday Β· mondays weekly on that day
every monday and thursday Β· every monday, wednesday and friday weekly on each day named (full day names)
every other tuesday every 2 weeks on that day
every 3 days (1–3650) every N days
every 2 weeks Β· biweekly Β· fortnightly every 14 days (every N weeks = N Γ— 7 days)
monthly Β· every month monthly, on the due date's day
every 2 months (1–99) Β· every other month Β· quarterly every N months (quarterly = every 3)
every first monday Β· the last friday of the month Β· on the second tuesday of each month monthly on that weekday (first, second, third, fourth or last)
yearly Β· annually Β· every year yearly

Two optional add-ons can follow the repeat, in this order: after I finish (also after finishing, after finishing it, after completing it, after completion, after it's done) counts the next one from the day you finish, and until <date> (until dec 31, until march 3, 2027, until 12/31) stops the series after that day β€” e.g. "water plants every 3 days after I finish until dec 31".

  • Pick it β€” the details pane's Repeat picker offers None, Daily, Every weekday, Weekly, Monthly, Yearly, Every N days and Custom…. Custom edits Every N days / weeks / months; for weeks, toggle the days of the week; for months, On the same date or the first / second / third / fourth / last + a weekday; Ends (a date, or empty to keep repeating); and Next one is counted from β€” Due date or When I finish. Every change saves at once; anything the plain picker can't show opens as Custom….

A repeat needs a due date, so a task with none gets the end of tomorrow β€” the last moment of that day (23:59:59.999 local), the same end-of-day instant every date-only due uses β€” as its first due. A bare "weekly" repeats on the weekday of the task's due date β€” the date you typed, the existing due, or that tomorrow default β€” as the Repeat picker does. Moving the due date anywhere keeps a one-day weekly repeat on the new weekday (Monday β†’ Wednesday repeats on Wednesdays) β€” the details pane, the row's due picker, the "Looks due" suggestion, the command box, dragging a row in a due-sorted list, and a bulk due picker all move it the same way; a rule with several days, a chosen day, or a non-weekly rule is left alone; a task whose due date you cleared and set again repeats on the new one. Snooze moves only this occurrence, never the schedule.

A repeating task shows a πŸ” marker on its row; hover it for the schedule (e.g. "Weekly on Mon, until Dec 31, 2026"). Finishing it creates the next occurrence in place β€” same text, project, priority, tags, estimate, energy and context, with the due date advanced. Its checklist comes back: sub-tasks return unticked under the new occurrence (their dates cleared), and the task's notes, links and other context come with it; a sub-task snoozed into the future is left out (with anything under it). Attached files are not copied, and a task with more than 500 rows under it repeats without its sub-tasks. The finish toast tells you when the next one is due, and its Undo removes the new copy and restores the finished one in one step. A repeating meeting you only dismissed still gets its next occurrence: about an hour after it starts, a background check (every 10 minutes) creates the next one and files the past one in Archived without marking it done; restore it to check it off.

Un-checking a finished repeating task (or restoring it from Archived as open) removes the next copy, so you never have the same repeat twice; finishing again creates the next one. If you already did anything to that next copy β€” edited, snoozed, checked it off, attached something, gave it a sub-task β€” it is kept as real work. Ctrl/Cmd+Z right after un-checking puts both back.

The next occurrence is normally worked out from the due date, so a repeating task needs one; a repeat counted from when you finish is the exception β€” it counts from the finish moment (keeping the due's clock time) and works with no due date. With an end date, finishing the last occurrence on or before it creates no next one. Clearing the due date but keeping an ordinary repeat means finishing creates no next copy, and the finish warns it won't repeat because it had no due date rather than ending the series silently; the same warning ("its next date couldn't be worked out") appears when the due can't produce a next one, and "its repeat settings couldn't be read" when the saved rule is damaged or in an old format (undo never erases settings it could not read). Ctrl/Cmd+Z brings the task back so you can add a due date and finish it again. This holds for every way of finishing β€” Finish/Archive and ticking the checkbox (list, Today, outliner, command input). The finish result carries the reason as recurrenceStopped (no-due / no-next-occurrence / invalid-rule) on both tasks-v2:archive and tasks-v2:complete.

Deleting or archiving a repeating task asks first, like Google Calendar. Press Delete (or Ctrl/Cmd+Delete, Cmd+Backspace on a Mac, Ctrl+Shift+Backspace on a selection), Drop (the row button, the β‹― or right-click menu, the bulk bar, Shift+X, or the Today put-off row), middle-click the row, or Drop task on a Tasks reminder or trickle card, and a repeating task asks "Archive a repeating task?": Just this one files this copy away (not finished) and the next one still comes, with a toast like "Archived. Next one Wed, Nov 4"; Stop repeating files it away and no more copies come; Cancel does nothing. A one-off task, or one already checked off, never asks. Undo (the toast, Ctrl/Cmd+Z, or Restore from Archived) brings it back and removes the next copy if untouched. 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. Finishing never asks, and agents and the command line never see the question: their archive call takes keepRepeating (default false, which stops the repeat).

The menu's Delete row asks the same question in Delete words. Delete in a task's β‹― or right-click menu (right after Drop) deletes the task into Recently deleted instead of filing it into Archived. On a repeating task it first asks "Delete a repeating task?": Just this one deletes this copy and the next one still comes, Stop repeating deletes it and no more come, Cancel deletes nothing. Undo (the toast or Ctrl/Cmd+Z) removes an untouched next copy and brings the deleted one back. Restoring it later from Recently deleted brings back only the deleted copy; the next copy stays. The delete call (IPC.TASKS_V2_DELETE, POST /tasks-v2/delete) takes the same optional keepRepeating boolean (left out, the series stops, as before).

A repeating step inside a task you finish. If a task you are finishing has a repeating sub-step, Tasks asks first: Keep repeating moves that step out next to the finished task so it keeps coming back, Stop repeating finishes it along with the task, Cancel finishes nothing.

The date math is built for real life: finishing late never creates a backlog (a "daily" finished after a long weekend spawns one task due tomorrow, not three overdue ones), monthly repeats clamp to month-end without losing your day (Jan 31 β†’ Feb 28 β†’ Mar 31), and daylight-saving transitions keep the task's local time β€” a repeat falling in the skipped hour moves to 3:30 AM for that one day only, with the original time kept in its rule (anchorMinutes) and restored the next day unless you moved the task. A "first / last weekday of the month" repeat always lands on that weekday, and "every 2 weeks on Tue" counts weeks from the current due date; repeats saved before these options existed keep producing the same dates. Agents can set a schedule through the task's metadata over the CLI (metadata.recurrence: kind and anchor β€” "due", or "completion" for "after I finish" β€” plus, where it applies, weekdays, n, interval (1–99) for every N weeks or months, nthWeekday: { n: 1–4 or -1, weekday: 0–6 }, and until as an ISO date-time); a schedule added to a task with no due date also fills the default first due. The tasks-v2.md mirror shows it as repeat=… (e.g. weekly:2,4;every=2) so a reading agent sees the schedule.

One project at a time

Tasks works like the rest of Omniscio: pick something in the sidebar and only that opens in the main panel. Click a project and you see its tasks; click Today, Caught or Archived and you see that. There is no "All Projects" row in the sidebar or header Show menu unless the all-projects scroll is on.

  • Tasks opens where you left off β€” the view you had open last (a project, Today or Caught). If that project was deleted, or you last had the all-projects scroll open and have since turned it off, it opens Inbox (or the first project when there is no Inbox).
  • Want the one-long-list view? Turn on "Show all projects in one scroll" in Customize (or Settings β†’ Tasks Β· Caught β†’ Tasks display). It takes effect at once; turn it off and you return to the project you last had open. It is an ordinary setting (tasksV2AllProjectsView, off by default), so the command line can flip it too.
  • Pinned columns (below) work in both layouts.

The giant all-projects view β€” all your tasks in one list

With "Show all projects in one scroll" on, the view you land on is one giant list (unless a link such as Mission Control's "open Today" already switched Tasks to Today or Caught; reopening from a single project paints every project from the last full load right away). It folds every project's tasks into one screen, grouped under each project's heading in rail order. Each heading shows the project's icon β€” or its color dot when no icon is set and a color is chosen (no color β‡’ nothing) β€” and its open count as part of the title (parenthesised, same size as the project name β€” e.g. Business (6); under an importance/tag filter that hides rows it reads an honest "n of m", e.g. 0 of 6), plus a "+" to add a task and a β‹― to customize it (rename / color / icon / delete), the same menu the rail uses. It is the default; the per-project view is reached by filtering (header Show β–Ύ or the rail).

  • Projects are collapsible. Each heading is a chevron toggle; what's folded is remembered (a tasksV2CollapsedProjectIds setting) and is purely a view preference.
  • Fully editable in place. A single click/tap HIGHLIGHTS a row (it does not open the details editor); the details pane opens from the focused row's Task-details button (double-click renames). The focused row carries the full action cluster β€” Task details, Launch agent, and the β‹― menu (Add subtask, Copy, Context, Break it down, Move to project, Move up / Move down scoped to that project; keyboard Alt+Shift+↑/↓ does the same but also hops the task into the neighboring project at a project's edge). Check off, rename, edit details (due, snooze, importance, tags) and add a task (each heading's "+") without leaving the view; every edit lands on the task's real project.
  • Make a new project without leaving this view. A "+ New project" box is pinned at the bottom; click it, type a name, press Enter, and the project is created right here (Escape or a blank name cancels). Unlike the rail's "New project" (which switches you INTO it β€” see Projects & master context), this keeps you on the All Projects view and drops your cursor into a first task, so a new project shows up right away even from the empty first-run screen. Invariant master-new-project (TaskV2MasterView.test.tsx).
  • Fully keyboard-driven. The giant view shares the same command-mode keyboard as the per-project outliner β€” one implementation (useTaskV2CommandKeys). Arrows / w-s / j-k move the highlight across project groups (skipping collapsed ones); Alt+Shift+↑/↓ moves the focused task up/down and at a project's edge carries it into the neighboring project; Space edits, Enter adds a task below, Esc stops; every command key acts on the focused row (h snooze Β· d deadline Β· x/e finish Β· p priority Β· c/i context Β· : command line Β· g agent Β· b break-it-down Β· ? cheat-sheet Β· Ctrl/Cmd+D duplicate Β· Ctrl/Cmd+Delete archive). Tab/Shift+Tab indent/outdent within the row's own project β€” you can build a full outline while entering tasks; indent nests under the task above in the same project (never across projects) and works while you're still typing. Only Backspace-merge and drill-in/out are no-ops here (no cross-project merge target, no breadcrumb); filter to one project for those.
  • Select the project NAME itself, and act on the whole project β€” up/down nav also stops on each project header (even a collapsed one), and the keys then fan out to every task in it. See Select a project & act on the whole thing.
  • A task can't be left blank. Clear its text and click away and it's removed (when it has no sub-items), without asking, with its notes, links and attached files; Ctrl/Cmd+Z brings it back before you restart. A parent with sub-items is kept so its subtree survives. A blank row left another way β€” an abandoned new row, or a blank parent whose last sub-item went β€” is swept up once the list settles (the row you're typing in is never swept); until then it shows a muted "Empty task" placeholder you can click and remove by hand (Ctrl/Cmd+Delete / β‹― β†’ Finish).
  • Drag a task anywhere β€” including into another project. Grab a row (with a mouse, press and move, no hold needed; on touch or with a pen, press and hold first), then drop it above/below any task (same project = reorder; another = the task moves there, sub-items riding along) or onto a project's heading to file it at the top (empty headings work), or onto a project in the left rail to file it at the bottom of that project. Drop it onto the middle of another task to nest it as its last sub-task, sub-items riding along; nesting under a task in another project moves it into that project (with the same "moved to" note). Drop-to-nest also works in a single-project list, where a folded target unfolds. A nest is refused β€” the row doesn't light up β€” for a task dropped into itself or its own sub-tasks, or onto a target already at the 15-level nesting limit. One drop = one move = one Ctrl/Cmd+Z. (Dragging pauses while a search/sort/filter overlay is active; in a single-project list, nesting is off while sorted by a field.)
  • Reordering inside a project only looks at that project. Every project keeps its own order, so a drag, an Alt+Shift+↑/↓ move, a multi-row move or a Shift+Tab positions the task against its neighbors in the same project, never against a row in another project that shares its place. A row not on screen right now β€” a task in a Snoozed or Waiting section, still highlightable and skipped by the move keys' neighbor search β€” is not moved at all by Alt+Shift+↑/↓ and never hops projects; wake or unsnooze it first.
  • Empty projects show their (collapsible) heading too, so you can move a task INTO one: cut a task and press Ctrl/Cmd+V on its heading, or click its heading (the mouse / phone way β€” see Cut & paste a task), or drag a task onto it. A task with no known project appears under Inbox (or an (Unfiled) heading). (When every project is empty β€” a brand-new install β€” the friendly "Add your first task…" box files into Inbox instead.)
  • Move a task between projects with the keyboard. Cut/paste (Ctrl/Cmd+X then Ctrl/Cmd+V): cut a task, move the cursor onto another project β€” even an empty one's heading β€” and paste (a cross-project move; within-project reordering stays Alt+Shift+↑/↓ or the filtered outliner). Or press V on a task to open a "move to project" picker. Both are rebindable (Settings β†’ Keyboard Shortcuts β†’ Tasks) and on the β‹― / right-click menu for mouse + mobile.

The view renders virtualized (only on-screen rows are drawn), so it stays smooth with thousands of tasks; some bookkeeping still grows with the list, so a heads-up banner appears at 1,000 tasks across all projects and a stronger warning at 5,000, past the supported scale (archiving finished tasks brings it down). Sort & filter work here too (the header funnel applies within each project group). Cross-project drag is built, and the view adds no new database tables, server routes or storage β€” only view-state settings (the collapse lists).

Pinned columns

  • Pin projects as columns to work on several at once. The first column is always the Live column, showing whatever you click in the sidebar; every other column is Pinned to one project and stays put. Pin a project three ways: drag it from the sidebar onto the main panel; its options menu (β‹― or right-click) β†’ Pin as column; or focus it in the sidebar and press Shift+Enter.
  • Up to 3 pinned columns (4 in all); a fourth pin shows a short "unpin one first" message. A pinned project shows a πŸ“Œ in the sidebar; clicking it there flashes its column instead of opening a second copy in the Live column.
  • Each pinned column is the full editable list for that project β€” add, finish, indent, reorder, right-click menus and details all work, and every edit lands on the right project. Sort, filter and find in the top bar apply to every column.
  • Unpin with the column's Unpin button or the project menu's Unpin column; removing the last pin leaves only the Live column. A pinned column shows just its project: no Today band and no "New project" box. Pins are remembered across restarts (tasksV2PinnedProjectIds); a deleted project's pin quietly disappears.
  • On a phone only the Live column shows; your pins come back on desktop.
  • Not yet: dragging a task from one column into another (use Move to project) and reordering pinned columns (unpin and pin again).

Select a project & act on the whole thing

In the giant view the up/down nav also stops on each project NAME (header), even a collapsed one, and a selected project gets the same accent highlight a focused task does and scrolls into view. This is the giant view only; in a single-project view the name lives in the top bar, and the rail opens its menu via right-click / long-press / Shift+F10.

With a project selected, the command keys fan out to the WHOLE project. They reuse the exact keys (and your custom rebindings) you use on a task β€” only the target is now every task in the project:

Key What it does to the whole project
x / e Finish all β€” done + archived (a one-click "Undo" toast; reversible)
h Snooze all β€” pick one time, every task is snoozed to it
d Set deadline on all β€” pick one date
p Set priority on all β€” pick one level
Ctrl/Cmd+Delete Delete all the project's tasks β€” asks for confirmation first
Space Fold / unfold the project
Enter (also right-click / Shift+F10 / a touch long-press) open the project actions menu
w/s Β· j/k Β· arrows keep moving the cursor (now across headers + tasks)

Task-only keys (launch agent g, break-it-down b, context c/i, reorder, indent, duplicate, the : command line) do nothing on a project header.

A selection wins over the header for the two destructive keys. With tasks selected and the cursor on a project header, x/e finishes the selected tasks and Ctrl/Cmd+Delete archives the selected tasks, not every task in the project; with nothing selected they fan out as above. Snooze, deadline and priority still open their whole-project picker.

Every bulk action is a single Undo. Finish/snooze/deadline/priority/delete/move/emphasis on a whole project is one Ctrl/Cmd+Z, and a bulk action that can't fully apply rolls back cleanly with a plain-English error. Delete all always confirms; Finish all confirms too unless Finish without asking (tasksV2SkipFinishConfirm) is on, which skips that prompt and leans on the Undo (the same 2,000-row undo-cap limit applies); Delete all is never skippable. Finish, delete and move empty the project, so the cursor jumps to the next project. The whole-project keys read the tasks from the data, so they cover a collapsed project's hidden tasks too.

The project actions menu (Enter / right-click / Shift+F10, or a touch long-press) gathers it all: Add task; Launch agent… (one agent for the whole project with all its tasks as context, via the same session-type picker a task launch gives β€” see Per-task agent chat); fold/unfold; Star all / Bold all / Highlight all (+ clear) and Copy all (the tasks as an indented markdown list); Finish all Β· Snooze all Β· Set deadline… Β· Set priority… Β· Move all to project… Β· Delete all; Move project up / down; Rename, color & icon…; and Delete project… (removes the WHOLE project and its tasks through the same confirm; disabled on your last project, available even on an empty one). Star / Bold read the project's current state (all-set β‡’ "Unstar all"). Complete all N counts open tasks; Delete all N counts every task. Delete project… differs from Delete all, which empties a project but keeps it β€” both undoable; deleting the project soft-deletes it and cascades its tasks, and undo restores the project and those tasks. The emphasis + copy + reorder rows are menu-only (no header shortcut; g/b stay task-only); Launch agent, Snooze all and Set priority also appear as inline header icons (Snooze/Priority reuse the h/p keys, so their tooltip shows the key-cap; Launch has no whole-project key by design). The synthetic (Unfiled) group hides rows needing a real project (Add task, Launch agent, Move project up/down, Rename, Delete project); "Move all to project…" hides with only one project, Move project up/down disable at the ends, and Snooze/Priority disable on an empty project.

Send top tasks to the inbox

The header's β‹― More β†’ Send to inbox drops your few highest-value open tasks into the Omniscio inbox as dismissible reminder rows. It's on demand (a manual click β€” no background service, schedule or setting), free (the same local ranking that powers "Right now" β€” no AI, no tokens), and re-sending coalesces by task (one row per task); completing or snoozing a task drops it from the next send. Snoozing one of these rows snoozes the task itself until the time you pick and clears the row, the same as snoozing a Tasks reminder. A row for a task you later finish, archive or delete is cleared by the background reminder sweep (reconcileTasksV2ReminderAlerts); a task owned by another signed-in account is left alone. While the task stays open the same sweep rewrites the row from the live task, so a rename, a new project, a new due date or the day rolling over ("due this week" becomes "due today") shows on the row already in the inbox. Each row names the task's project and a due hint: overdue, due today (only when it's due on today's date on your own clock, so a task due tomorrow morning never reads "due today"), or due this week. A manual send is a re-ask, not a re-nag: a task whose card you already put away today still goes out, and the toast counts rows that actually appeared, never the ones you tried to send. Handled by tasks-v2:drip-now (gated) reusing the shared inbox-alert primitive, so it adds no storage; rows appear in the Inbox's own Tasks section, not the shared Alerts pile. These rows belong to whoever sent them: when the signed-in account changes or signs out, the identity-scoped reset in src/main/services/tasks/tasks-v2-drip-release.ts clears every active one, so the next account never sees the previous account's task titles (send again to bring them back).

Trickle tasks into the inbox (on a schedule)

"Trickle to inbox…" is the recurring version of "Send top tasks to the inbox": it feeds a project's tasks (or a hand-picked set) into your inbox a few at a time, on a cadence you choose. Pick it from a project's actions menu (its open tasks) or a multi-selected set, and a small box asks for a name, a cadence (the same plain-English picker as Drip β€” "every weekday at 9am"), how many to send each time, an optional repeat forever, and "Archive each task once it's sent to my inbox." Confirm and a few tasks start arriving on that schedule. Confirming the same trickle again within ten minutes (same name, cadence and tasks, as a double-click does) adds nothing and says it is already set up; a different task set under the same name and cadence is a new trickle.

Under the hood this is Drip β€” it creates a real drip pre-loaded with your tasks, so pause/resume, snooze, repeat-forever and the Drip management view all work on it, and you can tweak it in Drip later. Because Drip delivers, Trickle needs Drip turned on (the Enable Drip switch in Settings β†’ Features, off by default): while Drip is off both Trickle rows in the project menu are grayed out with a tooltip saying so, and a create request from the app or the CLI is refused (the CLI answers 403 with disabled: true). It's free (the same local ranking, no AI). A task you finish (or delete) before its turn never shows up β€” it quietly drains. With archive-on-release on, a task is archived (reversible, via the Archived tab) the moment it's sent β€” off by default and hidden for a repeat-forever trickle (archiving would end the reminder). Big projects are capped (the top ~100 tasks) and you're told if anything was left out. It snapshots the tasks as they are when you set it up; add more later and you re-trickle (or use repeat-forever). Handled by tasks-v2:trickle-create (gated).

"Archive each task once it's sent" files the task away; it does not finish it. The task moves to Archived without being marked done, so it does not count toward what you finished today and sends no "completed" notice. Restore it from Archived any time.

Trickles pause while Tasks is hidden. If you hide Tasks, a trickle stops sending and its Drip page shows Paused while Tasks is hidden; it picks up on its next scheduled time once Tasks is back. To keep trickles sending while Tasks is hidden, turn on Keep trickles running while Tasks is hidden in Settings (off by default).

Each card a trickle delivers keeps its way back to the task: with Tasks on, it shows Open in Tasks (jumps to the task, selected) and Drop task (drops the task itself, then clears the card), the same two actions a Tasks reminder card has. A trickle set to archive each task on release shows neither, because the task is already archived by the time the card arrives. Snoozing a trickle card snoozes its task until the time you pick and clears the card, like a Tasks reminder, and Undo puts both back. On a trickle that archives each task, snoozing only hides the card.

Export every task as a JSON file

The header's β‹― More β†’ Export JSON writes an inspectable folder β€” one pretty-printed JSON file per task plus an _index.json manifest β€” into a folder for your signed-in account (tasks-v2/<account>/tasks-v2-export/ inside the app's data folder), then opens it. An older tasks-v2-export/ folder directly in the data folder is a pre-per-account leftover, removed at startup; deleting your account removes the whole folder with the rest of the Tasks data.

Each file carries every field the task has (text, done, due/snooze, importance/urgency, tags, estimate, waiting-on, plate and event details, archivedAt) plus its list's name, with a filename from the task's first line; only notification bookkeeping (the *NotifiedAt stamps) is left out. Archived and dropped tasks are exported too, so each _index.json entry carries archived: true or false and an archived task never reads as open. Characters Windows does not allow in a filename (: * ? " < > |) become _, so "Ask Sam about Q3?" exports as Ask Sam about Q3_.json on every computer instead of failing the whole export. A slash or a run of dots in the title becomes _ too, so "Pay rent 1/2" exports as Pay rent 1_2.json and "Wait... then call Bob" as Wait_ then call Bob.json, instead of the file name keeping only the words after the slash or falling back to task.json. The title itself is untouched inside the file and in _index.json.

It's on demand (a manual click, desktop app only β€” the row is hidden on mobile and in a web browser, where the phone bridge blocks the export channel), read-only (it reads the database and writes the folder; it reads a file back only to check that this feature wrote it, never to bring a change into the app, so editing a file changes nothing), and rebuilt from scratch every time: the new copy is built in a sibling folder and swapped in with a single rename, so every task file is rewritten at once and files for tasks that no longer exist are gone, always matching your current tasks. The swap replaces every .json in the folder β€” treat this folder as the export's output, not as a place to keep your own JSON files; only non-.json files you keep there are carried across into the new copy. Each export also writes a one-file copy of every task (_tasks-<date>.json) and a short README beside it. That one file is what Import can take back, within what Import accepts β€” 5,000 tasks or a 10 MB file. Read the mapping screen rather than trusting the suggestion: the export writes its own column names (dueAt, startAt, estimatedMinutes, completedAt, listName), and Import recognizes those spellings, so the suggested mapping restores the text, the notes, the done state, the priority, the tags, the due date, the project and the completion time. Start dates and estimates have no import column at all. Past the limits, the README says to keep the folder as your record instead, because that one file is larger than Import will take. An export that finds no tasks changes nothing at all β€” it writes no staging folder and does no swap, so the previous export is left exactly as it was, that one-file copy and README included. That matters when you are recovering from a bad state: pressing Export never wipes the copy the folder already holds. The folder itself is never deleted, so having it open in File Explorer (or a terminal inside it) never makes the export fail.

A task permanently deleted past the 30-day window is dropped from the folder by the daily retention sweep: _index.json is rewritten without it first, then its file is removed β€” every one attempted even when an earlier unlink fails β€” and the folder is re-read to confirm nothing still names a removed task (pruneTasksV2ExportForPurged). Handled by tasks-v2:export-json (gated); it adds no database tables. Two-way file sync β€” edit a JSON file by hand and have the change flow back into the app β€” is the deferred someday-luxury, not this.

The overview, the other parts, and everything else worth reading next all sit on Tasks (markdown outliner, in development).

Last verified 2026-11-03