---
title: Venom Tasks
description: Track issues in Venom Cloud with teams, triage, a list and a board, an issue page, the command menu and keyboard shortcuts, and hand work to agents as delegates.
section: cloud
order: 130
audience: [user]
sources: [services/nodejs-cloud/components/tasks, "services/nodejs-cloud/app/(tasks)", docs/tasks.md]
features: [cloud.page-tasks]
---

Venom Tasks is the issue tracker inside Venom Cloud, at `/tasks`. Your org adds it like Venom Notes (an owner or a
billing member adds it on the billing page; until then `/tasks` says so). Switch between Venom, Notes and Tasks with
the product switch at the top of the sidebar.

## Where things are

The sidebar starts with a header: the workspace menu (settings, import, members, invite), search (⌘K) and a new-issue
button. Then come your **Inbox** and **My issues**, your **Favorites**, a **Workspace** section (**Projects**,
**Cycles**, **Views**, **Settings**) and **Your teams**. A team opens to **Issues**, **Triage** (when the team turned
it on, with its count), **Backlog**, **Cycles** (when cycles are on; it opens the current cycle), **Projects** and
**Views**, the last two filtered to that team. Subteams sit under their parent team, a level in; a lock marks a
private team. Fold a section or a team with its arrow; the sidebar remembers what you
folded and how wide you made it (drag its right edge; double-click resets it). `[` hides and shows it. On wide screens a
thin bar above the page shows [where you are](#shell-bar); on a phone the sidebar opens from the menu button. You can
[arrange the sidebar](#customize-sidebar) and open [a team's overview](#team-overview). An issue's own page is `/tasks/issue/{id}` (for example
`/tasks/issue/ENG-12`); an old ID still opens it after the issue moved team. The planning pages are `/tasks/projects`,
`/tasks/cycles`, `/tasks/views` and `/tasks/settings` (see [Settings](/docs/cloud/tasks-settings)). `/tasks` itself opens the list you had open last (or My issues).
A URL that doesn't exist shows "Page not found" and an unknown issue key "Issue not found", both inside Tasks with a link back to My issues.

| Page | URL | What it lists |
|---|---|---|
| Inbox | `/tasks/inbox` | notifications: you were assigned, mentioned, or an issue you follow changed. Opening one marks it read |
| My issues | `/tasks/my/{tab}` (`assigned`, `created`, `subscribed`, `activity`) | issues assigned to you, grouped by when they are due (see [Planning your day](#plan-today)), with tabs for the ones you created, the ones you subscribe to, and **Activity**: issues you're assigned, created, follow or commented on that changed in the last 14 days, the most recent first. An issue you delegated to an agent stays in your list |
| Releases | `/tasks/releases`, `/tasks/releases/{pipeline}`, `/tasks/releases/{pipeline}/{release}` | release pipelines, a pipeline's releases, and one release's issues in the list ([Releases](/docs/cloud/tasks-releases.md)) |
| Pulse | `/tasks/pulse` | the status updates of the projects and initiatives you lead, work on or follow, newest first, with health changes highlighted and the ones due an update; your weekly digest ([Pulse](/docs/cloud/tasks-pulse.md)) |
| Drafts | `/tasks/drafts` | issues you started in the composer and haven't created yet (see Drafts below) |
| Triage | `/tasks/team/{key}/triage` | new issues that came in from outside the team (a form, an integration, an agent). Accept (`1`) moves one into the team; decline (`2`) cancels it |
| Issues, Active, Backlog | `/tasks/team/{key}/{view}` (`issues`, `active`, `backlog`) | the team's issues; Active is started and unstarted ones, Backlog the backlog states |
| Active cycle | `/tasks/team/{key}/cycle` | issues in the team's current cycle |

## Teams, subteams and private teams {#teams}

A Tasks team is one of the organisation's teams ([Settings → Teams](/docs/cloud/teams)) with Tasks' own settings: a
workflow, labels, estimates and cycles. Its name, key, place in the tree, members and the private flag are the org
team's, so a change in either place shows in both.

- **Subteams** nest under their parent team to any depth. A subteam of a Tasks team is a Tasks team too, with its own
  workflow, and the parent's members are its members. The team picker in the New issue dialog shows the tree and
  searches it.
- **Private teams**: their issues, projects, cycles, saved views, recurring issues and notifications are for the team's
  members (members of a team above it included) and the organisation's owners and admins. Anyone else gets "not
  found", the same as for an issue that does not exist, in every list, search, ⌘K, the MCP tools, the live updates,
  the `[[ENG-123]]` chips in Notes and linked notes, the pull request chips and triage's duplicate suggestions. A project
  shows when at least one of its teams is one you can see. A mention of someone who can't see the team notifies no one.
  Exactly what else "private" hides from someone outside the team:
  - **Support.** A conversation linked to the issue shows a **Private issue** chip, with no key, title or status. The
    chip still links to the issue, so a team member can open it. Support's notes on the conversation don't name the
    issue either. When the issue is done, the "we fixed it" draft is still prepared, because it answers the customer.
  - **Initiatives.** Progress counts only the issues you can see, in the projects you can see, and the initiative
    lists only those projects. If you change its projects, the ones you can't see stay attached.
  - **Agents.** The push stream of delegated issues (`/tasks/mcp/assigned`) sends a private team's issue only to a
    credential that may see the team.
  - **Venom Chat.** The Tasks feed ("an issue lands in Triage") never posts a private team's issues, because a
    channel's members are not the team's.

  Private doesn't hide the team's issues from org owners and admins, or from the org's
  [webhooks](/docs/cloud/workspace-mcp#webhooks). An owner or admin adds those endpoints, and they get the same
  fields as for any team: no description, no comment text.
- **Assigning in a private team.** An issue in a private team can be assigned only to someone who can see it: the
  team's members, members of a team above it, and org owners and admins. Anyone else is refused (`400
  not_team_member`, "Add them to the team first"). The same goes for moving an assigned issue into a private team,
  and for a recurring issue's or template's assignee. If someone leaves the team, their issues stay assigned to them
  (they just can't open them), and the next recurring issue is created unassigned. Delegating to an agent is not
  checked, because an agent id doesn't say whose access it has until it connects; the push stream above filters
  instead.
- **Team admins** (the team's admins, or admins of a team above it) change the team's workflow and settings, as org
  owners and admins do. Other members read them.

## The issue list and the board

Issues are grouped by status in workflow order. Each row shows the priority, the ID, the status, the title, labels,
the estimate and who owns it. A small agent badge on the avatar means an agent is working on it as a delegate.

- Move with `j` and `k`, select with `x` (Shift+click selects a range, ⌘/Ctrl+click adds one), open with `Enter`,
  or press `Space` to peek at the issue beside the list.
- Click a property on a row or card to change it in place: the priority or status icon, the assignee, a label,
  the project, cycle, milestone, estimate or due date each open their picker under the click, for that issue, or for
  the whole selection when the row is part of it. Press the digit or type to pick (`2` sets High), and focus stays on
  the row. A click anywhere else on the row opens the issue; on a touch screen a tap always opens it.
- With issues selected, a bar floats at the bottom: **N selected**, Status, Priority, Assignee, Labels, **Delegate**
  (an agent), Archive and Delete for all of them at once, **Actions** (`⌘/Ctrl+K`, the command menu acting on the
  selection) and **×** (or `Esc`) to clear. `⌘/Ctrl+Alt+A` selects the whole group the focused issue is in.
- Hover a group header for **⋯**: fold or unfold it, fold every other group, **Hide this group**, select all in the
  group, or create an issue in it. Hidden groups stay hidden in that view (this browser; it is part of the display),
  and **N hidden groups: show** at the end of the list brings them back; a shown group's menu has **Show this group
  again**. While an Insights chart filters the list, a group's count reads "matched / total".
- `t` on a parent row shows or hides its sub-issues (like `→` and `←`); on any other row it folds the group.
  `Alt+Shift+ArrowUp` and `Alt+Shift+ArrowDown` move the focused or selected issues to the top or bottom of their group
  (manual ordering; otherwise a message says to switch).
- Back from an issue (the browser's Back, `Esc`, a `g` key) puts you on the row you left, at the scroll position
  you left, for each list in this visit.
- **Filter** (`f`) adds a chip such as "Status is In Progress" or "Assignee is not me". See [Filters](#filters).
  Filters and display options live in the address bar, so a link opens the same list.
- **Display options** (`Shift+V`) switches between list and board, and sets grouping and sub-grouping, ordering
  (the arrow button beside it reverses the order; manual order stays as you dragged it), whether completed issues
  show, **Order completed by recency** (closed issues last in each group, the most recently closed first), empty
  groups, sub-issues and how they nest, and which properties a row shows. On a team that has subteams, **Include
  subteams** (on by default) shows the subteams' issues in the team's Issues, Active and Backlog lists too; Triage and
  the cycle stay the team's own. Each view remembers its own options in
  this browser; **Reset** (shown when the options differ from the view's defaults) puts them back. See [Display options](#display-options).
- On the **board** (`⌘/Ctrl+B`), drag a card to another column to change its status (or whatever the board is
  grouped by). With manual ordering, where you drop a card is where it stays. From the keyboard, `→` and `←` focus
  the card at the same position in the next column, `j` and `k` move within it, and `⌘/Ctrl+→` and `⌘/Ctrl+←` move
  the focused or selected cards one column over, exactly as a drop would (one `⌘/Ctrl+Z` undoes it). With
  swimlanes, `⌘/Ctrl+Alt+ArrowUp` and `⌘/Ctrl+Alt+ArrowDown` move cards to the lane above or below.
- A column's **⋯** hides it, collapses it to a narrow strip (click the strip to open it), creates an issue in it or
  selects its cards. Columns with no issues (unless **Show empty groups** is on) and columns you hid wait in a
  **Hidden columns** strip at the right with their counts; click one to show it, or drop a card on it.
- The peek (`Space`) shows the issue's status and how long it has had it, for example **In Progress · 20d**; hover
  for the date.
- A parent issue shows a ring that fills as its sub-issues close, with a count such as "3/5". Click the arrow
  beside it (or press `→`) to show its sub-issues nested under it; `←` hides them again, or, on a sub-issue, moves to
  its parent.

### The issue menu {#issue-menu}

Right-click an issue (a row or a board card), click the `⋯` at the end of a row, the `⋯` on the issue page or in the
peek, or the `⋯` in the bar over a selection: the same menu opens everywhere. When the row is part of a selection, the
menu acts on all of it, and a change to several issues is one change for `⌘/Ctrl+Z`. Every row shows its shortcut,
and only rows that apply appear: a reader sees Copy, Open, Favorite, Remind me and Subscribe; Milestone appears when
the issues share a project, Estimate and Cycle when the team uses them.

- **Status, Priority, Assignee, Delegate, Labels, Due date, Project, Milestone, Cycle, Estimate** open their picker
  beside the menu: type to filter, press a number to pick, `Enter` applies. Labels stays open while you tick several.
  Due date takes words such as "in 3 weeks" and shows the date they mean. `Esc` or `←` goes back to the menu.
- **Move to team…** moves the issues to another team ([Move to another team](#move-to-team)).
- **More properties:** Parent issue…, Add a link…, Rename…, Subscribers…, Remove due date.
- **Create related** (one issue): a related issue, a sub-issue, a parent issue (the new issue becomes this one's
  parent), an issue it blocks, or an issue that blocks it. The composer opens with the relation filled in and makes it
  when you create the issue; both issues show it.
  **Apply template…** (one issue) fills its empty fields from a template and adds the template's sub-issues
  ([Templates](#templates)).
- **Mark as:** Sub-issue of…, Related to…, Blocked by…, Blocking…, Duplicate of… (one or several issues). **Parent
  of…** (one issue) lists issues to make its sub-issues: pick as many as you like (each gets a check, a second pick
  takes it off) and they move under it when the list closes, as one change that one `⌘/Ctrl+Z` undoes. The issue's own
  parents aren't offered; a move that would make a loop is refused with a message.
- **Remove** (one issue, when it has any): its parent and each relation, one row each; picking one removes it.
- **Copy:** ID, link, title, title as a link, as Markdown, everything as Markdown (with comments and sub-issues), git
  branch name, as a prompt for an agent.
- **Convert to** (one issue): **Project…** asks first, then makes a planned project from the issue (its title,
  description, the assignee as lead), moves its sub-issues into the project and closes the issue with a comment that
  links the project. Linear keeps the issue as the project's first issue; Venom closes it, so the work is tracked in
  one place. **Template…** saves a team template from the issue and its sub-issue titles. **Recurring issue…** opens a
  new recurring series filled in from the issue in the team's settings. **Agent task…** (one or several issues, when
  your organisation has Agents): see [Convert to an agent task](#convert-to-an-agent-task).
- **Start agent chat…** (when your organisation has Agents): the issues' brief in a new agent chat
  ([Start an agent chat](#start-an-agent-chat)).
- **Make a copy…** (one issue): a dialog with the title ("Copy of …"), the team, and switches for its properties
  (on), its open sub-issues and its relations (off). The copy links back to the original in its Linked section.
- **Move** (one issue in a list): to the top, up, down or to the bottom of its group, when the list is in manual
  order; otherwise the rows say why they can't.
- Open, Open in peek, Favorite, Remind me, Subscribe, Archive or Restore, and Delete.

Arrow keys move in the menu, `→` opens a submenu, `Esc` closes one level. Shift+right-click keeps the browser's own
menu. On a phone the menu is a sheet, and a property opens its picker as a sheet from the bottom.

Copying several issues at once gives one line per issue for links, the IDs separated by commas, and, for a prompt
(`⌘/Ctrl+Alt+P`), a single brief for an agent: a task list with each issue's ID, title and link, then each issue's
status, priority, labels and description. Deleting issues, clearing the Inbox and deleting a triage rule ask first in
Tasks' own dialog, which lists the IDs of the issues to delete (up to five, then how many more): `Enter` confirms,
`Esc` cancels, and for a delete the focus starts on Cancel.

Every change shows at once and is saved in the background. If the save fails it is put back and a message says so.
`⌘/Ctrl+Z` undoes your last change. Changes others make, people or agents, arrive live.

### Large lists {#large-lists}

A list or board column with thousands of issues opens about as fast as a short one:

- Tasks loads your open issues first and shows them. Issues closed or changed in the last 90 days follow in the
  background, then older closed ones. While older ones are still arriving, a list set to show **all** completed
  issues says "Loading older closed issues…" at its end (on a board, at the end of the closed columns).
- A long list draws only the rows near the screen. `j`/`k`, `x`, Shift+click, select all and the bulk bar still
  work on every row of the list, drawn or not, and moving the focus to a row off screen scrolls to it. Group headers
  stay pinned while you scroll, a change made elsewhere (by you, a teammate or an agent) doesn't make the list jump,
  and coming back from an issue puts you where you were. Board columns with more than 60 cards, and swimlanes off
  screen, are drawn the same way.
- Because rows off screen aren't on the page, the browser's own find (`⌘/Ctrl+F`) only finds rows near the screen in
  a list of more than 150 rows. Use the list's search (`/`) or a filter instead: they search every issue.
- With an insight from the Insights panel filtering the list, each group header and board column shows
  how many of its issues match, such as "4 / 12".
- To check speed in your own browser, add `?perf=1` to a list's address: the browser console then shows how long the
  first rows took and how many are drawn. Nothing is sent anywhere.

### Fast reopening and offline reading {#local-cache}

Tasks keeps a copy of what you last saw in your browser's own storage (IndexedDB), so on your next visit the
sidebar, your lists and the issues you opened recently show at once, before the network answers. A small
**Updating…** note sits at the bottom of the sidebar until the server's answer replaces the copy. You don't need to do
anything to turn this on.

- **The server stays the source of truth.** The copy is only used for the first paint. When the server answers, its
  issues replace the copy: issues deleted, moved to a team you can't see, or changed by someone else while you were
  away update or disappear then. Changes made in another tab or by an agent reach you through the live stream, as
  before.
- **Editing before the update lands.** You can edit right away. If the issue is gone on the server, the edit fails
  with "That issue was deleted or you no longer have access to it. Nothing was changed." and the row disappears.
  Nothing is written without the server checking it.
- **Offline.** If Tasks can't reach Venom, the copy stays on screen and the note says **Offline**. You can read your
  lists and recently opened issues; changes won't save until you're back online.
- **What is kept.** For you in this organisation only: the workspace (teams, statuses, labels, people, projects,
  cycles, favorites), your Tasks preferences, your open issues and those closed in the last 90 days, and the last 200
  issue pages you opened, with their comments and activity. Notifications, drafts and attachments are not part of it.
  A copy older than 14 days is not shown, and the copy is capped at 20,000 issues and about 25 MB; past that only open
  issues and the last 50 issue pages are kept, the least recently changed issues going first.
- **When it is deleted.** Signing out, switching organisation, and opening Tasks as someone else on the same browser
  delete it (another person never sees your copy, not even for a moment). Losing access to Venom Tasks deletes it on
  the next visit, and a private team you were removed from is left out of the copy before anything is shown. A new
  Venom release that changes what an issue holds starts a fresh copy.
- **Clear it yourself** with **Clear local data** in [Settings → Preferences](/docs/cloud/tasks-settings.md#preferences). Tasks
  saves a new copy the next time you open it. Clearing your browser's site data for Venom deletes it too.
- In private browsing, with storage blocked or full, or in a browser without IndexedDB, Tasks works as it did before
  the copy existed: it loads from the network, with no error shown.

### Filters {#filters}

`f` opens the filter menu with a search box. Type a few letters of a field ("crea" finds Created and Creator) and press
`Enter` to see its values, or type a value ("urg", "todo", a person's name): the menu offers it directly as "Priority is
Urgent", across every field at once, and `Enter` adds it. `Enter` on a value adds it and closes the menu; hold `Shift`
to pick several. Each value shows how many issues in the list would match it. Values that match none are folded under
**Show N options with no matches**.

| Field | Values and operators |
|---|---|
| Status, Status type, Priority, Assignee, Agent, Creator, Project, Milestone, Cycle, Source, SLA | is, is not; several values read "is any of" / "is none of" |
| Labels, Subscribers | is any of, is none of, **includes all of** (every one of them) |
| Team | the teams by path ("Engineering › Mobile"); a team covers its sub-teams unless **Include subteams** is off |
| Parent issue | is a sub-issue, is not a sub-issue, has sub-issues, has no sub-issues, or a parent in the list |
| Estimate | a value of the team's scale or no estimate; **at least** or **at most** a value |
| Due date | overdue, due within a week or a month, has a due date, no due date; before, after or between days |
| Created, Updated, Started, Completed, Canceled | in the last day, week, month or 3 months; more than a week or a month ago; at any time or never (where it can be empty); before, after or between days (a calendar) |
| Customer requests | requested, 3 or more, 10 or more, none |
| Reminder | you have a reminder on it, or not |
| Content | words in the title or description: contains, does not contain |
| Relations | blocked, blocking, has related issues, is a duplicate, has duplicates, is a sub-issue, has sub-issues, has any relation |
| Blocked by | the issues blocking it (the list's blockers; type to search every issue), or blocked by nothing |
| Time in status | more than a day, 3 days, a week, 2 weeks or a month; less than a day, 3 days or a week (since it last changed status) |
| Links | where its links point: GitHub, GitLab, Figma, Sentry, Notion, Jira and other products by their domain, any other site by its host, linked notes, or no links; **includes all of** too |
| Pull request | open, draft, merged, closed, or no pull request |
| Project status, Project priority, Project lead, Project labels | the issue's project's own status, priority, lead and labels; "no project" where the issue has none |
| Initiative | the initiatives its project is in, or none |
| Template | the template it was created from (recorded from November 15, 2026), or none |
| Added to cycle | planned (before the cycle started or within its first day) or after it started |
| Mentions | the items its description or comments mention (the list offers the ones its issues mention), or nothing |
| Agent chat | your own agent chats started from the issue: working, done or failed, or none; other people's chats never count |
| Release, Release pipeline | the releases it is in (an issue can be in one per pipeline), or the pipelines of those releases; "no release" where it is in none; **includes all of** too ([Releases](/docs/cloud/tasks-releases.md)) |

The Parent issue and Blocked by values also search every issue: type part of an identifier or a title and the first
8 matches appear under the list's own values.

A chip reads field, operator, values. Click the operator to change it in place; click the values to change them. With
the keyboard, `←` and `→` move between chips and `Backspace` removes the focused one. With two chips or more, **Match
All / Any** says whether an issue must match every chip or one of them. Under the list, "N issues hidden by filters ·
Clear filters" says how many of the list's issues the chips hide. A filter on completed or canceled issues shows them
whatever the **Completed** option, and waits for closed issues to load (they arrive after the open ones) rather than
show an empty list. **Save view** keeps the chips and **Match** with the view.

#### Advanced filter {#advanced-filter}

The first row of the filter menu, **Advanced filter…**, opens a builder for conditions that chips can't say, such as
"Assignee is me AND (Priority is Urgent OR Labels is Bug)". It starts with the list's chips. Each row is a condition
(field, operator, values: the same lists the chips use, with their counts), and each group says **All** or **Any** of
its rows. **+ Condition** adds a row and opens its values; **+ Group** adds a group inside. Groups nest three levels
inside the top one, and a filter takes at most 50 conditions; the builder says when you reach either. Drag a row, or
press `Alt+↑` / `Alt+↓` on it, to move it; `Backspace` on a row still without values removes it. The list follows as
you edit, and its address keeps the filter, so a link or a reload opens the same list. `Esc` or **Done** closes the
builder and keeps the filter. When the conditions are flat again, **Convert to chips** puts them back as chips.

Parts of the filter that chips can show come back as chips; the rest shows as one **Advanced · N conditions** chip
(its tooltip spells the conditions out). Click it to edit them, or its × to remove them. **Save view** keeps the whole
filter, and a view opens the same way. Insights, the CSV export and the "N issues hidden by filters" line count it too.
On a phone the builder opens as a sheet.

### Display options {#display-options}

| Option | What it does |
|---|---|
| List / Board | rows under group headers, or cards in columns |
| Grouping | status, status type, due date (lists only; My issues' default), assignee, agent, priority, project, milestone, cycle, label, team, parent issue, or none |
| Sub-grouping | groups inside each group: nested headers on a list, swimlanes on a board. Dropping a card into a swimlane cell (or creating from its "+") sets both values, for example Todo and Ana. The button beside them swaps grouping and sub-grouping |
| Ordering | manual, priority, status (workflow order), assignee and agent (by name), last updated, last created, last started, last completed, time in status (longest first), due date, estimate, title, links (most first) and customer demand. The arrow beside it reverses the order (Last created reversed is oldest first); manual order stays as you dragged it |
| Completed | which closed issues show: all, closed in the past day, week or month, or none |
| Order completed by recency | closed issues last in each group, the most recently closed first, whatever the ordering |
| Show empty groups | groups with no issues still show; off, a board parks its empty columns in the **Hidden columns** strip (click one to open it) |
| Hidden groups | the groups and columns hidden from their **⋯** menu; kept with the display, and saved with a view's display |
| Show sub-issues | sub-issues get rows of their own |
| Nested sub-issues (list) | what the arrow on a parent shows under it: **Show matching** (only sub-issues the view shows), **Show all**, or **Show none** (no arrows) |
| Display properties | ID, priority, status, labels, project, milestone, cycle, due date, estimate, assignee, creator, time in status (how long the issue has had its status: `3d`, `2w`), created, updated, links (how many web links it has), pull requests, **started** ("Started 3d ago", the date on hover), **completed** ("Done 12 Mar", or "Canceled 12 Mar" in a muted tone), **agent** (the delegate agent as its own chip: its badge and name, a click changes it) **sub-issue progress** (on by default; "2/5" with a ring) and **release** (the release it is in, "2.5", or "2.5 +1" when it is in releases of several pipelines; [Releases](/docs/cloud/tasks-releases.md)). Started, completed and agent are off until you switch them on; when **Agent** is on the assignee avatar no longer carries the agent's badge. Board cards show the same properties, including assignee, cycle, created, updated and pull requests; their chips wrap to at most two lines. On a phone a row keeps the ID, status, priority and assignee plus one more property: the first other one you have on, in the order of this list. Saved views and the list's address carry all of them |

### Planning your day {#plan-today}

My issues opens grouped by due date: **Overdue**, **Today**, **Tomorrow**, **This week** (to Sunday), **Later**,
**No due date**, then **Done** for closed issues. Empty groups are hidden. Drag an issue into a group, or create one
from its "+", to set the date: Today and Tomorrow their day, This week its Friday (Sunday once Friday is tomorrow or
past; on a weekend the group is hidden), Later next Monday, No due date clears it. Overdue and Done set nothing. Any
list can group this way (**Display → Grouping → Due date**); a saved view cannot.

My issues can also group by **Focus** (**Display → Grouping → Focus**, offered on My issues only): what to work on
next, in this order, each issue in the first group it fits: **Urgent**, **SLA at risk** (at risk or breached),
**Blocking others** (issues that block an open issue; a blocked issue in a private team you are not in doesn't count), **In the current
cycle**, **Other active work** (started or unstarted), **Triage**, **Backlog** and **Recently completed** (the last
7 days). Inside a group, started issues come first, then by priority. While Focus is on, the ordering reads
**Importance** and can't be changed.

`h` snoozes an issue out of My issues until a time you pick (1 hour, Tomorrow 9:00, Next week, or a date). **Show
snoozed** under the tabs lists them again, and `h` on one offers **Unsnooze**. When the time comes it is back, and you
get a **Snooze ended** item in the Inbox. Done issues can't be snoozed.

### Reminders {#reminders}

`Shift+H` on an issue (a list, the board, its page or a peek), **⌘K → Remind me about it…**, **Remind me…** in the
issue's menu, or the **Reminder** row on the issue page asks when to remind you: **An hour from now**, **In 3 hours**,
**This evening** (18:00, until 17:00), **Tomorrow** (9:00), **Next week** (the first day of your week, 9:00),
**A month from now** (9:00), or **Pick a date and time…**. Or type it: `4pm` (today, or tomorrow once 4 pm has passed),
`16:30`, `in 2 hours`, `tomorrow 8am`, `next mon 9:30`, `in 5 weeks`, `dec 3 10am`; the first row shows what it read,
and nothing shows when it reads nothing. Times are your browser's time zone. With several issues selected, each gets
its own reminder. On a project's or an initiative's page `Shift+H` or the bell in its header does the same for it.

You have one reminder per issue, project or initiative: setting another replaces it, and the picker's first row, **Remove
reminder**, or the × on the issue page removes it. Issues with your reminder show a small bell in the list. The
Inbox's **Reminders** tab lists what is coming, soonest first.

When the time comes (within a minute) a **Reminder** item lands in your Tasks inbox and the bell, with your note if an
agent or the API set one; snooze it again (`h` or the clock) or delete it like any item. A project's reminder shows in
the bell until you mark it read. If the issue or project was completed, cancelled or archived in the meantime, the
reminder still comes and says so, unless you ticked **Only if still open**, in which case it is skipped. A reminder on
an issue that was deleted, or that you can no longer open (a private team you left), is dropped without a word.
Reminders reach only you; Tasks has no push or email for them.

Agents set, list and cancel reminders with `tasks_reminder_set`, `tasks_reminder_list` and `tasks_reminder_delete`
([API](/docs/cloud/tasks-api.md#reminders)). An agent with write access can remind an issue's assignee (`for: "assignee"`).

On a saved view (`/tasks/views/{id}`) the view's own display is the default. Changes stay in your browser until you
press **Save as default for this view**, which stores them on the view for everyone who opens it.

## The issue page

Open an issue to see its title and description, its sub-issues, its relations (blocked by, blocking, related,
duplicate) and its activity and comments in one stream. Click the title or the description to edit them in place.
**History** lists earlier versions of the description and restores one.

The header of an issue has buttons to subscribe, archive, copy the link, the branch name and the ID, and **⋯** for
the same actions menu as a right-click on a list.

Keys that work on an issue page, in a peek and on a list (on the focused or selected issues):

- `i` assigns the issue to you; press it again on an issue that is already yours and it unassigns you. With several
  issues selected it unassigns only when all of them are yours. The toast says which, and `⌘/Ctrl+Z` undoes it.
- `#` restores an archived issue (`⌘/Ctrl+Shift+Backspace` still toggles archive and restore). On an issue that is
  not archived it says so.
- `Shift+R` renames. On the issue page it selects the title so typing replaces it; on a list or in a peek it opens a
  one-line box with the title filled in (Enter saves, Esc cancels). If the title changed elsewhere meanwhile, it
  says so instead of overwriting.
- `⌘/Ctrl+Shift+I` puts the caret at the end of the description, on the issue page and in a peek.
- `⌘/Ctrl+Alt+L` opens a box for an address (http or https; a bare `example.com` becomes https) and an optional
  title, and adds it as a link on every targeted issue. The link appears under Links on the page.
- `Shift+M` sets the milestone: **No milestone**, then the milestones of the issue's project by target date, with the
  next unfinished one marked and 1 to 9 picking a row. The issues must share one project. The properties sidebar has
  a **Milestone** row under Project that opens the same picker.
- `⌘/Ctrl+Shift+S` manages subscribers: a list of people with a check beside each one who follows the issue (a dash
  when only some of several issues have them). Choosing a person adds or removes them. The people who follow an issue
  show as small avatars beside the bell in its header; click them to open the same list. Adding someone else needs
  write access to the issue and that the person can see its team.
- `⌘/Ctrl+Shift+ArrowDown` opens the issue's sub-issue; with several it asks which (open ones first).
- `⌘/Ctrl+Shift+'` copies the title and `⌘/Ctrl+Alt+C` copies the issue as Markdown with its comments and sub-issues.
  The command menu also has **Copy the title as a link** (a real link when you paste into rich text) and **Copy the
  issue as Markdown** (without comments). With several issues the rows say "titles", "links" and so on.
- `⌘/Ctrl+Delete` deletes, like `⌘/Ctrl+Backspace` (after the same confirmation).

An issue opened from a list remembers that list: `j` and `k` on the page step to the next and previous issue of it
(the address is replaced, so the browser's Back button is not filled with every step), and `Esc` returns to the list
with the issue you were on highlighted. An issue you opened by its link has no such list, and `j` and `k` do nothing.

### Changing properties {#pickers}

Every property (status, priority, assignee, agent, labels, estimate, due date, project, cycle, team, parent and
relations) changes through the same picker. A key (`s`, `p`, `a`, `l`…) opens it in the middle of the screen; clicking
a property in the issue sidebar, or a button in the bar that shows when issues are selected, opens it under that
control, with the key that opens it shown beside the filter. On a phone it always opens in the middle.

- **The current value is highlighted** when the picker opens, so `↵` keeps it and `↑`/`↓` start from it.
- **Number keys pick directly** while the filter is empty: the "No …" row is `0`, then `1` to `9` down the list.
  Priority's numbers are its values (`1` Urgent, `2` High, `3` Medium, `4` Low, `0` none), so `p` then `1` makes an
  issue urgent and `a` then `1` assigns it to you (`a` then `0` unassigns). Once you type in the filter, digits type.
- **Several issues at once**: a ✓ marks a value every selected issue has, a dash one that only some have. Choosing
  a value sets it on all of them, and one `⌘/Ctrl+Z` undoes it for all.
- **Labels** stay open so you can toggle several. They are listed as **Applied** (what the issues have), the team's
  labels and the workspace's; a label in a group reads "Group › Label", and choosing a second label of a group
  replaces the first. A dashed label goes on every selected issue; choose it again to take it off all of them.
  **Remove all labels** clears them. Type a name no label has and **Create label "…"** makes it (a team label when
  the issues share a team, else a workspace label) and applies it; it shows in Settings → Labels like any other.
- **Suggested labels.** For one issue with pending AI triage suggestions, **Labels** opens with a **Suggested**
  section first: each suggested label with a spark and its score as a muted percentage. Choosing one applies it and
  marks the suggestion accepted. A team with AI triage off asks for nothing, and typing in the filter searches the
  whole list.
- **Projects** show their status, the issue's team's projects first, and **Create project "…"** works the same way.
- **Status counts.** Opened from a list, **Change status** shows how many issues of that list are in each status,
  muted on the right. The issue page, and a selection that spans two teams, show none.
- **Assign to** lists you first, then a **Recent** section with up to five people you assigned to lately (from any
  picker or the bar for selected issues; kept in this browser, per organization and member, and dropped when someone
  leaves). Typing searches everyone, and the digits number the rows you see. **Manage subscribers** shares the list.
  Your agents have their own section: picking one delegates the issue to it and keeps the assignee. `Shift+A` still
  opens the agent picker on its own, in the same list as the issue page's agent control.
- **Parent and relations** list the issues already linked to this one first, then the matches for what you type
  (recently updated ones when the filter is empty).
- **Move to team** shows the team the issue is in, and under the list what the move does for the highlighted team:
  the status it lands in (the one of the same name, else the first of the same type) and how many of its labels
  belong to the old team and are removed. Picking a team opens [Move to another team](#move-to-team) to confirm.

`Esc` closes the picker and puts focus back on the control or row you started from.

### Reactions

React to a comment with the smiley in its top-right corner (it shows when you point at the comment), or to the
description with the smiley under it. The picker has quick picks, the ones you used lately and a search (`tada`,
`+1`). Reactions show as pills: yours are tinted, a click adds or takes back yours, and pointing at one lists who
reacted. Agents' comments take reactions like anyone's.

### Comment links, threads and the activity {#comment-links}

Every comment has a **⋯** menu (it shows when you point at the comment; right-click opens the same menu, except on a
link or selected text):

- **Edit** (your own comments), **Copy link**, **Copy as Markdown** (mentions read as `@Name`).
- **New issue from comment…** and **New sub-issue from comment…** open the new-issue form with the first line of the
  comment as the title (80 characters at most), the comment quoted in the description with a link back, and the new
  issue related to this one (or its sub-issue).
- **Resolve thread** or **Reopen thread** on a thread's first comment, for people who can write.
- **Delete** (the author or an org admin), after a confirmation.

A reader sees the copies. **Copy link** puts `/tasks/issue/ENG-12#comment-<id>` on your clipboard and in the address
bar. Opening such a link (a copied one, or the link in a notification email or push) scrolls to that comment and
highlights it for two seconds (a border only, without motion, when you ask your system for reduced motion). A reply
inside a folded thread opens the thread first; a comment that was deleted says "That comment was deleted".

A resolved thread folds into one line, "Resolved thread · 3 replies · resolved by Ana · 2d ago"; click it, or press
`Enter` on it, to read the thread, and **Hide** folds it again. Replying to a resolved thread reopens it. The activity
says "resolved a thread" and "reopened a thread". Threads that were resolved in Linear arrive resolved.

Runs of more than three small events in a row (labels, links, assignee, priority, due date…) fold into one line,
"Show 10 more events: 6 label changes, 4 relation changes"; click it to show them and again to hide them. Status
changes, creation and comments always stay visible, and the newest run stays open while it is the last thing on the
page. The **Activity** heading has **Subscribe** or **Unsubscribe** and up to five avatars of the people who follow the
issue (click them to manage subscribers). Pointing at a person's name anywhere in Tasks (and in People, Notes and
Chat) shows a card with their role, email, local time (when they have a time zone set), teams and how many open issues
are assigned to them. **Their issues** opens the list of the team that holds most of those, filtered to "Assignee is"
that person.

On wide screens the sidebar shows how long the issue has had its status and, when set, **Started**, **Completed** or
**Canceled** with the date (the exact time when you point at it).

### Writing descriptions and comments

The description, comments and the new-issue form share one rich editor. What you write is stored as markdown, so
agents and the API read and write the same text.

- Type `/` for blocks: headings, bulleted, numbered and to-do lists, code, quote, divider, table and Mermaid
  diagrams.
- Type `@` to mention a member or an agent; they get a notification. The same menu offers anything else you can see,
  grouped by kind under the people: projects, notes, contacts, companies, deals, agent chats, cycles and more. Saving
  links the issue to it (it shows in that item's **Linked** section): see
  [Mentions](/docs/cloud/references.md#mentions).
- Type `#` (or `[[`) and part of a title or an ID to link another issue. The link reads `[[ENG-12]]` in the stored
  text. An ID typed as plain text, such as `ENG-12`, shows as a link to that issue in comments, quick look and
  release notes when it is an issue you can see (not inside code or another link); the stored text stays as typed,
  and it doesn't relate the issues the way `[[ENG-12]]` does.
- Type `:` and a name for an emoji (`:tada` offers 🎉); `:tada:` typed out in full becomes 🎉 at once.
- Markdown shortcuts work as you type (`# ` for a heading, `- ` for a list, `[] ` for a to-do, `> ` for a quote,
  `|--` for a table), and pasted markdown or formatted text keeps its formatting. Select text for the formatting
  bar; `⌘/Ctrl+B`, `⌘/Ctrl+I` and `⌘/Ctrl+K` (link) work as usual, and so do Linear's list keys
  (`⌘/Ctrl+Shift+7`, `8`, `9`).
- `>>> ` (or **Toggle list** in the `/` menu) makes a collapsible section: a summary line with the rest folded under
  it, good for long logs and agent prompts. It is saved as `> [!toggle]- Summary` with the content quoted under it,
  and shows closed on the issue page and in comments until you click it. See [the API](/docs/cloud/tasks-api.md#issues) for the
  syntax agents write.
- A typed emoticon becomes an emoji after a space (`:)` 🙂, `<3` ❤️); Backspace right after takes it back, and
  **Turn typed emoticons into emoji** in [Preferences](/docs/cloud/tasks-settings.md#preferences) turns it off.
- The description saves when you click away. A comment posts with `⌘/Ctrl+Enter` (or `Enter`, if you chose it in
  [Preferences](/docs/cloud/tasks-settings.md#preferences)); in a to-do, `⌘/Ctrl+Enter` checks it instead. Esc stops editing.

### Steps you tick off {#steps}

A to-do list in the description is the issue's steps. Ticking or unticking a step saves at once, so the list, the
board and your other devices show it straight away.

- Under the description, a bar shows how far you are (**3 of 7 steps**). When every step is ticked and the issue is
  still open, **Mark done** moves it to the team's done status.
- In the list and on the board, an issue with steps shows them ticked so far (☑ 3/7) next to its title.
- In the activity, a save that only ticks or unticks steps reads **ticked steps · 3 of 7**, and a run of ticks by one
  person shows as one line. Over the API it is an `updated` row with `field: "steps"` and `from`/`to` as
  `{done, total}`; any other change to the text is still `field: "description"`.
- A description written as a numbered list (`1. Open the console`, `2. Copy the key`) shows **Make the 7 numbered
  steps tickable** under it. One click turns each top-level numbered item into a to-do item, keeping every word and
  the order; nested lists, code and the rest of the text stay as they were, and **History** keeps the text before.
- Agents filing work for a person (`tasks_issue_create` over MCP) are asked to write the steps as a to-do list
  (`- [ ] step`), so those issues can be ticked off from the start.

### Editing at the same time {#stale-writes}

If someone else (a person or an agent) changes the title or description while you are editing it, your save does not
overwrite their change without telling you. When your edit and theirs touch different lines, Venom Tasks merges them
and says so. When they touch the same lines, the issue page shows both texts, yours (not saved yet) and the one saved
now, with **Keep mine** (yours replaces theirs) and **Use theirs** (yours is dropped). Status, assignee, priority and
the other fields are not checked: the last change wins, as before. Either way, **History** keeps every earlier text.

Over the API, every issue carries a `textVersion` that goes up with each change to its title or description. Send it
back as `expectTextVersion` on `PATCH /tasks/api/issues/{id}` with a title or description change, and the write is
refused with `409` and code `stale` if the text moved on. The error's `current` has the text now (`textVersion`,
`title`, `description`, `updatedAt`), and nothing in that patch is written. Without `expectTextVersion` nothing is
checked.

### Sub-issues

**+ Add → Sub-issue** under the issue (or **+ Add** in the Sub-issues header once there are some) takes one title per
Enter. Paste a list (bullets, numbers or one title a line) to create one sub-issue per line at once. Each row's × makes
that sub-issue a top-level issue again; on a sub-issue, **Make top-level** next to its parent does the same.
**+ Add → Parent issue…** (`⌘/Ctrl+Shift+P`) moves any issue under a parent. The same menu adds relations, links and
files ([Links and attachments](/docs/cloud/tasks-resources.md#add)).

A team can close parents for you: in the team's settings, under Workflow, turn on **Close parents automatically**.
When the last open sub-issue of a parent is done or canceled, the parent moves to the team's Done state, shown in its
activity as done by Venom Tasks.

The properties are status, priority, **assignee**, **delegate**, labels, estimate, project, cycle and due date.
The assignee is always a person: the one responsible. The delegate is an agent working on it for them; an issue can
have both. Comments an agent wrote through MCP carry a "via MCP" badge. `Shift+A` delegates, `a` assigns.

Write a comment with `Ctrl+M` (⌘/Ctrl+Enter sends). Reply to a comment from its Reply link or with `r`.

### Move to another team {#move-to-team}

An issue filed in the wrong team moves to the right one with **Move to team…**: in the issue menu, with
`⌘/Ctrl+Shift+M`, from the Team row on the issue page, or from ⌘K. Select several issues in a list first to move them
together. Pick the team, and a dialog shows what the move does before anything changes:

- **A new identifier.** The issue takes the next number of the new team: CON-1 becomes, say, VEN-12. The old
  identifier keeps working: `/tasks/issue/CON-1` opens VEN-12, and so do `[[CON-1]]` links, mentions, a git branch or
  pull request that names CON-1, search and ⌘K. CON-1 is never given to another issue. The activity says "moved from
  CON to VEN, was CON-1", and an open issue page shows the new identifier.
- **The status** is the new team's status of the same name, else its first status of the same type (a "QA" that is
  started lands in the first started status).
- **Labels** of the old team become the new team's label of the same name; one it doesn't have is removed. Workspace
  labels, and labels of the new team's parent teams, stay.
- **The cycle** is cleared: cycles belong to a team.
- **The estimate** stays if the new team's scale has the value, else it is cleared.
- **The project** stays if the project is in the new team (or has no team), else it is cleared with its milestone.
- **The assignee and the delegate** stay if they can see the new team (a private team's members), else they are
  cleared.
- **Sub-issues:** **Move sub-issues too** (on by default) moves every sub-issue below it. Left off, they stay in their
  team under the moved parent: a parent and its sub-issues may be in different teams.

Everything that would be cleared or removed is listed under "This move removes" before you press **Move**.
`⌘/Ctrl+Z` moves the issues back, and each takes its old number again. You need to be able to change the issue and
to create issues in the new team; a private team you are not in is not offered. Subscribers are told about the new
status as for any change, and org webhooks and the change feed see an update. Over MCP: `tasks_issue_move`
([MCP](/docs/cloud/tasks-mcp.md)); over HTTP: `POST /tasks/api/issues/move` ([API](/docs/cloud/tasks-api.md)).

### Start an agent chat {#start-an-agent-chat}

When your organisation has [Agents](/docs/agents/app.md), **Start an agent chat** (`⌘/Ctrl+Alt+Shift+P`, ⌘K, or **Start
agent chat…** in the issue menu) on the open, focused or selected issues opens the Agents composer with their brief
written and a **From ENG-12** chip. `⌘/Ctrl+J` does the same while an issue is open, peeked or focused; on the inbox, or
with nothing focused, it opens an empty composer as before. Nothing starts until you press Enter there.

The brief is the prompt **Copy as a prompt for an agent** makes (title, status, priority, labels, link, description),
then the issue's latest three unresolved comments and the items linked to it, and its reference for the agent to open
with `workspace_item_get`. It is read as you, so it never holds more than you can see, and it is capped in size. The chat
remembers the issue as its origin and shows on the issue's **Linked** section as "worked in", with its state (running,
needs you, done) kept current while it works; its header links back to the issue. Several issues: the first is the
origin and the chat is linked to each of them. When it finishes, needs you or fails, you are told in your Inbox on the
issue ([Agent chats from an issue](/docs/cloud/tasks-notifications.md#agent-chats)).

### Convert to an agent task {#convert-to-an-agent-task}

**Convert to ▸ Agent task…** in the issue menu (or ⌘K) hands one or several issues to an agent in one step. Pick the
agent from the delegate list. If you have started an agent chat before, **Also start a chat in …** is on: it names where
your last chat ran. Confirm, and Tasks:

1. sets the agent as the delegate (one change; ⌘Z undoes it),
2. starts the chat with the issues' brief as its first message, where you last started one, with your last gear and
   mode (never a mode you did not choose), linked to the issues,
3. posts one comment on each issue, as you: "Handed to <agent>.", with a link to the chat.

If the chat cannot start, the delegate stays set and a message says why, with **Open Agents**. Without a previous chat,
or if your role cannot start agent chats, the dialog only sets the delegate and posts the comment. People who can only
read the issues don't get the menu entry, and ⌘K tells them they can't.

## Creating issues

Press `c` anywhere (or the + button). Pick the team from the chip at the top left, type a title, press Enter to move
to the description, and set properties with the chips below it. ⌘/Ctrl+Enter creates the issue; with **Create more**
on, the form stays open for the next one, keeping the properties and clearing the title and description. A new issue
starts in the view you are in: created from a team's Backlog it lands in the backlog, from My issues it is assigned
to you.

The paperclip next to **Create issue** attaches files: pick them, or drop or paste them onto the composer. They show as chips (click × to remove one) and upload to the new issue once it is created, up to the same 100 MB as on the issue page. If an upload fails the issue still exists, a toast names the file, and you can attach it again from the issue page. Files are not kept in drafts.

The expand button at the top right (or `v` instead of `c`) turns the dialog into a full-page composer with more room
for the description; press it again to shrink it back.

More chips set what Linear's composer does before the issue exists:

- **Milestone** shows once a project is set and lists that project's milestones.
- **Links** adds web addresses (and an optional title each); they become the issue's links when it is created.
- **Sub-issues** takes one title a line (a pasted list fills it). Each is made under the new issue with what a sub-issue
  inherits (below).
- **Repeat** makes a recurring issue instead of one issue: daily, weekly, every 2 weeks or monthly from today at 09:00
  in your time zone, or **Custom…**, the same chooser as the team's **Recurring issues** (weekdays, every few weeks, a
  day of the month, the time, time zone, start and end, with the next three dates), and the button reads **Create
  recurring issue**. Change it later under the team's **Recurring issues**. A recurring issue makes one issue each time, so the Sub-issues chip is off while Repeat is on.

Every chip has a key that works while you type (`⌥` is Option on a Mac): `⌥S` status, `⌥P` priority, `⌥A` assignee,
`⌥⇧A` agent, `⌥L` labels, `⌥⇧E` estimate, `⌥⇧P` project, `⌥⇧M` milestone, `⌥⇧C` cycle, `⌥⇧D` due date, `⌥⇧U` parent,
`⌥⇧L` links, `⌥⇧O` sub-issues, `⌥⇧R` repeat, `⌥C` template and `⌥⇧T` team (the full list is under
[Keyboard shortcuts](#keyboard-shortcuts) → New issue). `⌘/Ctrl+Shift+Enter` creates the issue and starts the next one
with the same properties, the parent included, so a run of sub-issues is quick.

**Paste a list.** Paste two or more lines (bullets `- ` or `* `, numbers `1.`, checkboxes `[ ]`, or plain lines) into an
empty title and the composer asks **Create 5 issues from this list?**: **Create 5 issues** makes one issue per line with
the chips' values, one after another, and one toast lists them with **Undo** (which archives them all); **Keep as text**
pastes the lines as one title. At most 50 lines at once; a longer list is pasted as text with a note of its length. A
paste into the description stays a paste.

**Sub-issues inherit** what Linear's do: a new sub-issue (`⌘/Ctrl+Shift+O`, Create related ▸ Sub-issue…, the Sub-issues
chip, a template's sub-issues) starts in the parent's team with its priority and project (and milestone); its cycle
only when the sub-issue starts in a started or unstarted status; its assignee only when you are the parent's assignee
or every existing sub-issue has the parent's assignee. Labels are never inherited.

**Create from a relation picker.** In Blocked by…, Blocking…, Related to…, Sub-issue of… (the parent picker), Parent
of… and Open a sub-issue, type a title that isn't there and the last row offers **New issue "…" that blocks ENG-12**
(worded per relation). Enter opens the composer with that title, and the relation is made when you create it.

The **Due date** chip opens the same date picker as `d` on an issue. Pick Today, Tomorrow, End of week (Friday) or
Next week (next Monday; on a Sunday, when that is tomorrow, the Monday after), choose a day in the calendar, or type it: `fri`, `tomorrow`, `in 3 days`, `2w`, `next mon`,
`dec 3`. A weekday on its own means the next one after today; `next mon` means Monday of next week. The **⋯** chip
holds the properties you set less often: cycle, parent issue and due date. A cycle or parent you set shows as its
own chip.

### Drafts

What you type in the composer is saved as you go: in this browser at once, and to your account a moment later, so a
draft follows you to another browser, a reload included. The links, sub-issue titles and repeat you set are kept with
it. If creating the issue fails, the draft is put back and the message has **Open draft**. Close the composer with Esc (or click outside it) and a half-written issue is
kept as a draft; press `c` again and it reopens where you left it. **Discard** in the composer's header throws it
away. **Drafts** under My issues (`/tasks/drafts`) lists every draft, newest first: click one to carry on, or the
bin to discard it. Drafts are private to you. Creating the issue deletes its draft. Text that looks like a secret
stays in this browser only.

Attachments in the composer are not available yet.

A link can prefill the form: `/tasks/new?team=ENG&title=Fix%20login&priority=high&assignee=me&labels=Bug`.

### Templates

A template is what a new issue starts with: a title, a description, labels, a priority, an assignee, an agent, a
status, a project, an estimate and a list of sub-issues. Each team keeps its own under Settings → the team →
**Templates** (`/tasks/settings/teams/ENG#templates`): **New template**, then edit or delete. A sub-team is offered its
parent teams' templates too, listed under the team's own.

**Workspace templates** (Settings → **Templates**, `/tasks/settings/templates`) are offered in every team. Owners and
admins make and edit them; everyone uses them. They take workspace labels only and no status, since labels and
statuses belong to one team (the API answers `400 team_property` naming the field).

A team has two defaults, both set from its Templates list: **Make default** is the template a fresh composer starts
from for the team's members, and **Default for others** is the one used when someone outside the team creates an
issue in it (a request from another team, an agent, an intake). Either may be the team's own template, a parent team's
or a workspace template. Issues created through the API by someone outside the team, without a `templateId`, start
from the second; `"templateId": null` asks for none.

Three ways to use one:

- **`⌥C` (Alt+C)**, or ⌘K's **Create issue from template…**, opens a template picker for the page's team: the team's
  templates, then its parent teams', then the workspace's, each under its own heading. Type to filter, Enter opens the
  composer with the template applied, Esc cancels. With no templates anywhere, the picker offers **Create a template**.
- **The Template chip** next to "New issue" in the composer (or `⌥C` there) opens the same picker; picking one fills
  the form (a title you already typed is kept) and shows how many sub-issues it brings. Pick "No template" to drop it.
  Moving the composer to another team keeps a workspace template and takes off a team template that team isn't offered,
  with its labels and status. An owner who left the workspace or an archived project is skipped, and a toast says so.
- **Apply a template to an issue that exists**: `⌘/Ctrl+Alt+Shift+T`, the issue menu's **Apply template…** or ⌘K. Only
  the issue's empty fields are filled: the title never changes, the template's description goes after the issue's
  under a rule, its labels are added, and the assignee, priority, project, estimate and agent are set only where the
  issue has none. That is one change, undone with `⌘/Ctrl+Z`. The template's sub-issues are then made under the issue
  and listed in a toast whose **Undo** archives them. A sub-issue takes only templates without sub-issues; the others
  are listed, greyed out, with the reason.

When you create an issue from a template, the template's sub-issues are made under it at once. Templates brought over
by the Linear importer are ordinary team templates and appear in the same picker.

## Archive

Archiving takes an issue out of every list, board and search without deleting it: its history, comments and links
stay. Archive the issue you're on or the selected ones with `⌘/Ctrl+Shift+Backspace`, the **Archive** button in the
selection bar, the archive button in an issue's header or **Archive or restore** in `⌘K`. An archived issue's page
says so and has **Restore**; `⌘/Ctrl+Z` undoes either.

**Archive** in the sidebar (`/tasks/archive`, `?team=ENG` for one team) lists archived issues, most recently changed
first, with a filter, a link to each and **Restore**.

A team can archive and close issues on its own, under Settings → the team → **Archive**:

- **Archive closed issues**: completed and canceled issues are archived 1, 3, 6, 9 or 12 months after they closed.
- **Close stale issues**: open issues (backlog, todo, in progress; not triage) that nobody has updated for that many
  months move to the team's Canceled state.

Both are off by default. A background job does the work every few minutes; each change shows in the issue's activity
as done by Venom Tasks, and notifies its subscribers as usual.

## On a phone {#phone}

Tasks is a web app, so a phone needs nothing but a browser. Install Venom to the home screen (Share → **Add to Home
Screen** on iPhone, **Install app** on Android) to get push notifications and two shortcuts on the app's icon:
**Tasks inbox** and **New issue**. Tapping a push opens the issue it is about.

On a screen narrower than a tablet:

- **The bar at the bottom** has Inbox (with the unread count), My issues, a **+** button that opens a new issue, Search
  (Tasks' `⌘K`) and Menu, which opens the sidebar: teams and their subteams, projects, views and settings. It sits
  above the workspace's app bar and hides while the keyboard is up. The top bar shows where you are.
- **Lists and the inbox** refresh when you pull down from the top.
- **Long-press** an issue in a list or on a board, or tap its **⋯**, to open the issue menu as a sheet from the bottom of
  the screen. Its property rows open the same pickers as the keys.
- **Select several issues.** Choose **Select** first in that menu (the issue joins the selection you already have), or tap
  **Select** at the top right of a list. The top bar becomes "3 selected", with **Done** at one end and **Select all** at
  the other; it selects every issue the list shows under its filter, not only the rows drawn, and then reads "All 240
  selected". Rows show a checkbox you can hit with a thumb and a tap toggles them instead of opening them. The bar at the
  bottom becomes **Status**, **Assignee**, **Priority**, **Labels** and **More**, which opens the issue menu for the
  selection (Delegate, Archive, Delete, Copy and the rest of what the computer's bulk bar does). Swipes are off while
  you select. **Done**, the browser's or Android's back button, or deselecting the last issue leaves select mode.
- **Pickers come up from the bottom.** Every property picker (status, assignee, labels, due date and the rest) opens as a
  sheet with a drag handle, the search field at the top, rows 48 px tall and the current value marked (a dash when only
  some of the selected issues have it). It is never taller than 85% of what the keyboard leaves, it sits above the
  keyboard, and swiping the handle down, tapping outside it or `Esc` on a hardware keyboard closes it. A long list, such
  as every person in a large organization, scrolls smoothly, filters as you type and has its first row ready for
  **Go**.
- **Swipe a list row** toward the end of the line (right, or left in a right-to-left language) to move the issue to its
  team's first completed state, and toward the start to snooze it. Each swipe shows **Undo** in its toast. Board cards
  don't swipe, because their columns scroll sideways. A swipe that starts at the very edge of the screen is left to the
  browser's back gesture, and a mouse never swipes.
- **In the inbox**, swipe a notification toward the start to delete it (with **Undo**) and toward the end to choose when
  it comes back (**Snooze**; a snoozed one is unsnoozed instead). Each row's **⋯** (or a long-press) has Open issue,
  Mark read or unread, Snooze and Delete. A tap opens the issue as its own page; back returns to the same row. Filter,
  Display and ⋯ in the inbox header open as sheets.
- **The issue page** has the main properties as a row of chips under the title: status, priority, assignee, labels,
  project and due date. Each opens its picker. **All properties** opens every property, linked notes and linked items in
  a sheet. Below the description, **Sub-issues**, **Relations**, **Customer requests**, **Pull requests**, **Resources**
  and **Activity** are sections with a header you tap to fold, showing how many they hold. Sub-issues and Activity start
  open and the others fold when they hold more than three; your choice is remembered for each section in this browser. A
  link to a comment (`#comment-…`) or to `#sub-issues` opens the section it points into.
- **A new issue** fills the screen, with the title focused, the property chips in one row you scroll sideways, and
  **Create issue** at the top so the keyboard doesn't cover it. Drafts are kept as on a computer.

Every control is at least 44 px tall on a touch screen, group headers and their **+** buttons included, and text fields
use 16 px text so the phone doesn't zoom in.
Nothing changes on a computer.

## Search {#search}

`/` opens the search page, `/tasks/search`, from anywhere in Tasks (typing in a field types the slash; `⌘/Ctrl+K` stays
the command menu, and on a phone the **Search** tab of the bottom bar opens the page). Type in the field, which has the
focus. Everything you set lives in the address, so a search can be shared and returned to: the words (`q`), the tab
(`tab=issues`), the sort (`sort=updated`), the layout (`layout=board`) and the filters, written as a list writes
them.

- **Tabs.** **All** shows the first ten issues, five projects and five documents, each with a link to its tab.
  **Issues**, **Projects** and **Documents** (notes you can read) list everything found.
- **What matches.** Issues match on title and description (not comments), by word stems: `login` finds "logging in".
  A phrase in quotes must match as written (`"login bug"`), `-word` leaves a word out, `ENG-12` finds that issue (an
  old identifier too) and `Enter` on an identifier alone opens it. Archived issues are searched too, last.
- **Order.** **Relevance** puts open work first (started and unstarted), then backlog, completed, canceled and archived,
  the better match first within each. **Recently updated** and **Recently created** order by date. The page lists at
  most 500 issues and says so when there are more: refine the search.
- **Filters.** On the **Issues** tab the same filter chips as a list ("Filter" and **Clear**) narrow the issues, and **Advanced filter…** opens the same and/or builder as a list, **Save
  view** (`⌥V`) saves the search as a view, and **Board** shows the results by status. `@` in the field offers teams,
  people and statuses and turns the one you pick into a chip.
- **Only what you may see.** A private team's issues, and a private sub-team's, never appear in results, counts or
  snippets for someone who is not in it. The set of issues is the one `tasks_issue_search` finds for the same words and
  filter, so a person and an agent see the same issues.
- **Before you type.** The page lists your ten **Recent searches** (**Clear** forgets them; they stay in this browser)
  and the ten issues you **Recently opened**.
- **Keys.** `↓` or `Enter` moves from the field into the results; `j`/`k` (or `↓`/`↑`) move, `Enter` opens, `Space`
  peeks, and `Esc` returns to the field (in an empty field it goes back). `/` on the page focuses the field.

## Where you are {#shell-bar}

From the medium screen width up a bar above the page shows breadcrumbs: **Engineering › Active**, **Projects ›
Atlas**, **Engineering › ENG-12 Fix login**. Each segment but the last is a link (a team's opens its overview); the
last carries the star that adds the page to **Favorites** and, for a team or an issue, a **⋯** with that item's menu.
A team you cannot see is never named. The bar is left out of Settings, which has its own navigation.

## The help menu {#help-menu}

The **?** at the sidebar's foot (or **Open help…** in the command menu, `g` then `h`) opens a menu: **Keyboard
shortcuts** (`?` and `⌘/Ctrl+/` still open the panel), **Workspace shortcuts**, **Tasks documentation** (this page) and
**Settings**.

## Customize the sidebar {#customize-sidebar}

**Customize sidebar…** in the workspace menu (the title at the sidebar's top; it cannot be hidden) opens a list of the
personal items (Inbox, My issues, Drafts, Favorites) and the workspace ones (Projects, Initiatives, Pulse, Insights,
Dashboards, Dependencies, Cycles, Views, Archive). Drag a row by its handle, press `Alt+↑` or `Alt+↓` on it, or use the
arrows to reorder. For each item choose **Always show**, **Show when it has a badge** (the Inbox and Drafts: it shows
only while there is something to count) or **Hide**; what is hidden, or has nothing to show, sits under **More**, one
click away. **Badges** chooses a count or a dot. It saves as you go, with your account, so it is the same in every
browser, and **Reset to default** puts everything back. Folded sections, folded teams and the width are unchanged.

## A team's overview {#team-overview}

`/tasks/team/{key}/overview` (`g` then `o`, or a team's crumb) shows the team: its icon and name, a description the
team's admins edit in place, a strip of open issues, issues in progress and the current cycle's progress, its
**Resources**, its members, and links to its pages (Issues, Active, Triage, Backlog, Cycles, Projects, Views,
Settings). Resources are links (`http` or `https`) and notes (`note:<id>`), at most 30, in sections the admins
name; they are also the `resources` of the team on the team in the API, and `tasks_team_update` sets them.

## The command menu

`⌘/Ctrl+K` opens the command menu. Type to find an issue by ID or title, go to any page, create an issue, or run any
action on the selected issues ("Change status", "Assign to me", "Copy git branch name"). Each action shows its key.
Inside Tasks `⌘/Ctrl+K` is this menu, not the [workspace search](/docs/cloud/workspace.md): that one is
`⌘/Ctrl+P`, the rail's Search button, or **Search everything** in this menu (and **Search everything for "…"** at
the end of the list once you type).

With issues focused or selected, their actions come first. Several issues get plural rows: **Copy the IDs**, **Copy
the branch names** (one per line), **Copy the pull request links**, **Delete the issues**, **Remove every subscriber**
(after a confirmation). One issue also gets **Copy the pull request link** and **Unlink a pull request…**, which lists
its linked pull requests (an open one asks first).

- **Values without the picker.** Type two letters or more and the menu also offers values directly, as breadcrumbs:
  "review" offers **Change status › In Review**, "urg" **Set priority › Urgent**, a person's name **Assign to › Grace
  Hopper**, a label's name **Add or remove label › Bug**, and projects, cycles and estimates the same way. A command's
  name lists its first values ("status"); a command's name and a value find that value ("status review"). `↵` applies
  it to the issues as one change, so `⌘/Ctrl+Z` undoes it. A check marks what the issues have already. On a list,
  "group assignee", "order priority" or "board" change the list's display (**Group by**, **Order by**, **Layout**).
- **Pickers in place.** Choosing **Change status…**, **Assign to…**, **Labels…**, **Add to project…** and the other
  pickers turns the same box into that picker, with the issues still named at the top. `Backspace` in the empty field,
  `←` or `Esc` goes back to the menu; a second `Esc` closes it. **Set due date…**, **Remind me…** and **Set
  milestone…** work the same way: type a date in words or pick a day in the calendar, pick a reminder time, or pick
  one of the project's milestones.
- **The page's own rows.** On a project's page the menu leads with that project's ⋯ menu: **Blocked by…** and
  **Blocking…** (its [dependencies](/docs/cloud/tasks-planning#project-dependencies)), **Write update**, **Update
  schedule…** and the copy rows.
- **Everything in Venom.** As you type, issues on screen answer at once; when fewer than eight match, the server's
  matches follow. Projects, notes, people, companies, deals and chats that match come after, under **Elsewhere in
  Venom**, two of each kind and eight in all. The last row, **Search everything for "…"**, opens the workspace search
  with what you typed. A pasted ID, `<kind>:<id>` reference or Venom link shows **Open** first. Nothing typed waits on
  these: they join the list below the rows you can already pick, and the highlighted row doesn't move.
- **An issue's actions.** `Alt+↵` on an issue in the results lists that issue's actions; `Esc` or `Backspace` goes back.
- **Quick look.** `→` on an issue in the results (with the cursor at the end of what you typed) shows it in the menu:
  status, priority, assignee, team and its description. `←` or `Esc` goes back to the results with your search kept;
  `↵` opens the issue.
- **Ask an agent.** Where your organisation has Agents, `Tab` with issues focused or selected opens a new agent chat
  with what you typed and the issues' brief (as [Start an agent chat](#start-an-agent-chat) writes it). Nothing starts
  until you send it.
- **Groups.** With nothing typed: the issues' actions, **Create** (an issue, or full screen), the page's team (copy its
  key or link, its settings), **Go to** (every page and the "Open a …" pickers, **Open a document…** included), **Display** (the open list's display
  options, layout, folding and Insights), **Settings** (Tasks, your preferences, notifications, teams, labels, members,
  import, export, GitHub) and **Help** (the shortcuts, open an issue by ID, these docs).

The footer shows the keys that apply to the highlighted row. The menu's rows are the UI kit's list rows: `↑`/`↓` wrap,
`Home`/`End` jump, `Page Up`/`Page Down` move a page, and a long list draws only the rows in view.

## Keyboard shortcuts

Press `?` (or `⌘/Ctrl+/`) for the shortcuts panel, beside the page. Search it by words ("copy" leaves the copy
actions), or by keys when the search looks like keys ("⌘⇧", "ctrl k", "g i"). Esc clears the search, a second Esc
closes the panel. The keyboard button beside the search (or `Tab` from an empty search, then `Enter`) finds a row by
its keys: press a chord or two keys ("g" then "i") and the panel records them without running them, `?` and `⌘/Ctrl+/`
included, and filters by them. Esc stops recording and keeps what was recorded; the next Esc clears it, the one after
closes the panel. **Workspace shortcuts** at the foot of the panel opens the workspace's own sheet. **This page** shows only the keys that work where you are, that page's own sections first; **All**
lists everything and dims the rest with where they work ("on the timeline"). The panel remembers your choice in this
browser. A row marked "opens a list" asks you to pick; "acts at once" doesn't.

Keys never fire while you are typing in a field. "`g` then `i`" means press G, then I within a second. ⌘ is
Command on a Mac; Ctrl elsewhere. The same letter can mean different things on different pages: `m` zooms the
timeline to months there, while `m` then `b` marks an issue as blocked on a list. The workspace's own keys (⌘P, ⌘J,
switching apps) are on the workspace's sheet: the help button at the foot of the app rail.

### General

| Keys | Does |
|---|---|
| `⌘/Ctrl+K` | Command menu |
| `/` | Search |
| `?`, `⌘/Ctrl+/` | Keyboard shortcuts |
| `g` then `h` | Open the help menu |
| `Escape` | Back: close, clear the selection, leave the issue |
| `⌘/Ctrl+Z` | Undo the last change |
| `c` | Create an issue |
| `v` | Create an issue, full screen |
| `Alt+c` | Create an issue from a template |
| `⌘/Ctrl+Alt+O` | Open the link from the last toast |
| `⌘/Ctrl+Alt+X` | Dismiss all toasts |

### Navigation

**Jumps and the workspace.** Inside Tasks, `g` then `n`, `g` then `d` and `g` then `x` go to Initiatives, Drafts and the
Archive. The workspace uses the same letters for Notes, Funnel and Experiments, so in Tasks those three
apps are `⌘/Ctrl+1` to `⌘/Ctrl+9` (the app's place on the rail) or `⌘/Ctrl+P`; everywhere else the workspace's letters
are unchanged. `g` then `g` still opens Agents through the workspace, and `g` then `j` does the same from Tasks (only
where Agents is on for you). `⌘/Ctrl+Shift+1` to `9` open the Issues of the Nth team in the sidebar, subteams counted
as shown (on a Mac, macOS keeps ⌘⇧3, 4 and 5 for screenshots: use `o` then `t` for those teams). Two-key sequences cancel with Esc or after a second; nothing fires while you type in a field.

**Open pickers.** `o` then `p`, `c`, `v`, `t`, `u`, `f`, `n`, `a` or `d` opens a list of projects, cycles, views, teams,
people, favorites, initiatives, agents or documents to type in. Enter (or a digit while the box is empty) opens the one you pick: a project, cycle
or view page, a team's Issues, the current team's Issues filtered to that person, a favorite's page, an initiative. Agents
list the ones working now first ("working on ENG-12"), then by name; Enter shows the issues delegated to that agent
(in the current team, else My issues), and `Alt+Enter` opens the Agents app where you have it. Documents are notes:
the ones attached to the project you are looking at (or the open issue's project) come first, then notes you opened
lately, then a search of every note you can read as you type. Enter opens the note in Notes and `Alt+Enter` copies its
reference (`note:<id>`), which you can paste into any text to get the note's chip. Cycles
list the current one first, then upcoming, then the last three past. Each list says what is missing when it is empty
("No cycles. Turn cycles on in team settings."). `⌘/Ctrl+K` lists the same destinations and pickers under Go to.

**Toasts.** A toast that announces something you made or copied ("Created ENG-12") carries a link: `⌘/Ctrl+Alt+O`
opens the newest one on screen, `⌘/Ctrl+Alt+X` clears them all.

| Keys | Does |
|---|---|
| `g` then `i` | Go to Inbox |
| `g` then `m` | Go to My issues |
| `g` then `t` | Go to Triage |
| `g` then `e` | Go to all issues |
| `g` then `a` | Go to active issues |
| `g` then `b` | Go to the backlog |
| `g` then `v` | Go to the current cycle |
| `g` then `c` | Go to Cycles |
| `g` then `p` | Go to Projects |
| `g` then `w` | Go to the upcoming cycle |
| `g` then `Shift+V`, `g` then `u` | Go to Views |
| `g` then `s` | Go to Settings |
| `g` then `o` | Go to the team's overview |
| `g` then `Shift+T` | Open the team's settings |
| `g` then `d` | Go to Drafts |
| `g` then `x` | Go to the Archive |
| `g` then `n` | Go to Initiatives |
| `g` then `r` | Go to Releases |
| `g` then `-` | Go to Dashboards |
| `g` then `j` | Go to Agents |
| `⌘/Ctrl+Shift+1` | Go to team 1 |
| `⌘/Ctrl+Shift+2` | Go to team 2 |
| `⌘/Ctrl+Shift+3` | Go to team 3 |
| `⌘/Ctrl+Shift+4` | Go to team 4 |
| `⌘/Ctrl+Shift+5` | Go to team 5 |
| `⌘/Ctrl+Shift+6` | Go to team 6 |
| `⌘/Ctrl+Shift+7` | Go to team 7 |
| `⌘/Ctrl+Shift+8` | Go to team 8 |
| `⌘/Ctrl+Shift+9` | Go to team 9 |
| `o` then `i` | Open an issue by ID |
| `o` then `p` | Open a project… |
| `o` then `c` | Open a cycle… |
| `o` then `v` | Open a view… |
| `o` then `t` | Open a team… |
| `o` then `u` | Open a person's issues… |
| `o` then `f` | Open a favorite… |
| `o` then `n` | Open an initiative… |
| `o` then `a` | Open an agent's issues… |
| `o` then `d` | Open a document… |
| `⌘/Ctrl+Shift+ArrowUp` | Open the parent issue |
| `⌘/Ctrl+Shift+ArrowDown` | Open a sub-issue |
| `j` | Next issue in the list you came from |
| `k` | Previous issue in the list you came from |
| `[` | Show or hide the sidebar |
| `]` | Show or hide the issue's properties |
| `Alt+f` | Add to or remove from favorites |

### Issues

| Keys | Does |
|---|---|
| `s` | Change status |
| `p` | Set priority |
| `a` | Assign to… |
| `i` | Assign to me |
| `Shift+A` | Delegate to an agent… |
| `l` | Add or remove labels |
| `Shift+E` | Set estimate |
| `Shift+D` | Set due date |
| `⌘/Ctrl+Shift+D` | Remove due date |
| `Shift+P` | Add to project |
| `Shift+C` | Add to cycle |
| `⌘/Ctrl+Shift+P` | Set parent issue |
| `⌘/Ctrl+Shift+O` | Create a sub-issue |
| `m` then `b` | Mark as blocked by… |
| `m` then `x` | Mark as blocking… |
| `m` then `r` | Relate to… |
| `m` then `m` | Mark as duplicate of… |
| `Shift+M` | Set milestone |
| `⌘/Ctrl+Alt+L` | Add a link |
| `⌘/Ctrl+Shift+I` | Edit the description |
| `Shift+R` | Rename |
| `⌘/Ctrl+Shift+M` | Move to another team |
| `Shift+S` | Subscribe or unsubscribe |
| `Shift+H` | Remind me about it… |
| `⌘/Ctrl+Shift+S` | Manage subscribers |
| `⌘/Ctrl+Backspace`, `⌘/Ctrl+Delete` | Delete |
| `⌘/Ctrl+Shift+Backspace` | Archive or restore |
| `#` | Restore from the archive |
| `⌘/Ctrl+.` | Copy the ID |
| `⌘/Ctrl+Shift+.` | Copy a git branch name |
| `⌘/Ctrl+Shift+,` | Copy the link |
| `⌘/Ctrl+Alt+P` | Copy as a prompt for an agent |
| `⌘/Ctrl+Alt+Shift+P` | Start an agent chat |
| `⌘/Ctrl+Shift+'` | Copy the title |
| `⌘/Ctrl+Alt+Shift+T` | Apply a template… |
| `⌘/Ctrl+Alt+C` | Copy as Markdown, with comments and sub-issues |

### New issue

In the New issue dialog. They work while you type the title or the description (`⌥` is Option on a Mac), never while an input method is composing.

| Keys | Does |
|---|---|
| `⌘/Ctrl+Enter` | Create the issue |
| `⌘/Ctrl+Shift+Enter` | Create it and start another with the same properties |
| `Alt+c` | Choose a template |
| `Alt+Shift+T` | Change the team |
| `Alt+s` | Status |
| `Alt+p` | Priority |
| `Alt+a` | Assignee |
| `Alt+Shift+A` | Agent |
| `Alt+l` | Labels |
| `Alt+Shift+E` | Estimate |
| `Alt+Shift+P` | Project |
| `Alt+Shift+M` | Milestone |
| `Alt+Shift+C` | Cycle |
| `Alt+Shift+D` | Due date |
| `Alt+Shift+U` | Parent issue |
| `Alt+Shift+L` | Links |
| `Alt+Shift+O` | Sub-issues |
| `Alt+Shift+R` | Repeat on a schedule |

### Projects

| Keys | Does |
|---|---|
| `j`, `ArrowDown` | Next project |
| `k`, `ArrowUp` | Previous project |
| `Enter`, `o` | Open the project |
| `n` then `p` | New project |
| `p` then `s` | Change the project's status |
| `p` then `a` | Change the project's lead |
| `⌘/Ctrl+Shift+U` | Write a project update |
| `p` then `n` | Add the project to an initiative… |
| `p` then `m` | Change the project's members |
| `p` then `t` | Change the project's teams |
| `p` then `l` | Change the project's labels |
| `⌘/Ctrl+Alt+S` | Set the project's start date |
| `⌘/Ctrl+Alt+D` | Set the project's target date |
| `⌘/Ctrl+U` | Open the project's updates |
| `⌘/Ctrl+.` | Copy the project's ID |
| `⌘/Ctrl+Shift+,` | Copy the project's link |
| `⌘/Ctrl+Shift+'` | Copy the project's name |
| `x` | Select the project (Shift+click: a range) |
| `⌘/Ctrl+A` | Select every project shown |
| `⌘/Ctrl+B` | Switch the projects between list and board |
| `Shift+V` | Projects display options |
| `f` | Filter the projects |
| `Shift+F` | Remove the last project filter |
| `Alt+Shift+F` | Clear the project filters |
| `Shift+H` | Remind me about the project… |

The list keys, `n` then `p`, the copy keys, selection, layout, display and filter keys work on the Projects list (the
filter keys on the timeline too); `p` then `s`, `p` then `a`, `⌘/Ctrl+Shift+U` and `Shift+H` on a project's page; the
other property keys on both, acting on the focused or selected projects. See
[Planning](/docs/cloud/tasks-planning.md#projects-list).

### Initiatives

| Keys | Does |
|---|---|
| `j`, `ArrowDown` | Next initiative |
| `k`, `ArrowUp` | Previous initiative |
| `Enter`, `o` | Open the initiative |
| `ArrowLeft`, `ArrowRight` | Fold or unfold the sub-initiatives |
| `n` then `i` | New initiative |
| `n` then `s` | Add a sub-initiative… |
| `s` | Change the initiative's status |
| `n` then `o` | Change the initiative's owner |
| `⌘/Ctrl+Alt+D` | Set the initiative's target date |
| `Shift+H` | Remind me about the initiative… |
| `⌘/Ctrl+U` | Open the initiative's updates |
| `⌘/Ctrl+Shift+U` | Write an initiative update |
| `⌘/Ctrl+.` | Copy the initiative's ID |
| `⌘/Ctrl+Shift+,` | Copy the initiative's link |
| `⌘/Ctrl+Shift+'` | Copy the initiative's name |

The list keys, `n` then `i` and the fold keys work on the Initiatives page; the property keys and the copy keys on the
focused row there and on an initiative's own page; `n` then `s` and `⌘/Ctrl+Shift+U` on the page only. `Alt+F` stars
the open initiative like any page. See [Initiatives](/docs/cloud/tasks-initiatives.md).

### Cycles

| Keys | Does |
|---|---|
| `⌘/Ctrl+I` | Show or hide the cycle's details |

On a cycle's page (and the current cycle on the Cycles page), the details sidebar shows progress, the burn-up with
its target and projection, capacity, and breakdowns by assignee, label and project; see
[Planning](/docs/cloud/tasks-planning.md#cycle-details).

### List and board

| Keys | Does |
|---|---|
| `j`, `ArrowDown` | Next issue |
| `k`, `ArrowUp` | Previous issue |
| `x` | Select the issue (Shift+click: a range) |
| `Shift+click` | Select a range |
| `⌘/Ctrl+click` | Add to the selection |
| `⌘/Ctrl+A` | Select all |
| `Enter` | Open the issue |
| `Space` | Peek at the issue beside the list |
| `⌘/Ctrl+B` | Switch between list and board |
| `t` | Fold the row's sub-issues or the group |
| `Alt+t` | Fold or unfold every group |
| `→` | Show the issue's sub-issues under it |
| `←` | Hide the sub-issues (or go to the parent) |
| `Alt+ArrowUp` | Move the issue up (manual order) |
| `Alt+ArrowDown` | Move the issue down (manual order) |
| `Alt+Shift+ArrowUp` | Move the issue to the top of its group (manual order) |
| `Alt+Shift+ArrowDown` | Move the issue to the bottom of its group (manual order) |
| `⌘/Ctrl+Alt+A` | Select every issue in the group |
| `←` (board) | Focus the card in the column to the left |
| `→` (board) | Focus the card in the column to the right |
| `⌘/Ctrl+ArrowLeft` | Move the card to the column on the left |
| `⌘/Ctrl+ArrowRight` | Move the card to the column on the right |
| `⌘/Ctrl+Alt+ArrowUp` | Move the card to the swimlane above |
| `⌘/Ctrl+Alt+ArrowDown` | Move the card to the swimlane below |
| `drag` | Drag a row to reorder it (manual order) |
| `drag` | Drag a card to another column |
| `Shift+V` | Display options |
| `⌘/Ctrl+Shift+I`, `]` | Show or hide Insights beside the list |
| `⌘/Ctrl+Shift+B` | Show the breakdown of the list |
| `⌘/Ctrl+F` | Find in this list |

`⌘/Ctrl+F` on a list, a board or a saved view's list puts the cursor in the search box above it with its text selected, so you type over the last search; pressing it again while you are in the box opens the browser's own find. `Esc` in the box clears it, a second `Esc` leaves it. In an issue, the editor or a dialog the key is the browser's. The Inbox has its own `⌘/Ctrl+F`.

`]` shows or hides Insights on a list, a board, a saved view and a cycle (on a project it switches to the Insights
tab and back); on an issue page it still shows or hides the issue's properties. `⌘/Ctrl+Shift+I` does the same on
those pages, but on an issue page and in the peek it edits the description. In Chrome and Edge on Windows and Linux, `Ctrl+Shift+I` opens the browser's developer tools
before the page hears it: use `]` there. See [Insights](/docs/cloud/tasks-insights.md#the-dock).

### Timeline

| Keys | Does |
|---|---|
| `w` | Zoom to weeks |
| `m` | Zoom to months |
| `q` | Zoom to quarters |
| `y` | Zoom to years |
| `=` | Zoom in |
| `-` | Zoom out |
| `Mod+scroll` | Zoom around the pointer |
| `.` | Go to today |
| `j`, `ArrowDown` | Next project |
| `k`, `ArrowUp` | Previous project |
| `→` | Next project or milestone |
| `←` | Previous project or milestone |
| `Alt+←` | Move the project or milestone a day earlier |
| `Alt+→` | Move the project or milestone a day later |
| `Alt+Shift+←` | Move the project or milestone a week earlier |
| `Alt+Shift+→` | Move the project or milestone a week later |
| `Enter` | Open the project |
| `x` | Select the project or milestone |
| `Escape` | Clear the selection |
| `{` | Show or hide the project list |
| `t` | Fold the focused project's group |
| `Backspace` | Remove the selected dependency line |
| `drag` | Drag a bar to move the project and bump the planned projects it blocks; drag an end to change its dates |
| `Mod+drag` | Move the project alone, leaving the projects it blocks |
| `Shift+drag` | Move the project and every project it blocks by the same days |
| `drag ○` | Drag from the circle at a bar's end to another bar to add a dependency |
| right-click | Right-click a row to add a milestone on that day |

### Comments

| Keys | Does |
|---|---|
| `Ctrl+M` | Write a comment |
| `r` | Reply to the last comment |

### Inbox

The header has **Inbox**, **Snoozed** and **Reminders** tabs, a search button and three menus.

- **Filter** narrows by type (assigned, mentioned, comments, status changes, from agents, reminders, due dates, links
  between issues, SLA, from Tasks itself), project, priority, status, team and who. Each value shows how many of the loaded
  notifications it covers; values with none sit under "N more with none". Your filters, display and Important rules are kept
  in this browser.
- **Display** shows or hides read and snoozed items, puts unread first, groups by issue or project (each group shows its
  unread count; `j` and `k` walk across groups), orders newest or oldest first, and turns on the **Important** tab.
- **⋯** marks everything read, deletes all read, **Delete completed** (the notifications about completed or canceled
  issues) or deletes all, each after you confirm.
- **Search** (`⌘F` or `Ctrl+F` in the inbox) filters by issue ID, title, what happened, who, team, project or priority,
  ignoring case and accents. `Esc` clears it, a second `Esc` leaves the field, and `⌘F` pressed again in the field opens the
  browser's own find. A search reads older pages too, up to 500 notifications; **Load older** fetches more by hand.
- **Important** splits the list into **Important** and **Everything else** by rules, never by a model. By default a mention,
  an assignment, an SLA notice, a reminder, or anything on an Urgent or High issue is important; **Display → What is
  important** changes the types and the minimum priority. While it is on, the inbox badge in the sidebar and the phone bar
  counts only the important unread ones. It is off until you turn it on.
- **Row menu**: right-click a row (long-press on a phone, or its ⋯) for Open, Mark read or unread, Snooze, Delete,
  Favorite, Copy (ID, link, title, link to the comment), Status, Assignee, Priority and Unsubscribe from the issue; each
  line shows its key.
- **Selecting**: `x` or `⌘/Ctrl`-click selects a notification, `Shift`-click a range. A bar shows the count with Mark
  read, Snooze, Delete and Clear; `u`, `h` and delete act on all of them. `Esc` clears the selection.

Deleting one notification (or a selection) offers **Undo**. After any action the next notification takes focus, so you can
keep pressing keys. Snooze offers 1 hour, This evening, Tomorrow (9:00), Next week (Monday 9:00) or a date; the **Snoozed**
tab lists what is waiting, each with Unsnooze. No key fires while you type in a field or compose text.

| Keys | Does |
|---|---|
| `u` | Mark read or unread |
| `Alt+u` | Mark all read |
| `e`, `Backspace`, `Delete` | Delete the notification |
| `Shift+Backspace` | Delete all read notifications |
| `⌘F` or `Ctrl+F` | Search the inbox |
| `x` | Select the issue (Shift+click: a range) |
| `s`, `a`, `p` | Change the status, assignee or priority of the notification's issue |
| `Shift+S` | Subscribe or unsubscribe from the notification's issue |
| `Alt+f` | Add the notification's issue to or remove it from favorites |
| `h` | Snooze until tomorrow 9:00 |

### Triage

| Keys | Does |
|---|---|
| `1` | Accept into the team |
| `2` | Decline (cancel) |
| `3` | Mark as duplicate of… |
| `h` | Snooze |

A team's [triage rules](/docs/cloud/tasks-triage-rules.md) route issues as they arrive (team, status, assignee, agent, labels,
priority, project, cycle); the issue's activity says which rule did what. A team can also put people on
[triage duty](/docs/cloud/tasks-settings.md#automations) (notified of each new issue, or assigned in turn) and ask for a priority
before accepting.

`1` and `2` act at once; their toast has **Add a comment**, which opens a small box to post a note on the issues.
**Accept with comment…** and **Decline with comment…** (in `⌘/Ctrl+K`, and as buttons on a triage issue's page) open
that box first and send the decision and the note together. Accepting also offers the status to land in (the team's
default first) and the priority. When the team asks for a priority and the issue has none, `1` opens this box with the
priority to pick; picking one and confirming accepts. Over MCP, `tasks_issue_triage` takes `comment` and `priority`.

`h` opens a picker with 1 hour, Tomorrow (9:00), Next week, or a date you type (`2026-12-01`, 9:00 that day). A snoozed issue leaves the Triage list and its count until the time comes (it works the same way in [My issues](#plan-today)). **Show snoozed** (under the tabs) lists
them again, each with a clock, and `h` on one offers **Unsnooze**. Accepting or declining a snoozed issue ends the
snooze. When the time comes the issue is back in Triage and its assignee (or its creator, when nobody is assigned)
gets a **Snooze ended** item in the Inbox. Over MCP, `tasks_issue_update` takes `snooze_until`; the API takes
`snoozedUntil` on `PATCH /tasks/api/issues/{id}` (an ISO time ahead, or `null` to wake it now).

### Filters

| Keys | Does |
|---|---|
| `f` | Add a filter |
| `Shift+F` | Remove the last filter |
| `Alt+Shift+F` | Clear all filters |

### Insights

While focus is inside the Insights panel, each key opens one control's list (type to filter it, or press a number):

| Keys | Does |
|---|---|
| `m` | Pick what to measure |
| `s` | Pick the slice (the bars or the time axis) |
| `g` | Pick the segment (the colours) |
| `c` | Pick the chart type |
| `d` | Pick the date the issues are counted by |
| `r` | Pick the time range |
| `Shift+C` | Copy the chart as an image |

On a focused chart, `←`/`→` (or `↑`/`↓` on bars by field) move between bars, the other pair between a bar's
segments, `Enter` filters the list to it, and `Esc` leaves the chart. `Esc` in the panel leaves full screen, then
closes it.

### Views

| Keys | Does |
|---|---|
| `Alt+V` | Save the current filters as a view |

It works on a filtered issue list and on the projects list (a project view); see [Views](/docs/cloud/tasks-planning.md#views).

### Editor and markdown

The description and comment editor is the one from Venom Notes, with its keys (bold, headings, moving blocks) and the markdown you
type (`# `, `- `, `[] `). The panel lists them under Editor and Markdown; see [Editing in Notes](/docs/cloud/globe-editing.md).
Linear's editor keys work where they don't clash with Venom's: `⌘/Ctrl+Shift+7` checklist, `8` bulleted list, `9`
numbered list (again on such a line: back to text), `⌘/Ctrl+Enter` in a to-do checks it, `⌘/Ctrl+Shift+Enter` checks
it with the to-dos inside it, `>>> ` a collapsible section, `> ` a quote, `___ ` a divider, `|--` a table, `_text_`
italic, `~~text~~` strikethrough, `:name:` an emoji. Inside an editor these keys format text; `⌘/Ctrl+Shift+1…9` jump to
a team only outside it.

> [!NOTE]
> **If you come from Linear.** Three keys keep Venom's meaning. In notes, `> ` and a space makes a toggle
> (`>>> ` gives a collapsible section everywhere, `" ` a quote). In Notes, `⌘/Ctrl+Shift+Enter` on a line that is not
> a to-do makes a task from it, and in the New issue form it still creates the issue and starts another. Esc leaves
> the editor rather than closing anything else. `⌘/Ctrl+Shift+\` shows or hides the app rail rather than making a code
> block (type ` ``` ` instead), and `⌘/Ctrl+Shift+U` writes a project or initiative update rather than attaching a
> file.

### Favorites {#favorites}

Star an issue (`Alt+F` on the focused or open issue), a project, a cycle, a saved view or a team (the ☆ beside its
title, or on the team's row in the sidebar). Starred items sit in **Favorites** at the top of your sidebar, only for
you, with their live title (an issue shows its state). Drag an entry to reorder it, or hover it and click the star to
remove it. The API is `GET`, `POST /tasks/api/favorites` and `PATCH`, `DELETE /tasks/api/favorites/{id}`
(`PATCH {beforeId}` moves one before another, `null` to the end).
