Provided by: task_2.0.0.release-0ubuntu2_i386 bug


       task - A command line todo manager.


       task <filter> <command> [ <mods> | <args> ]
       task --version


       Taskwarrior is a command line todo list manager. It maintains a list of
       tasks that you want to do, allowing you to  add/remove,  and  otherwise
       manipulate  them.  Taskwarrior has a rich set of subcommands that allow
       you to do various things with it.

       At the core, taskwarrior is a list processing program. You add text and
       additional  related  parameters and redisplay the information in a nice
       way.  It turns into a todo list program when  you  add  due  dates  and
       recurrence.  It  turns into an organized todo list program when you add
       priorities,  tags  (one  word  descriptors),   project   groups,   etc.
       Taskwarrior  turns into an organized to do list program when you modify
       the configuration file to have the output displayed the way you want to
       see it.


       The  <filter>  consists  of  zero  or  more search criteria that select
       tasks.  For example, to list all tasks belonging to the 'Home' project:

         task project:Home list

       You can specify multiple filter terms, each of which  further  restrict
       the result:

         task project:Home +weekend garden list

       This  example  applies three filters: the 'Home' project, the 'weekend'
       tag, and the description or  annotations  must  contain  the  character
       sequence  'garden'.  In this example, 'garden' is translated internally


       as  a  convenient  shortcut.   The  'contains'  here  is  an  attribute
       modifier,  which  is  used  to  exert more control over the filter than
       simply absence or presence.  See 'ATTRIBUTE MODIFIERS' for  a  complete
       list of modifiers.

       Note  that  a  filter  may  have zero terms, which means that all tasks
       apply to the command.  This can be dangerous, and this special case  is
       confirmed, and cannot be overridden.  For example, this command:

         task modify +work
         This command has no filter, and will modify all tasks.  Are you sure?

       will add the 'work' tag to all tasks, but only after confirmation.

       More filter examples:

         task                                      <command> <mods>
         task 28                                   <command> <mods>
         task +weekend                             <command> <mods>
         task project:Home due.before:today        <command> <mods>
         task ebeeab00-ccf8-464b-8b58-f7f2d606edfb <command> <mods>

       By  default  filter  elements  are  combined  with  an  implicit  'and'
       operator, but 'or' and 'xor' may also be used, provided parentheses are

         task '( /[Cc]at|[Dd]og/ or /[0-9]+/ )'      <command> <mods>

       The parentheses isolate the  logical  term  from  any  default  command
       filter  or  implicit  report  filter  which  would  be combined with an
       implicit 'and'.

       A filter may target specific  tasks  using  ID  or  UUID  numbers.   To
       specify multiple tasks use one of these forms:

         task 1,2,3                                    delete
         task 1-3                                      info
         task 1,2-5,19                                 modify pri:H
         task 4-7 ebeeab00-ccf8-464b-8b58-f7f2d606edfb info


       The  <mods>  consist  of  zero or more changes to apply to the selected
       tasks, such as:

         task <filter> <command> project:Home
         task <filter> <command> +weekend +garden due:tomorrow
         task <filter> <command> Description/annotation text
         task <filter> <command> /from/to/


       Taskwarrior supports different  kinds  of  commands.   There  are  read
       commands,  write  commands,  miscellaneous  commands  and script helper
       commands.  Read commands do not allow  modification  of  tasks.   Write
       commands can alter almost any aspect of a task.  Script helper commands
       are provided to help you  write  add-on  scripts,  for  example,  shell


       Reports  are  read  subcommands.  There  are  several reports currently
       predefined in taskwarrior.  The  output  and  sort  behavior  of  these
       reports  can  be configured in the configuration file. See also the man
       page taskrc(5).  There are also other read  subcommands  that  are  not

       task --version
              This  is  the  only  conventional  command  line  argument  that
              Taskwarrior supports, and is  intended  for  add-on  scripts  to
              verify  the  version  number of an installed Taskwarrior without
              invoking the mechanisms that create default files.

       task <filter>
              With no command specified, the default command is run,  and  the
              filter applied.

       task <filter> active
              Shows  all  tasks  matching  the filter that are started but not

       task <filter> all
              Shows all  tasks  matching  the  filter,  including  parents  of
              recurring tasks.

       task <filter> blocked
              Shows  all  tasks matching the filter, that have dependencies on
              other tasks.

       task <filter> burndown.daily
              Shows a graphical burndown chart, by day.  Note that  'burndown'
              is an alias to the 'burndown.daily' report.

       task <filter> burndown.weekly
              Shows a graphical burndown chart, by week.

       task <filter> burndown.monthly
              Shows a graphical burndown chart, by month.

       task calendar [due|<month> <year>|<year>] [y]
              Shows  a  monthly  calendar  with  due  tasks marked.  Shows one
              horizontal line of months.  If the  'y'  argument  is  provided,
              will  show  at  least one complete year.  If a year is provided,
              such as '2012', then that full year is shown.  If both  a  month
              and  a  year  are specified ('6 2012') then the months displayed
              begin at the specified month and year.  If the 'due' argument is
              provided, will show the starting month of the earliest due task.

       task colors [sample | legend]
              Displays  all  possible  colors,  a  named  sample,  or a legend
              containing all currently defined colors.

       task columns
              Displays all supported columns and  formatting  styles.   Useful
              when creating custom reports.

       task <filter> completed
              Shows all tasks matching the filter that are completed.

       task <filter> count
              Displays only a count of tasks matching the filter.

       task <filter> export
              Exports  all tasks in the JSON format.  Redirect the output to a
              file, if you wish to save it, or pipe it to another  command  or
              script  to  convert  it  to  another  format.  The standard task
              release comes with  a  few  example  scripts,  such  as  export-

       task <filter> ghistory.annual
              Shows a graphical report of task status by year.

       task <filter> ghistory.monthly
              Shows  a  graphical  report  of task status by month.  Note that
              'ghistory' is an alias to 'ghistory.monthly'.

       task help
              Shows the long usage text.

       task <filter> history.annual
              Shows a report of task history by year.

       task <filter> history.monthly
              Shows a report of task history by month.  Note that 'history' is
              an alias to 'history.monthly'.

       task <filter> ids
              Applies  the filter then extracts only the task IDs and presents
              them as a range, for example: 1-4,12.  This is useful  as  input
              to a task command, to achieve this:

                   task $(task project:Home ids) modify priority:H

              This  example  first  gets  the IDs for the project:Home filter,
              then sets the priority to H for each of those tasks.   This  can
              also be achieved directly:

                task project:Home modify priority:H

              This command is mainly of use to external scripts.

       task <filter> uuids
              Applies  the  filter  then  extracts  only  the  task  UUIDs and
              presents them as a comma-separated  list.   This  is  useful  as
              input to a task command, to achieve this:

                   task  $(task  project:Home  status:completed  uuids) modify

              This example first gets  the  UUIDs  for  the  project:Home  and
              status:completed  filter, then makes each of those tasks pending

              This command is mainly of use to external scripts.

       task <filter> information
              Shows all data and metadata for the specified  tasks.   This  is
              the  only  means  of  displaying  all  aspects  of a given task,
              including the change history.

       task <filter> list
              Provides a standard listing of tasks matching the filter.

       task <filter> long
              Provides the most detailed listing of tasks matching the filter.

       task <filter> ls
              Provides a short listing of tasks matching the filter.

       task <filter> minimal
              Provides a minimal listing of tasks matching the filter.

       task <filter> newest
              Shows the newest tasks matching the filter.

       task <filter> next
              Shows a page of the most urgent tasks, sorted by urgency,  which
              is a calculated value.

       task <filter> oldest
              Shows the oldest tasks matching the filter.

       task <filter> overdue
              Shows  all  incomplete tasks matching the filter that are beyond
              their due date.

       task <filter> projects
              Lists all project names  that  are  currently  used  by  pending
              tasks, and the number of tasks for each.

       task <filter> recurring
              Shows all recurring tasks matching the filter.

       task <filter> unblocked
              Shows  all  tasks  that  do  not have dependencies, matching the

       task <filter> waiting
              Shows all waiting tasks matching the filter.


       task add <mods>
              Adds a new pending task to the task list.

       task <filter> annotate <mods>
              Adds an annotation to an existing task.

       task <filter> append <mods>
              Appends description text to an existing task.

       task <filter> delete <mods>
              Deletes the specified task from task list.

       task <filter> denotate <mods>
              Deletes an annotation for the specified task.  If  the  provided
              description  matches  an  annotation  exactly, the corresponding
              annotation is  deleted.  If  the  provided  description  matches
              annotations  partly,  the  first  partly  matched  annotation is

       task <filter> done <mods>
              Marks the specified task as done.

       task <filter> duplicate <mods>
              Duplicates the specified task and allows modifications.

       task <filter> edit
              Launches a text editor to let you modify all aspects of  a  task
              directly.   In  general,  this  is not the recommended method of
              modifying tasks, but is provided for exceptional  circumstances.
              Use carefully.

       task import <file> [<file> ...]
              Imports  tasks  in  the  JSON format.  The standard task release
              comes with a few example scripts, such as

       task log <mods>
              Adds a new task that is already completed, to the task list.

       task merge <URL>
              Merges two task databases by comparing  the  modifications  that
              are  stored  in  the files. The location of the second
     file must be passed on as argument. URL may  have  the
              following syntaxes:





              You  can  set  aliases  for frequently used URLs in the .taskrc.
              Further documentation can be found in task-sync(5) man page.

       task <filter> modify <mods>
              Modifies the existing task with provided information.

       task <filter> prepend <mods>
              Prepends description text to an existing task.

       task pull <URL>
              Overwrites the task database with those files found at the  URL.
              (See 'merge' command for valid URL syntax.)

       task push <URL>
              Pushes  the  task  database  to  a  remote  another location for
              distributing the  changes  made  by  the  merge  command.   (See
              'merge' command for valid URL syntax.)

       task <filter> start <mods>
              Marks the specified tasks as started.

       task <filter> stop <mods>
              Removes the start time from the specified task.


       Miscellaneous  subcommands  either accept no command line arguments, or
       accept non-standard arguments.

       task config [name [value | '']]
              Add, modify and remove  settings  directly  in  the  taskwarrior
              configuration.   This command either modifies the 'name' setting
              with a new value of  'value',  or  adds  a  new  entry  that  is
              equivalent to 'name=value':

                  task config name value

              This  command  sets  a  blank  value.   This  has  the effect of
              suppressing any default value:

                  task config name ''

              Finally, this command removes  any  'name=...'  entry  from  the
              .taskrc file:

                  task config name

       task diagnostics
              Shows  diagnostic information, of the kind needed when reporting
              a problem.  When you  report  a  bug,  it  is  likely  that  the
              platform,  version, and environment are important.  Running this
              command generates a summary of similar information  that  should
              accompany a bug report.

              It includes compiler, library and software information.  It does
              not include any personal information, other  than  the  location
              and size of your task data files.

              This  command also performs a diagnostic scan of your data files
              looking for common problems, such as duplicate UUIDs.

       task execute <external command>
              Executes the specified command.  Not useful by itself, but  when
              used  in  conjunction  with  aliases  and extensions can provide
              seamless integration.

       task logo
              Displays the Taskwarrior logo.

       task reports
              Lists  all  supported  reports.   This  includes  the   built-in
              reports, and any custom reports you have defined.

       task shell
              Launches  an  interactive  shell  with  all  the  task  commands

       task show [all | substring]
              Shows all the current settings in the taskwarrior  configuration
              file.   If a substring is specified just the settings containing
              that substring will be displayed.

       task <filter> stats
              Shows statistics of the tasks defined by the filter.

       task <filter> summary
              Shows a report of aggregated task status by project.

       task <filter> tags
              Show a list of  all  tags  used.   Any  special  tags  used  are

       task timesheet [weeks]
              Shows a weekly report of tasks completed and started.

       task undo
              Reverts the most recent action.  Obeys the confirmation setting.

       task version
              Shows the taskwarrior version number.


       task _columns
              Displays only a list of supported columns.

       task _commands
              Generates a list of all commands, for autocompletion purposes.

       task _config
              Lists  all  supported  configuration  variables,  for completion

       task <filter> _ids
              Shows only the IDs of matching tasks, in the form of a list.

       task <filter> _projects
              Shows only a list of all project names used.

       task <filter> _tags
              Shows only a list of all tags used, for autocompletion purposes.

       task <filter> _urgency
              Displays the urgency measure of a task.

       task _version
              Shows only the taskwarrior version number.

       task _zshcommands
              Generates  a  list  of  all  commands,  for  zsh  autocompletion

       task <filter> _zshids
              Shows the IDs and descriptions of matching tasks.


       ID     Tasks  can  be  specified  uniquely by IDs, which are simply the
              index of the task in the data  file.   The  ID  of  a  task  may
              therefore  change,  but only when a command is run that displays
              IDs.  When modifying tasks, it is  safe  to  rely  on  the  last
              displayed  ID.   Always run a report to check you have the right
              ID for a task. IDs can be given  to  task  as  a  sequence,  for
              task 1,4-10,19 delete

              Tags  are arbitrary words associated with a task. Use + to add a
              tag and - to remove a tag from a  task.  A  task  can  have  any
              quantity of tags.

              Certain  tags (called 'special tags'), can be used to affect the
              way tasks are treated.  For example, is a task has  the  special
              tag  'nocolor',  then  it  is  exempt from all color rules.  The
              supported special tags are:

                  +nocolor     Disable color rules processing for this task
                  +nonag       Completion of  this  task  suppresses  all  nag
                  +nocal       This task will not appear on the calendar
                  +next        Elevates task so it appears on 'next' report

              Specifies the project to which a task is related to.

       priority:H|M|L or priority:
              Specifies High, Medium, Low and no priority for a task.

              Specifies the due-date of a task.

              Specifies the frequency of a recurrence of a task.

              Specifies the Recurrence end-date of a task.

              Specifies foreground color. Deprecated.

              Specifies background color. Deprecated.

              Specifies the desired number of tasks a report should show, if a
              positive integer is given.  The value 'page' may also  be  used,
              and  will  limit  the  report output to as many lines of text as
              will fit on screen.  This defaults to 25 lines.

              Date until task becomes pending.

       depends:<id1,id2 ...>
              Declares this task to be dependent on id1 and id2.   This  means
              that the tasks id1 and id2 should be completed before this task.
              Consequently, this task will  then  show  up  on  the  'blocked'

              For report purposes, specifies the date that a task was created.
              The entry attribute cannot be directly specified using task add,
              and should not be edited after creating the task.


       Attribute modifiers improve filters.  Supported modifiers are:

              before (synonyms under, below)
              after (synonyms over, above)
              is (synonym equals)
              isnt (synonym not)
              has (synonym contains)
              startswith (synonym left)
              endswith (synonym right)

       For example:

              task due.before:eom priority.not:L list

       The before modifier is used to compare values, preserving semantics, so
       project.before:B list all projects that begin with 'A'.   Priority  'L'
       is  before  'M',  and  due:2011-01-01  is  before  due:2011-01-02.  The
       synonyms 'under' and 'below' are included to allow  filters  that  read
       more naturally.

       The after modifier is the inverse of the before modifier.

       The  none  modifier  requires that the attribute does not have a value.
       For example:

           task priority:      list
           task priority.none: list

       are equivalent, and list tasks that do not have a priority.

       The any modifier requires that the attribute has a value, but any value
       will suffice.

       The is modifier requires an exact match with the value.

       The isnt modifier is the inverse of the is modifier.

       The has modifier is used to search for a substring, such as:

           task description.has:foo list
           task foo                 list

       These  are  equivalent  and  will return any task that has 'foo' in the
       description or annotations.

       The hasnt modifier is the inverse of the has modifier.

       The startswith modifier matches against the left, or  beginning  of  an
       attribute, such that:

           task project.startswith:H list
           task project:H            list

       are  equivalent and will match any project starting with 'H'.  Matching
       all projects not starting with 'H' is done with:

           task project.not:H         list

       The  endswith  modifier  matches  against  the  right,  or  end  of  an

       The  word  modifier  requires that the attribute contain the whole word
       specified, such that this:

           task description.word:bar list

       Will match the description 'foo bar baz' but does not match 'dog food'.

       The noword modifier is the inverse of the word modifier.


       You can use the following operators in filter expressions:

         and  or  xor            Logical operators
         <  <=  =  !=  >=  >     Relational operators
         (  )                    Precedence

       For example:

         task due.before:eom priority.not:L list
         task '( due < eom or priority != L )'  list

       Note that the parentheses are required when using  a  logical  operator
       other than the 'and' operator.  The reason is that some report contains
       filters that must be combined with the  command  line.   Consider  this

         task project:Home or project:Garden list

       While  this  looks  correct,  it  is not.  The 'list' report contains a
       filter of:

         task show report.list.filter

         Config Variable    Value
         -----------------  --------------
         report.list.filter status:pending

       Which means the example is really:

         task status:pending project:Home or project:Garden list

       The implied 'and' operator makes it:

         task status:pending and project:Home or project:Garden list

       This is a precedence error - the 'and' and  'or'  need  to  be  grouped
       using parentheses, like this:

         task status:pending and ( project:Home or project:Garden ) list

       The original example therefore must be entered as:

         task '( project:Home or project:Garden )' list

       This  includes  quotes  to  escape  the  parentheses, so that the shell
       doesn't interpret them and hide them from taskwarrior.

       There is redundancy between operators, attribute  modifiers  and  other
       syntactic sugar.  For example, the following are all equivalent:

         task foo                      list
         task /foo/                    list
         task description.contains:foo list
         task description.has:foo      list
         task 'description ~ foo'      list


       Taskwarrior reads dates from the command line and displays dates in the
       reports.  The expected and desired date format  is  determined  by  the
       configuration  variable  dateformat  in  the  taskwarrior configuration

              Exact specification
                     task ... due:7/14/2008

                     task ... due:20120314T223000Z

              Relative wording
                     task ... due:today
                     task ... due:yesterday
                     task ... due:tomorrow

              Day number with ordinal
                     task ... due:23rd
                     task ... due:3wks
                     task ... due:1day
                     task ... due:9hrs

              Start of (work) week (Monday), calendar week (Sunday or Monday),
              month, quarter and year
                     task ... due:sow
                     task ... due:soww
                     task ... due:socw
                     task ... due:som
                     task ... due:soq
                     task ... due:soy

              End of (work) week (Friday), calendar week (Saturday or Sunday),
              month, quarter and year
                     task ... due:eow
                     task ... due:eoww
                     task ... due:eocw
                     task ... due:eom
                     task ... due:eoq
                     task ... due:eoy

              At some point or later
                     task ... wait:later
                     task ... wait:someday

                     This sets the wait date to 1/18/2038.

              Next occurring weekday
                     task ... due:fri

       Recurrence periods. Taskwarrior supports several ways of specifying the
       frequency of recurring tasks.

              daily, day, 1da, 2da, ...
                     Every day or a number of days.

                     Mondays,  Tuesdays,  Wednesdays,  Thursdays,  Fridays and
                     skipping weekend days.

              weekly, 1wk, 2wks, ...
                     Every week or a number of weeks.

              biweekly, fortnight
                     Every two weeks.

              monthly, month, 1mo, 2mo, ...
                     Every month.

              quarterly, 1qtr, 2qtrs, ...
                     Every three months, a quarter, or a number of quarters.

                     Every six months.

              annual, yearly, 1yr, 2yrs, ...
                     Every year or a number of years.

              biannual, biyearly, 2yr
                     Every two years.


       All taskwarrior commands may be abbreviated as long as a unique  prefix
       is used, for example:

              $ task li

       is an unambiguous abbreviation for

              $ task list


              $ task l

       could be list, ls or long.

       Note  that  you  can  restrict  the minimum abbreviation size using the
       configuration setting:



       Some task descriptions need to be escaped because of the shell and  the
       special  meaning  of  some  characters  to  the shell. This can be done
       either by adding quotes to the  description  or  escaping  the  special

              $ task add "quoted ' quote"
              $ task add escaped \' quote

       The  argument  --  (a double dash) tells taskwarrior to treat all other
       args as description:

              $ task add -- project:Home needs scheduling

       In other situations, the shell sees spaces  and  breaks  up  arguments.
       For example, this command:

              $ task 123 modify /from this/to that/

       is broken up into several arguments, which is corrected with quotes:

              $ task 123 modify "/from this/to that/"

       It  is  sometimes  necessary  to  force  the  shell  to  pass quotes to
       Taskwarrior intact, so you can use:

              $ task add project:\'Three Word Project\' description


       Taskwarrior stores its configuration in  a  file  in  the  user's  home
       directory:  ~/.taskrc. The default configuration file can be overridden

       task rc:<path-to-alternate-file> ...
              Specifies an alternate configuration file.

       The environment variable overrides the default and the command line
              specification of the .taskrc file.

       task rc.<name>:<value> ...
              task rc.<name>=<value> ...  Specifies  individual  configuration
              file overrides.

       TASKDATA=/tmp/.task task ...
              The  environment  variable  overrides  the  default, the command
              line, and the 'data.location' configuration setting of the  task
              data directory.


       For examples please see the task tutorial man page at

              man task-tutorial

       or the online documentation starting at


       Note  that  the  online documentation is more detailed and more current
       than this man page.


              User configuration file - see also taskrc(5).   Note  that  this
              can  be  overridden  on  the  command  line  or  by  the  TASKRC
              environment variable.

              The default directory where task  stores  its  data  files.  The
              location   can  be  configured  in  the  configuration  variable
              'data.location', or overridden  with  the  TASKDATA  environment

              The file that contains the tasks that are not yet done.

              The file that contains the completed "done" tasks.

              The file that contains the information to the "undo" command.


       Copyright (C) 2006 - 2012 P. Beckingham, F. Hernandez.

       Taskwarrior    is    distributed    under    the   MIT   license.   See       for       more


       taskrc(5), task-tutorial(5), task-faq(5), task-color(5), task-sync(5)

       For more information regarding taskwarrior, see the following:

       The official site at

       The official code repository at

       You can contact the project by emailing


       Bugs in taskwarrior may be reported to the issue-tracker at