---
title: Tasks (markdown outliner, in development) (part 2)
---
# Tasks (markdown outliner, in development) (part 2)

## What it is

This is part 2 of the [Tasks (markdown outliner, in development)](tasks-v2.md) 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)](tasks-v2.md) — 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 2)

| Key                          | What it does                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| ---------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Space` / `Enter`            | **Space** edits this row (writing mode); **Enter** adds a **new task below**. While typing, **Enter** finishes **editing** (commits text — no new row).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `Space`                      | **Edit** this row (drop into writing mode); **`F2`** does the same — the Windows "rename" alias for Space                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `Enter`                      | **Add a new task** directly below this one (same level + project) and start typing it                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `Shift+Enter`                | **Add a new task** directly **above** this one (same level + project) and start typing it — the mirror of Enter. (While typing, Shift+Enter is a normal line break.)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `Cmd/Ctrl+Enter`             | **Submit + start the next task below** — commits the current task and opens a fresh row right below it in edit mode, so you can type task after task without lifting your hands (rapid entry). Works **while you're typing** the row (it commits first) and when a row is just highlighted. It no longer finishes/archives (that's `x` / `e` / `Delete`).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| `c`                          | **Context** — add or review the task's context attachments (`i` is an alias)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `h`                          | **Snooze** — opens the **universal snooze box** (the same command-palette snoozer used for sessions and the inbox): type a time ("2h", "fri 3pm", "next month") or arrow to a preset and Enter                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `d`                          | **Deadline** — a small picker opens: press `1`–`5` for a preset (today · tomorrow · end of week · next week · next month), type a date ("friday", "mar 15", "in 2 weeks"), or **None** to clear the due date                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `x` / `e`                    | **Finish** the task — marks it **done** and files it into Archived, in one press (undoable with Ctrl/Cmd+Z); the highlight then moves to the next task **in the same project** — the same rule snooze uses (next below it, else the one above, else the next project). (`Cmd/Ctrl+Enter` no longer finishes — it now submits + adds the next task below; see its row.)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `Delete` · `Ctrl/Cmd+Delete` | **Archive** the highlighted task — the same reversible, browsable archive as checking it off (the highlight advances; undo with Ctrl/Cmd+Z). Plain **Delete** needs no modifier. Never fires while you're typing in a row, and it's `Delete` only — not `Backspace`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `p`                          | **Priority** — a quick None / Low / Medium / High picker (importance)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `t`                          | **Estimate** — set the task's time estimate: press **1**–**5** for a preset (15m / 30m / 1h / 2h / 4h), **0** to clear, or type a duration (`30m`, `1h 30m`, `2h`). The field prefills with the current estimate so `t` then Enter keeps it.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `A`                          | **Waiting on** — mark the task as waiting on someone else: a small box opens to name who or what is blocking it and (optionally) set **when to be reminded to chase it** in plain language (**Enter** marks it; an empty box still marks it "waiting"). Once waiting, the box edits that name, sets a new reminder time, or **clears** it. The keyboard twin of the row's ⏳ button.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `w` / `s`                    | Move the **highlight** up / down (`k` / `j` and the arrow keys do the same)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `Ctrl/Cmd+↑` / `↓`           | **Move between projects** — jump the highlight to the previous / next project. In **All Projects** it hops between project headers (staying in that view); in a single-project view it switches the shown project. Wraps around. Mirrors the app-wide Ctrl+↑/↓ "previous / next project", but scoped to the tasks-v2 projects while you're in Tasks.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `Shift+W` / `Shift+S`        | **Move the task itself** up / down — one-hand reorder. With **multiple rows selected**, the whole block shifts together within each row's sibling group (order kept); in **All Projects**, a top-level block at its project's edge crosses **as a set** into the neighboring project (appended, one undo); a nested block at its sibling-group edge cleanly stays put (nesting-at-an-edge stays single-task). For a single row at the **edge of its sibling group**, a nested (indented) row **nests into the item beside it** — move-down → first child of the item below, move-up → last child of the item above (same project only). A **top-level** row instead hops to the next / previous project at a project's edge in **All Projects**.                                                                                                                                                               |
| `Shift+A` / `Shift+D`        | **Move the task** left / right — outdent / indent (one-hand)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `Ctrl/Cmd+X` / `Ctrl/Cmd+V`  | **Cut / paste** the task — mark it to move, then paste it **right below the highlighted task in every view** (same project or across projects); pasting onto a project's **heading** drops it INTO that project instead (even an empty one). **With multiple rows selected, Cut grabs the whole selection**, so pasting into a project moves them all. Cut marks only; nothing moves until you paste, and `Esc` cancels. See [Cut & paste a task](#cut--paste-a-task).                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `V`                          | **Move to project** — open a small picker and choose another project to move the task into (works in both views; rebindable; the ⋯ / right-click **Move to project** is the same). The picker also has a **"＋ New project…"** row — type a name and it **creates the project, moves the task into it, and opens it** (so it shows even when the current project is your only one). And a **Today** row at the top — **Add to Today** (or **Remove from Today** if it's already on the plate) — so you can put a task on or off today's plate from the same menu, just like filing it under a project. Today is an overlay, so this keeps the task's home project (see [Today](#today--your-daily-plate-a-flat-editable-list)).                                                                                                                                                                                |
| `Alt+Shift+↑/↓` · `←/→`      | **Reorder** the task up / down · **outdent / indent** it (← out, → in) — the full OneNote-style outline-move scheme (←/→ are aliases for Shift+Tab / Tab). With **multiple rows selected**, ↑/↓ shifts the whole block within each row's sibling group (order kept); and in **All Projects**, when that block sits at its project's edge, the **whole selection crosses into the neighboring project** (appended there, one undo) — the multi-select twin of the single-row cross below. At its **sibling-group edge** a (single) nested row **nests into the adjacent item** (move-down → first child of the item below, move-up → last child of the item above; same project, depth preserved). In **All Projects**, a **top-level** row instead crosses into the neighboring project at a project's edge — including into an empty project (indent / outdent, and a child's nest, stay within the project). |
| `F`                          | **Fold / unfold** this task's sub-items — hide its subtree behind a chevron (only acts when the task has sub-items)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `:`                          | **Command line** — type a plain-English line and press Enter: "due friday", "high priority", "#work", "move to Errands", "snooze 2h", "done". One line can set several fields at once. (Urgency phrases are ignored on the v2 surface.)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `Ctrl/Cmd+K`                 | **Insert link** — open a small popover (URL + optional text) and drop a markdown `[text](url)` link into the task: **while editing**, a selected word becomes the link text (you just type the URL); **on a highlighted row**, the link is added to it. Empty URL does nothing; no text → the URL shows as the text. Works like the notes editor's Ctrl+K. Rebindable, and also on the row **⋯ / right-click → Insert link** (the mouse + phone path).                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `g` · `b`                    | Launch/open the task's **agent** · **break it down** with AI                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `Ctrl/Cmd+C`                 | **Copy** the task — puts its text (raw markdown line) on the system clipboard **and** on an in-app clipboard so you can **paste it as a duplicate** into any project (Ctrl/Cmd+V / **Paste here**; see [Cut & paste a task](#cut--paste-a-task)). The same as the ⋯ / right-click **Copy**. A fixed chord (not rebindable); while you're editing a task it's the normal text-copy.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `Ctrl/Cmd+Z` · `Ctrl/Cmd+Y`  | **Undo · Redo** — step back through your recent changes with `Ctrl/Cmd+Z` and re-apply them with `Ctrl/Cmd+Y` (or `Ctrl/Cmd+Shift+Z`). Both are unlimited, real (they persist), and fixed chords; while you're editing a row's text they're the normal text undo/redo. See [Archive & universal undo](#archive--universal-undo).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| `/` · `Ctrl/Cmd+F`           | **Find tasks** — open the find-as-you-type bar; matches (and their parents) stay visible, everything else drops away. See [Find tasks](#find-tasks--or-ctrlf).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `Ctrl/Cmd+A`                 | **Select all** visible tasks — the bulk action bar appears (snooze / due / priority / move / finish the whole selection at once). While typing, it stays the normal select-all-text. See [Select many & act once](#select-many--act-once--ctrla--the-bulk-bar).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `?`                          | **Cheat-sheet** — every shortcut, grouped (the answer to "I forget the keys"); also opens from the **keyboard-shortcuts button** in the header                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |

**These command keys are rebindable.** Open **Settings → Keyboard Shortcuts → Tasks**
(the tab appears once Tasks is enabled) to remap any of the command-mode actions —
snooze, deadline, priority, estimate, **waiting on** (`A`), finish, context, launch agent, break-down, command line,
**insert link** (`Ctrl/Cmd+K`), the
focus moves, the **one-hand move keys** (`Shift+W/A/S/D`), **cut/paste** (`Ctrl/Cmd+X` / `Ctrl/Cmd+V`), **move to project** (`V`),
**fold/unfold** (`F`), and help. Each action keeps its
aliases (focus-down is `J` + `S`, context is `C` + `I`, finish is `X` + `E`) and supports
multiple bindings; press **+ Add** then your key, the **X** removes one, **Default** restores. The `?` cheat-sheet then shows your actual keys. The structural
keys — `Enter` / `Shift+Enter` / `Space` / `Esc`, `Tab` indent, the arrows, `Ctrl/Cmd+↑/↓` between projects, `Ctrl/Cmd+Z` undo + `Ctrl/Cmd+Y` redo, duplicate, and
archive (`Ctrl/Cmd+Delete` and a bare `Delete`) — stay fixed (most are shared with the v1 / v3
outliners; the bare `Delete`→archive and `Shift+Enter`→add-above are v2-only additions).

## Related

The overview, the other parts, and everything else worth reading next all sit on [Tasks (markdown outliner, in development)](tasks-v2.md).
