Tasks (markdown outliner, in development) (part 6)
A dedicated Today surface holds the day's true priorities across every project. It is a non-destructive overlay: a task on Today keeps its home project and listid — Today just flags it (dailyplatedate = the local day). Nothing is moved or copied; at day's end a task simply drops off Today and is still sitting in its project.
On this page
What it is
This is part 6 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 where the feature lives in the product. Everything below is reached from there.
How it behaves
Everything below is the behaviour, detail and edge cases for this stretch of the page.
Today — your daily plate (a flat, editable list)
A dedicated Today surface holds the day's true priorities across every project. It is a non-destructive overlay: a task on Today keeps its home project and list_id — Today just flags it (daily_plate_date = the local day). Nothing is moved or copied; at day's end a task simply drops off Today and is still sitting in its project.
It behaves like any other project — fully editable. Today renders your plate as one flat, editable list using the SAME rows the "All Projects" view uses: edit a task inline, open its Task details (due / priority / context), launch an agent on it, use the ⋯ menu, check it off — all right here, without bouncing to the project. Editing a task on Today edits the real task in its home project (the same row shown in two places). Done tasks collect in a Done section below. (Deadlines show as the normal due chip on each row, and snoozed tasks stay hidden until they wake.)
Where it lives. A Today tab (calendar icon) sits directly below "All Projects" at the top of the projects rail — a project-style row rendered above your projects (and above New project / Archived) — AND a Today section is pinned at the top of the "All Projects" combined view, styled as a project section (calendar glyph + bold heading), staying fixed above your project groups as they scroll (a long day's plate scrolls inside its own capped height, so it never swallows the screen). That Today section is always shown — when nothing is on today's plate it reads a quiet "Nothing scheduled for today yet" in place of the list, followed by the "Plan my day with AI" session button described below, so an empty Today in the combined view can kick off planning in one click. "Today" is always the first thing at the top of the combined view, while the rail keeps a Today tab right under "All Projects". Today is mutually exclusive with All Projects and any single-project selection.
Plan my day with AI (the prominent button). The Today tab's header button, the empty-day Plan my day card and the Plan my day in a session button in the All Projects view's Today band all start the same planning session described below, then switch the Tasks panel to its Sessions tab with that chat open. (They once opened the single-call Plan my day review panel; no button opens it now.) When the Today tab itself is empty it shows a grid of action cards instead of a bare message — Plan my day, Catch me up (with a count of caught items), an adaptive Suggest card (a next-best-task pick for power users that can use one small AI call — 3+ completed AI-coaching interviews, or the whole curriculum finished; for everyone else a card that starts or continues your AI coaching) and Brain dump — so an empty day teaches by doing in one click. Two of them are conditional here: Plan my day appears only once you have at least one task, and the Suggest card is left off the empty grid for a brand-new user, whose empty day shows only Catch me up and Brain dump. Its add box invites a brand-new user to Add your first task…; once you have any task at all, in any project, it reads Add a task instead (BUG-B027). Once everything on today's plate is done, a two-card version (Suggest and Brain dump) shows above the finished list, and there the Suggest card is shown to a brand-new user too, reading as a start-your-AI-coaching card. If a Brain dump session is already starting, the card says so; a launch that fails shows only its error. If the Suggest card cannot load the next-best pick, it shows that error and stays where it is rather than jumping to an old pick. Each of these buttons launches a real session on your selected AI model (a full agent, not the cheap prioritizer) steered by a Daily Focus Planner prompt and handed today's plate, your whole open board, and your strategic context — so it starts already knowing what's on your plate and reasons from it (leading with a point of view) instead of asking you to list everything from scratch. It talks through your day and — once you approve — captures what to focus on.
- It plans the day the screen shows — and the screen shows the computer's day. Every projects read reports the Omniscio computer's own plate day, the renderer keeps it (falling back to the viewing device's clock only until that first read lands), and the Today list, Re-arrange, roll-to-tomorrow and bring-leftovers all use it. So a phone or browser sitting in another time zone still acts on the desktop's day, which is the only day the server's plate, day log and evening close-out use. A device that crosses local midnight asks the computer for its day again.
- It's a paid session (real tokens per turn) — it launches straight from the labelled button (no confirm pop-up). An agent can also request it over the control server; that always waits for your approval in the Inbox, whatever Require approval: Tasks AI & agent runs is set to, because it starts a paid session.
- Your open board = every open task across all your projects that isn't already on today's plate, grouped by project and bounded — so the agent starts oriented over what's really open and never has to go fetch it.
- One "Context loaded for Planning AI" divider shows the loaded planning context (today's plate + your open board + your projects) at the top of the chat, collapsed, so you can see exactly what it started with. The app's login token still reaches the agent but is never shown in that divider.
- Strategic context = your AI Coaching "About you" profile (your goals, standing priorities, how you like to work). It's folded into the session to steer the AI, addressed to you in the second person, and kept out of the loaded-context divider and the session title. The agent is asked not to quote it back, but Omniscio does not filter its replies or the tasks it saves — so check the tasks it adds before you keep them, because anything from your profile that lands in a task's text travels with that task, including to the other AI services Tasks uses. It appears only when AI Coaching is enabled and the session it is about to start runs on first-party Anthropic — the recorded consent for that profile names first-party Anthropic as its destination, so on any other engine (DeepSeek / Kimi / GLM / OpenRouter / a proxy-backed vendor) the block is dropped. Without it, the session still works from your plate + board alone.
How tasks get onto Today.
- Add a task straight to Today (you pick which project it belongs to). The "+" at the start of the Today add box is a real button: with text in the box it saves it exactly as Enter does, and with an empty box it puts the cursor in the box.
- A task with a clock time today is on Today by itself. A task due at a time today (say "send the contract 4pm", added from any project) shows in Today's list without anyone planning it; one timed for tomorrow does not, and a due date with no clock time still needs planning. When Today is sorted by due date, those tasks sit in time order; the manual order is unchanged. Rolling unfinished tasks to tomorrow moves only the tasks planned for today, so a timed task stays on the day it is due. Meetings are unchanged: a clock time typed into the Today box still makes a meeting, which shows in Today's meetings at the top and keeps its own alarm, and never joins the list.
- Create one inline, from a row you're already on — Add subtask (⋯ menu / right-click), Enter for a new task below, Shift+Enter for one above. Anything created this way lands on today's plate as a user pin, so it stays put through a re-arrange. Because Today is a flat list it appears as its own row rather than indented under its parent — it is still a real sub-task back in its home project.
- Only open tasks that are not meetings can join a plate, whichever way they get there (the app, an agent, or the CLI). Putting a finished task or a meeting on a day answers "Only open tasks that are not meetings can be planned for a day." A finished task already on today's plate stays there.
- From the Move-to-project menu — on any existing task (its ⋯ menu, right-click, or the
Vkey) pick Add to Today to put it on the plate, or Remove from Today to take it off. It's the same menu you use to file a task under a project, so moving things on and off Today works "just like any other project"; being an overlay it keeps the task's home project, and a hand-added task is a user pin (plate_source = 'user') that a re-arrange never disturbs. - The "Plan my day with AI" session can add tasks to today's plate for you. It is told to wait for your OK first, but Omniscio does not block it, so check what it added.
- Or accept the daily check-in interview: the AI reviews what is due and slipping and proposes a focus; on accept, Today is arranged — the focus tasks + any due-soon deadlines are placed on the plate. The base arrange (
arrangeTodayPlate) is deterministic and free (no AI, no spend): the interview does the thinking; arranging just materializes its result plus your deadlines. A separate AI arrange pass (tasksV2ArrangeAiEnabled, default ON) runs a paid Claude call that composes an ordered plate with per-task rationale — no daily budget limits it, and it degrades to the free deterministic arrange on error. A one-tap Re-arrange (the sort-by-priority button) redoes it anytime; it shows a spinner while it works, then a short result line that is either "Today tidied: N tasks added, M removed." or, when nothing moved, "Nothing to change — today already matches your priorities." - Each placed task carries a provenance mark:
plate_source = 'ai'(arrange placed it) vs a user pin ('user'— you added it by hand). A re-arrange never touches a task you pinned yourself.
Today's meetings. Meetings due today sit in a strip at the top of Today, earliest first, each with its start time; past ones are dimmed. Click a meeting's name to change its heads-up (how many minutes ahead and how loud). The X (Remove meeting) only turns it back into an ordinary task, with no heads-up; the task stays in its project.
Reorder your day. Grab a task on Today and drag it to a new position: with a mouse, press and move (no hold needed); on a touch screen or with a pen, press and hold it first, so scrolling never grabs a task. Drop it on a project in the left rail instead to move it into that project. The new order writes plate_rank so it sticks after a reload, whether or not AI arrange set a rank. Done-section tasks can't be dragged. Keyboard reorder (Alt+Shift+Up/Down) still works alongside drag. Dragging and the ⋯ Move up/down rows are offered only while Sort: Manual is chosen with no filter (a drag under Importance, Due or Start sets that field instead, and under any other sort, or with a filter on, they are turned off rather than pretended — the same rule every other task list follows). The free Re-arrange button is not a reorder: it decides which tasks are on the plate, so it stays available under every sort.
Filtering your day. The Sort & filter bar above the plate narrows what you see. When a filter you picked hides every task on the plate, Today says "Nothing on today matches these filters" with a Clear filters button — it never shows the finished-day cards, because the day is not finished, just filtered. A task hidden by a filter also stays out of Roll unfinished → tomorrow (see below), so a narrowed view can never quietly carry unseen work to tomorrow.
The daily reset.
- Past items drop off Today on their own (still in their projects).
- Roll unfinished → tomorrow (with undo) carries the unfinished tasks you can see on Today forward to tomorrow's plate; done rows stay put, and every task the roll carries forward becomes one of your own picks, so re-arranging tomorrow or planning it with AI keeps them. Tasks hidden by a Today filter, or snoozed until later today, stay on today, so the count in the confirm box, the count in the banner and what Undo brings back always match. If Undo cannot move some tasks back, the Undo button stays for just those tasks and the error says how many are still on tomorrow, so pressing Undo again retries them.
- Forgot to roll? On a new day, if your last plate still has unfinished tasks, Today shows "N unfinished tasks from <day>" with Bring them to today and Leave them. Bring moves exactly those tasks onto today in one step and makes them your own picks, so a later Re-arrange or an accepted check-in never drops them; Leave hides the line for 4 hours, and a second Leave hides it for the rest of the day. Leave cannot be undone from the line. Leave also takes the listed tasks off their old day's plate, so in the ordinary case those tasks are never offered as leftovers again. Bring, or a second Leave, counts for the day, so an older plate never pops up after it. The line comes back on its own, with no restart needed. Meetings, archived tasks and tasks snoozed into the future are never offered. (
findPlateLeftoversinplate-leftovers.ts; the store'sbringLeftoversToTodaysends the existing roll-plate call with atoDateandasUserPin: true(which stampsplate_source = 'user'), which the IPC handler andPOST /tasks-v2/roll-plateboth accept.)
Learn about your habits. With Tasks memory on, a Learn about your habits button under the plate shows what Tasks has learned from your history: how many tasks you usually finish a day, how much of what you plan you complete, the task you have carried over longest and the one you snooze most, about how many meetings you have a day, task types you often re-classify, how often you keep Caught suggestions and accept check-in suggestions, and how many days it has tracked. Reading it is free. On a carried-over or most-snoozed task you can Open it, Break it down, Send to an agent (opens the agent launch popup; launching uses AI) or Drop it (files it away without marking it done; undoable).
A day that has already ended. A check-in is for one day, and once that day is over the app stops applying it: accepting it, or committing a plan you reviewed, answers 409 naming the day and changes nothing — no accept stamp, no tasks created, no plate arranged. Start a new one for today instead. Repeating a commit that already went through still returns the plan unchanged rather than failing. The same rule already stopped you opening or launching an agent for a passed day; this closes the approval half.
Projects & master context
A subtask always lives in its parent's list, so a list delete and restore reach every descendant: creating a task with a parentId stores the parent's list (the list the caller names only when the parent has none).
A new subtask takes its parent's list only while that list exists and is live (otherwise the list named on creation), and an undo that puts a subtask back under its parent files it in the parent's current list. A task that saved an importance or urgency value outside the normal range before the range check existed no longer blocks other edits to itself.
Every list mutation (create / update / delete / reorder) refreshes the mirror — the ## {list} headings, their order, and the master-context blockquotes all live in tasks-v2.md, and the mirror rewrites whenever a list or task change is announced.
Each project can carry a master context — a short note that rides with every task in it — edited from a pinned card above the list. If saving the card's text fails, the store keeps what you typed (unsavedMasterContextDraft, keyed by project id) rather than the editor — the blur that starts the save also closes the popover, so the editor is already gone when the failure lands. The error says the master context wasn't saved and that your text is kept, and opening Edit again for that project seeds the editor with your unsaved text instead of the old value (Escape discards it, a successful save clears it, and so does editing it back to the saved text and clicking away). Clicking away only writes when YOUR text differs from what the editor opened with: a shared note changed elsewhere while the editor was open — another window, the phone, or the Interview agent writing through the CLI — is never reverted by a stray blur (with nothing typed the newer value simply stays), and if you did type, the card asks whether to keep your version or use the newer one before anything is written. Every project edit (rename, colour, icon, default project, master context) is sent with the version of the project it was based on, so if the project changed since then in another window, on the phone or through an agent, the save is refused instead of writing over that change: the newer version stays, and a notice says your change wasn't saved so you can make it again. Quick edits to the same project are sent one after another, so they never refuse each other. The save itself carries the project's version captured when editing began, so a write that raced an edit the push channel had not delivered yet is refused by the backend instead of clobbering it — that refusal opens the same keep-or-use-newer dialog, and "Keep my version" writes unguarded. A refusal caused only by ANOTHER field (a rename, a new color) is retried against the fresh version rather than alarming, because it changes nothing of the other writer's notes.
The rail is a persistent FILTER, not just a switcher: an "All Projects" entry (the giant view — shown only while "Show all projects in one scroll" is on in Customize, and valid even with a single project) plus one entry per project that filters the view down to it. The rail supports:
Drag-to-reorder the projects (the whole tab is the drag surface; a plain tap still switches the filter).
Drop a task on a project row to move it there. While you drag a task from a project, All Projects or Today, the project row under the pointer lights up; drop and the task moves to the bottom of that project with its sub-tasks, exactly like Move to project (one
moveIntoProjectcall withposition: 'bottom', a Moved to {project} note with Undo, and one Ctrl/Cmd+Z). Dropping on the project the task is already in does nothing. Each row carriesdata-tasks-rail-project-dropfor the drag hook to find.Clean rows — icon + name + a right-aligned count, with two hover buttons. Hovering or focusing a project row reveals a "+" (tooltip Add task to {name},
data-ui-anchor="tasks-v2-rail-row-add-task") and the ⋯ options button; on mobile both are always shown. The "+" opens that project and puts the cursor in its "Add a task" box (for a project pinned as a column, the add box in that column), the same box the project's own add row and the header "+" use — see Per-project "+" add. Both buttons are markeddata-no-drag, so pressing them never starts a project drag. The count sits flush-right in one column and the name takes the remaining width. A project with no icon and no color also drops its blank leading slot (ProjectIcon collapseWhenEmpty), so its name starts flush-left and reclaims that width too; a project with an emoji/icon or a color still shows it, and the fixed All Projects / New project / Archived rows keep theirs.One lit entry at a time. The rail highlights only the view you are in — All Projects, Today, Caught, a project, or Archived. Opening Archived keeps your project selected underneath (closing Archived returns you to it), but only Archived is lit while it is open. Customize is the one exception: it is an inline overlay, so it lights beside the view it opened over.
Creating a project opens it and drops you into a first task. The fixed "New project" row reveals an inline name input with a check Create button beside it (Enter or the button submits, clicking away with a name typed also submits so the name is never silently lost, Escape cancels, an empty field just closes on click-away — wired to the store's
createList). The Move-to-project menu's New project… field behaves the same way, and the All Projects view's bottom New project field carries the same Create button but keeps the box open with the typed name on click-away (all three shareuseProjectNameDraft). On submit, the rail uses the new project's id to switch the view INTO it (setActiveList) and arm a one-shot signal (autoStartFirstTaskListId); the per-project outliner consumes it once and auto-opens a blank task in edit mode, so you start typing the first task immediately. Desktop only (an unprompted edit box would pop the mobile soft keyboard, the same reason focus-on-entry is desktop-only — mobile still opens the project, just without the auto task box). The signal self-clears on use and if you navigate away first, so it can't fire later on an unrelated empty list. Locked by the contract'screate-opens-projectinvariant (TaskV2ListRail.test.tsx+TaskV2Outliner.test.tsx). (The giant All Projects view also has its own bottom "New project" box — that one deliberately stays on the giant view instead of switching in; see The giant default view — all your tasks in one list.) You can also spin up a project from a task's Move-to-project menu — its "+ New project…" row creates the project and moves the task(s) straight into it, then opens it. If you have navigated somewhere else by the time the move finishes (opened another project, switched to Today or Caught, or left All Projects), you stay where you are and the new project is simply waiting in the rail. Every surface runs that one store action (moveToNewProjectAndOpen), so the outliner's New project… row now reports the move with the same Moved toast and Undo entry the master view shows, instead of moving silently.A per-project options menu (
TaskV2ListMenu.tsx) — rename, recolor (the sharedColorPicker), set an icon (theIconPicker— an emoji or a Lucide glyph; see Per-project color & icon), and delete (a dangerConfirmDialog; when the project has open tasks the dialog shows how many and offers a "Move tasks to Inbox, then delete" secondary action that re-files every task in the project into Inbox, finished and archived ones included, before the soft-delete cascade runs — so work is never silently lost; Delete is disabled when only one project remains, and the reason is shown as text under the row rather than only in a hover tooltip; the built-in Today and Caught tabs show no Delete row at all, since they can never be deleted; Ctrl/Cmd+Z undoes a deleted project). The rail row carries a visible ⋯ button that opens the menu directly (hover-revealed on desktop, always visible on mobile, where there is no hover) — and the same menu still opens by right-clicking (desktop), long-pressing (mobile), or Shift+F10 / Menu (keyboard) on the row. The button is markeddata-no-dragbecause the rail's rows are drag-reorderable and a press must open the menu rather than start a drag. The master-view project header keeps its ⋯ button for this same rename/color/icon/delete menu (the rail and the header ⋯ both drive one shareduseListOptionsMenuhook, so a project is customizable wherever its name appears — it owns the menu's open and close, its position, the delete confirm, and the edits; the menu anchors under a button, or opens at the cursor and is kept on screen. Whatever opened the menu is where focus returns when it closes; a right-click on a rail row passes that row's button, so after a delete removes the row focus falls back to the project list and Ctrl/Cmd+Z still reaches the Tasks undo); right-clicking the header now opens the broader project actions menu (which offers a direct Delete project… row, and reaches rename/color/icon via its "Rename, color & icon…" row), not this menu directly.A per-project open-task count badge that is accurate for every project, not just the active one — and now moves on the same frame as your add / complete / delete, instead of a round trip later. Every open-task number on the rail comes from ONE resolver: it answers each list's number and the unfiled tally in one call, so no surface recombines the sources itself (the rail and the master-view project menu both read it). It resolves that number from the two sources that each hold part of the truth: the rows the app has loaded win for the list (or lists) they cover, so an optimistic write shows immediately and its rollback restores it, while a list whose rows aren't loaded shows the backend's own count rather than flashing to zero. A read still in flight — or one that failed — never resolves a badge against a tree describing a different view.
A resizable width that respects the sidebar. The rail starts matched to your sessions-sidebar width — the slot it stands in for, since Tasks
panelOwnsLayoutsuppresses that sidebar — instead of a fixed column. Drag the handle on its right edge to resize it in place (double-click or Enter on the handle resets it to follow the sidebar again); your width persists to a dedicatedtasksV2RailWidthsetting (a separate key fromsessionsSidebarWidth, so resizing the rail never makes the real sidebar "jump"). It reuses the same freeze-hardened resize behavior as the sidebar.
On mobile the rail is not a side column. A side rail beside the content leaves a phone almost no room (the content column collapses to a one-word-per-line sliver), so on a phone the side rail is dropped entirely — the content column goes full-width — and moves the same project rail into a slide-up sheet. A header switcher button (showing the active list's name + a chevron) opens it; the sheet auto-closes when the active list / master view changes, so a tap-to-switch dismisses it. Check-in, Send to inbox, Export JSON and the Looks-big nudges toggle live in the header's More menu, and on a phone the header stays on one line instead of wrapping. Export JSON is not offered on mobile at all, because it writes and opens a folder on the desktop computer, which a phone cannot reach. Because the sheet is a transformed/overflow container, the project options menu portals to the page body so its fixed backdrop/box is positioned against the viewport (never clipped inside the sheet) — identical on desktop, where its coords already come from the trigger's getBoundingClientRect(). Desktop is unchanged.
Tasks can be moved between projects from the outliner: a focused row shows a "Move to project" trigger (TaskV2MoveToListMenu.tsx) that re-files the row and its whole subtree into the chosen project. (Moving to another project is its own explicit action — it is NOT a reorder.) The markdown mirror groups tasks under a ## {list name} heading (in sort_order) with the master context as a > blockquote beneath it; tasks with no known project fall under Inbox (or an ## (Unfiled) section) so none are lost.
Per-project color & icon
Each project carries an optional color (default: none) and an optional icon — an emoji or a curated Lucide glyph — chosen from the project's ⋯ options menu. Each icon grid is a single Tab stop (the selected swatch, or the first one when none is selected) and the arrow keys move between swatches, so a keyboard user no longer tabs through 70+ buttons. The icon appears wherever the project's name does — the rail row, every master-view header, the Move-to-project menu and the header Show menu — and falls back to a color dot when there is no icon or the saved icon is one this build does not know. Projects default to no color, so by default a project shows no dot: in the rail a no-icon, no-color project drops its leading slot entirely so its name reclaims the width, and master-view project headers do the same, while the fixed rail rows (All Projects, Today, Caught, New project, Customize, Archived) all keep one icon slot so their labels share a single left edge. A colored project shows its dot, and a bad icon value never crashes a render. A no-color Lucide icon tints neutral (inherits the row text color), never an accent. Icon is update-only (creating a project never sets one). The options menu that hosts both pickers opens from the master-view project header's ⋯ button and from a rail row via right-click / long-press, and is kept on screen.
The built-in views — Today and Caught — support the same context menu (right-click / Shift+F10) as regular projects: rename, recolor, set an icon. Because these are view-mode toggles (not DB-backed TaskV2List rows), their customizations persist to AppSettings (tasksV2TodayColor / tasksV2TodayIcon / tasksV2TodayName, and the Caught equivalents) instead of the tasks_v2_lists table. The menu reuses the same TaskV2ListMenu component with no Delete row (built-in views cannot be removed) and Move up/down omitted (their positions are fixed). Clearing the name and confirming restores the default (translated) name. When no customization is applied, the default Lucide icons (CalendarDays for Today, Sparkles for Caught) and the i18n-derived labels render unchanged.
Per-project "+" add
Each master-view project header carries a "+" (add task) button. Clicking it drops a new empty top-level task into that project and opens it for editing immediately (the top-level twin of "Add subtask"); a collapsed project is expanded first so the new row is visible. Each rail project row also carries a hover "+": it opens that project and focuses its "Add a task" row, so you can type the new task straight away (it opens the project rather than creating a blank row, so nothing is made until you type). With the old top "Add a task" box removed, this per-project "+" and the outliner's "Add a task" row are the primary ways to add a task.
Inline "Add a task" row at the bottom
Beneath the tasks there's an always-present blank entry row you can click and start typing into right away (Notion / Apple-Reminders style) — no "+" button, no separate box. It's there in both editable views: at the bottom of a single-project list, and at the bottom of each project's section in the giant default view (a collapsed project shows none). Type a line and press Enter and it becomes a real task in that project, and your cursor stays right in the add row — cleared and ready for the next one — so capturing many tasks is just type, Enter, type, Enter…. It does not re-open the task you just typed for editing (you already named it in the row) — that's the rapid-entry behavior, locked by the add-row-rapid-entry invariant in the contract. The "+" button still drops into editing because it starts a blank task; the empty-list first-task field does too only on a bare Enter (also blank) — but a first task you actually type in full now settles to the highlighted row border, the same rapid-entry as this add row (no longer re-opened in the green editing state). On a phone, a small tappable "Add" button appears at the end of the row once you've typed something — because a phone's on-screen keyboard can't be relied on to commit (autocorrect / predictive text can swallow its Enter), the button is the deterministic way to save; tap it and the task is created exactly as Enter does — same rapid-entry, the cursor stays in the add row for the next one. Desktop keeps Enter only — no button. Visually, the inline row shows a muted "+" marker sitting in the outline-number column — lined up with the task numbers (1. / 2.) above it, not off under the checkboxes — and hovering the row gives it a subtle button-like highlight (the "+" darkens with it), so it reads as a place to add rather than a separate click-to-add button. The checkbox spacer follows your Show checkboxes setting, so the "+" stays aligned whether checkboxes are on or off.
It only turns into a task once you've typed something and pressed Enter — so it never leaves empty junk tasks behind (Tasks deliberately deletes blank tasks, so a permanent real empty task would fight that; this row is just a typing slot until you commit it). As you type, it reads dates, priority, repeats, estimates and tags and shows each as a removable label under the row — "call vendor due friday #work" shows Due … and #work labels and saves a task named "Call vendor"; remove a label with its ✕ and that field is not saved (its words stay in the name). Nothing is applied that wasn't shown as a label, because Tasks never silently guesses a date (see New-task boxes read what you type). You can also dictate into it: spoken words like "high priority" or "tag work" become the same labels, and saying "next task" or starting a new sentence shows a numbered list of separate tasks that Enter saves in order (see Talk your tasks in). The row is its own keyboard context (a typed letter like "x" or "d" types into it, never firing a row shortcut), guards against a double-Enter creating two tasks, and won't submit mid-IME-composition. An empty project now shows its heading + this add row in the giant view (empty projects are no longer hidden — see The giant default view), so you can add the first task right there. One honest limit: the synthetic "(Unfiled)" group — where orphan tasks land when they've lost their project — has no add row, since there's no real project to file a new task into.
Empty list opens ready to type
When a list has no tasks, it doesn't make you press Enter first — it shows a focused "Add your first task…" field with the cursor already in it, so you type the first task immediately (Enter creates it and settles it to the normal highlighted-row border; it no longer stays in the green "editing" state). Your cursor then moves straight into the "Add a task" row of the project the task landed in — at the bottom of a single project, or under that project's section in "All Projects" — so you can keep typing the next task, Enter, the next, exactly like that row. This works on both surfaces: a single empty project (the per-project list you switch to) and the consolidated "All Projects" view when every project is empty (there the first task files into Inbox, never "Unfiled"). Same no-blank-task rule as the inline row — typing only creates on Enter — except a bare Enter still makes a blank editable row (the legacy affordance the keyboard's create-then-cancel flow relies on, so nothing about that flow regresses). Desktop auto-focuses on entry and on re-entry (switching back into a kept-warm panel); mobile shows the field but doesn't auto-focus, so it never pops the on-screen keyboard. Like the "Add a task" row, it shows labels for the dates, priority, repeats, estimates and tags it reads as you type or dictate, and saves only the labels still showing; several dictated tasks show as a numbered list and all save on Enter, in order, capitalized the same way as the list shows them.
The first task is the one thing a new user has produced, so nothing here is allowed to lose it. Three ways back, all added for the activation path:
- A failed create gives the text back. If the create round-trip fails (offline, a server reject, an IPC error), the composer restores what was typed and did not save (all of it, or the unsaved tail when one line split into several tasks), but only while the field is still empty, so a restore never clobbers a next task already started.
- Quitting mid-draft commits it. A brand-new row is a LOCAL DRAFT until it is committed, and React runs no cleanup on a hard teardown — so the Tasks store registers a
pagehide/beforeunloadflush that commits the pending drafts (through the samecommitAllPendingDraftsa view switch already calls). A blank row holding typed text reaches the database before the app dies. Every mounted row also registers its own debounced-text flush throughregisterTasksEditorTeardownFlush, and the teardown runs those editor flushes BEFORE the store's draft commit: keystrokes still inside the 300ms save window reach the store first, so the draft is created, or the edit saved, with the final text instead of a stale or blank one. - Text typed but not committed survives a remount. The composer mirrors its text into a session-scoped in-memory draft and re-seeds from it on mount, so an interrupted first session resumes with what was typed instead of an empty field. Each list keeps its own draft — a half-typed task follows the list it would be created in, never the next one you open, so Enter can't file it into a different list. The draft is also mirrored into the window's session storage, so a renderer reload keeps it; it is cleared when the signed-in account changes, and a full restart starts blank.
- Signing out mid-draft keeps it. When you sign out, Tasks first saves what you typed and had not saved yet — a new row you were still typing, text sitting in an "Add a task" row or the first-task field without Enter, and any save already on its way — into your account, and only then signs you out. Sign back in with the same account and it is there; anyone else who signs in on that computer never sees it. Composer text is read the same way pressing Enter would read it, into the project that box files into (at the project's top level). Two honest limits: if the save itself fails at that moment (for example you are offline), the text you typed is kept on this computer for your account only, for up to 7 days, and comes back in the box when you sign in again with the same account — nobody else who signs in on that computer can see it; and sign-out never waits more than ten seconds in all — up to five for the save, then up to five more for a save already on its way. From the moment that first wait ends until you are signed out, Tasks sends nothing new; if you typed several tasks in one go and the save is still going when the time runs out, the tasks not yet saved are not created at all, so none of them can end up anywhere but your account. The rule is
sign-out-saves-the-owners-unsaved-work-firstin the global sign-in contract; the Tasks side isstore/tasks-sign-out-flush.ts.
A few plain words above the field say what Tasks is and the one thing to try, for someone who arrived at a link rather than a launch.
Typing stays safe right after Enter. A first task still settles to the focused-row border (never re-opened into the green editor). If the list surface ends up holding the keyboard instead of an "Add a task" row (for example the project is collapsed), bare letters there are normally vim-style commands (x archives), so for the moment right after a first create a bare letter is treated as continued typing rather than a command, and can't archive or launch anything. Any deliberate key (an arrow, Tab, a chord, Enter, Escape) releases that hold immediately, so real commands are unaffected; Space does not release it, because a space is how you keep typing, and neither does a modifier key on its own (Shift, Caps Lock, Ctrl, Alt, the Windows/Command key) — a keyboard sends a bare Shift before every capital letter, which once let "Get eggs" open Launch agent and archive a task (BUG-B003). Both hosts behave identically — the All-Projects master view (the default landing host) and the per-project outliner.
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