Agent skill

Taskwarrior

by meain in meain/dotfiles

Manage tasks using Taskwarrior (task CLI) - create, list, update, complete, annotate, and manage dependencies between tasks.

MITAuto-check passed

Install Taskwarrior

skills CLI
$ npx skills add meain/dotfiles --skill taskwarrior -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install meain/dotfiles taskwarrior --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/meain/dotfiles.git skills-src && mkdir -p .claude/skills && cp -r skills-src/agents/.agents/skills/taskwarrior .claude/skills/taskwarrior && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
taskwarrior
GitHub stars
285
Token cost
~2.9k tokens
SKILL.md length
1,159 words
Files
1
Skills in repo
36
Repo updated
First seen
Licence
MIT

At a glance

Manage tasks using Taskwarrior (task CLI) - create, list, update, complete, annotate, and manage dependencies between tasks.

  • Works in 2 steps: Identify the Request → Present Results
  • SKILL.md covers When to Use, Important Notes, Instructions and External Lookups, plus 1 more section
  • Calls gh

What it does

Taskwarrior is an agent skill from meain/dotfiles. Manage tasks using Taskwarrior (task CLI) - create, list, update, complete, annotate, and manage dependencies between tasks.

Its SKILL.md is about 2.9k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

The repository describes itself as: If there is a shell, there is a way! The licence is MIT.

Example prompts

  • “/taskwarrior”

Workflow steps

2 steps, taken from the step headings in SKILL.md.

  1. Identify the Request
  2. Present Results

What it can do on your machine

Read from SKILL.md and the folder at commit f469fb6. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • gh

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md. Its commands use gh, which can reach the network depending on how they are called.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Taskwarrior loads about 2.9k tokens when it runs. Until then it costs about 34 tokens; SKILL.md has 1,159 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~34
When it runs · the whole SKILL.md, loaded when a task matches
~2.9k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from meain/dotfiles at commit f469fb6, republished under its MIT licence (© meain). 1,159 words, ~2,922 tokens.

Download SKILL.mdSave it as .claude/skills/taskwarrior/SKILL.md (or your agent's skills folder).
name
taskwarrior
description
Manage tasks using Taskwarrior (task CLI) - create, list, update, complete, annotate, and manage dependencies between tasks.
triggers
/tw, create task, create issue, add task, list tasks, show task, close task, complete task, what tasks, what's ready, task status, update task, blocked tasks…

Taskwarrior Issue Management

Use the task CLI to manage issues with dependency tracking.

When to Use

  • The user mentions a task ID or wants to manage work items
  • The user asks to create, view, update, close, or search tasks
  • The user wants to see what work is ready or blocked
  • The user wants to manage dependencies between tasks
  • The user asks about project status

Important Notes

Sandbox

The task CLI needs read/write access to ~/.task/ which is typically outside the sandbox. Commands will fail with "unable to open database file" errors. Use dangerouslyDisableSandbox: true for all task commands.

Output Formatting

Use rc.verbose=label on list/report commands to keep column headers but strip footer noise (task count, config overrides, sync messages). Prefer this over rc.verbose=nothing which strips headers too and makes output harder to parse.

For programmatic use or when you need structured data (e.g., to build a markdown table), use task export which outputs JSON. You can filter it the same way: task project:cpb export, task +BLOCKED export, etc.

Instructions

Phase 1: Identify the Request

IMPORTANT: Always use UUID (short prefix is fine) instead of numeric IDs when referencing tasks. Numeric IDs are unstable and shift when tasks are completed or deleted — never use numeric IDs in commands, even if they appear in the output. IDs are shown in reports for the user's convenience only. After creating a task, use rc.verbose=new-uuid to get the UUID directly (see Phase 2A).

IntentOperation
View task detailstask <uuid> information
List/filter taskstask list, task project:<name> list
See available worktask ready
Create a new tasktask add
Update task fieldstask <uuid> modify
Complete a tasktask <uuid> done
Delete a tasktask <uuid> delete
Add a comment/annotationtask <uuid> annotate "text"
Remove annotationtask <uuid> denotate "text"
Manage dependenciestask <uuid> modify depends:<other_uuid>
See blocked taskstask blocked
See blocking taskstask blocking
Project summarytask summary or task projects
Start workingtask <uuid> start
Stop workingtask <uuid> stop
Active taskstask active
Phase 2A: Creating Tasks

Always use rc.verbose=new-uuid when creating tasks — this makes task add output the UUID directly instead of the unstable numeric ID.

Task titles: Write clean, concise descriptions — don't just copy-paste alert names or ticket titles verbatim. Distill the key info: service, symptom, environment. For example, instead of Elastic - [prod] [swedencentral] API Error - earn-svc - 5xx PrdeuswEARNQueryOrg, use Investigate earn-svc 5xx errors in prod swedencentral (PrdeuswEARNQueryOrg).

Tags and projects: Do NOT invent tags or projects. Only use tags and projects that already exist in the task database. Before creating a task, check existing tasks (task rc.verbose=label projects and task rc.verbose=label tags) to see what's in use. If no matching tag/project exists, create the task without tags/projects and let the user decide. The only exception is project:on-call and priority:H for on-call investigation tasks — these are always correct.

bash
# Basic task with project
task rc.verbose=new-uuid add "Task description" project:cpb

# With priority (H=high, M=medium, L=low)
task rc.verbose=new-uuid add "Fix bug" project:cpb priority:H

# With due date
task rc.verbose=new-uuid add "Deploy" project:cpb due:friday

# With tags
task rc.verbose=new-uuid add "Review" project:cpb +urgent +review

# With dependencies (use UUID of the dependency)
task rc.verbose=new-uuid add "Deploy to prod" project:cpb depends:a1b2c3d4

# Sub-projects using dots
task rc.verbose=new-uuid add "Fix API" project:cpb.earn

The output will be like Created task a1b2c3d4-... — use that UUID for all subsequent operations.

Phase 2B: Annotations (Comments)
bash
# Add annotation (use UUID)
task a1b2c3d4 annotate "Spoke with Ryan, needs API change first"
task a1b2c3d4 annotate "See PR #1234 for context"

# Remove annotation
task a1b2c3d4 denotate "Spoke with Ryan"
Phase 2C: Dependencies
bash
# Add dependency using UUIDs (task abc depends on tasks def and ghi)
task a1b2c3d4 modify depends:d5e6f7a8,b9c0d1e2

# Remove dependency
task a1b2c3d4 modify depends:-d5e6f7a8

# View blocked/blocking
task blocked
task blocking
Phase 2D: Filtering
bash
# By project
task project:cpb list

# By priority
task priority:H list

# By tag
task +urgent list

# By status
task +BLOCKED list
task +OVERDUE list
task +ACTIVE list

# Text search
task /deploy/ list

# Combined filters
task project:cpb priority:H due.before:eow list
Phase 2E: Modifying Tasks

IMPORTANT: Always use tag: attribute syntax when adding tags — the +tag syntax is unreliable with modify and can be misinterpreted as a description. Use -tag to remove tags.

bash
task a1b2c3d4 modify priority:H
task a1b2c3d4 modify project:cpb.earn
task a1b2c3d4 modify due:eow
task a1b2c3d4 modify tag:urgent          # add/set tag
task a1b2c3d4 modify tag:on-call,prod    # set multiple tags
task a1b2c3d4 modify -urgent             # remove tag
task a1b2c3d4 modify depends:d5e6f7a8    # add dependency
Phase 2F: Task Notes

Detailed notes for tasks live in /Users/meain/.local/share/tasknotes/. Each note is a markdown file named <uuid-prefix> - <task name>.md.

All task-related resources go here — not just notes, but also drafts, templates, support ticket messages, or any other artifacts tied to a task. Name them with the task UUID prefix for discoverability (e.g., <uuid> - Azure support ticket draft.md). Never save task-related files to /tmp or other locations.

When completing a task, always write detailed notes summarizing what was done, findings, and outcomes. If you learned something new during the task (new patterns, gotchas, field types, service behaviors, etc.), also create a separate learning note named <uuid-prefix> learning.md with bullet points of key learnings.

After writing notes, annotate the task with the filenames:

bash
# Write the note file
# /Users/meain/.local/share/tasknotes/<uuid> - <task name>.md

# Annotate the task to reference the note
task a1b2c3d4 annotate "notes: <uuid> - <task name>.md"

# If there are learnings too
task a1b2c3d4 annotate "notes: <uuid> - <task name> - learning.md"

Notes should include:

  • Summary of what was done
  • Root cause / findings (for investigations)
  • Evidence and key data points
  • Links to PRs, runbooks, or other artifacts
  • Next steps if applicable

Learning notes should be concise bullet points covering:

  • New patterns or conventions discovered
  • Gotchas and pitfalls encountered
  • Service behaviors or field types that weren't obvious
  • Useful queries or commands found
Show full SKILL.md (451 more words)Show less
Phase 2G: Completing and Deleting
bash
task a1b2c3d4 done                  # mark complete
task a1b2c3d4 delete                # mark deleted
task undo                    # revert most recent change

# Revert a completed task back to pending (works for any task, not just the last action)
task a1b2c3d4 modify status:pending

On completion: Always write task notes (and learning notes if applicable) before marking done. See Phase 2F.

Phase 2H: Reports and Views

Use rc.verbose=label on all list/report commands for clean output with headers.

bash
task rc.verbose=label list                    # pending tasks
task rc.verbose=label next                    # most urgent
task rc.verbose=label ready                   # actionable (not blocked/waiting)
task rc.verbose=label all                     # everything
task rc.verbose=label completed               # done tasks
task rc.verbose=label summary                 # project summary
task rc.verbose=label projects                # project list with counts
Phase 2I: Export/Import

Use task export for structured JSON output — useful for building markdown tables or programmatic processing. Supports the same filters as other commands.

bash
task export                  # all as JSON
task project:cpb export      # filtered by project
task +BLOCKED export         # filtered by virtual tag
task status:pending export   # filtered by status
task import tasks.json       # import
Phase 3: Present Results

For read operations, present as a markdown table when showing multiple tasks:

#UUIDTaskStatus
830bd26f9Check with Juan about schema validationready
95466d0bbFix schema validation in devblocked by #8

Include relevant columns: UUID, description, status/blockers, priority, due date, project. For single tasks, a brief summary is fine.

For write operations, confirm what was done:

  • State the action taken and the task UUID
  • Show the updated task list if multiple tasks were affected

External Lookups

When the user references external links or identifiers in task arguments, look them up to extract context (title, status, summary) for use in task descriptions and annotations.

SourceHow to look up
GitHub PR/issue URLGIT_DIR=$(jj git root 2>/dev/null || echo .git) gh pr view <number> --repo <owner/repo> --json title,state or gh issue view
Jira ticket (e.g. PROJ-123)jira issue view PROJ-123
Confluence page URLconfluence page view --url <url> or use WebFetch
Generic webpage URLUse WebFetch to retrieve the page title/summary

After looking up, use the extracted info to:

  1. Write a clean task title (don't just paste the URL)
  2. Annotate the task with the URL for reference
  3. Create dependency tasks if the task depends on the external item (e.g., "merge PR#X" as a blocker)

Guidelines

  • Tasks tagged on-call should always have priority:H — on-call items are top priority
  • Use project:cpb as the default project for control-plane-backend work
  • Use sub-projects with dots for specificity (e.g., project:cpb.earn)
  • Priority levels: H (high/critical), M (medium), L (low/backlog)
  • Use annotations for context, links, and notes — but NOT for dependency info (use depends: instead)
  • Always use taskwarrior's native depends: for dependency chains, never annotations
  • When creating multi-environment rollouts (dev -> stage -> prod), create separate tasks and chain them with depends:
  • Use task ready to find unblocked work (excludes blocked tasks)
  • Use task next when the user asks "what should I work on"
  • Use task blocked / task blocking to inspect dependency state
  • Reference tasks in backlog using backtick format: tw:<uuid>
  • Date shorthands: today, tomorrow, monday, eod, eow, eom, eoq, eoy, som, sow
  • The default list report shows dependencies in the Deps column
  • Use rc.confirmation=0 to suppress confirmation prompts on destructive operations (delete, done on multiple tasks)
  • When task changes reflect broader project state changes (e.g., a revert, a new blocker), consider updating auto-memory to keep project context current

ARGUMENTS: $ARGUMENTS

© meain, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in agents/.agents/skills/taskwarrior of meain/dotfiles.

Open the folder on GitHubat commit f469fb6

Similar skills

  • C Tasks

    daxaur/openpaw

    Manage tasks across Todoist (todoist-cli), Things 3 (things-cli), and Taskwarrior (task).

    174 GitHub stars~588 tokensUpdated 4 mo ago
    Auto-check passed

More from meain/dotfiles

All 36 skills in this repo
  • Recall

    meain/dotfiles

    Search past Claude Code and Codex sessions. An agent skill from meain/dotfiles.

    285 GitHub starsUsed in 1 repo~684 tokens
    Auto-check passed
  • Grill With Docs

    meain/dotfiles

    Grilling session that challenges your plan against the existing domain model, sharpens terminology, and updates documentation (CONTEXT.md, ADRs) inline as decisions crystallise.

    285 GitHub starsUsed in 21 repos~875 tokens
    Auto-check passed
  • Backlog

    meain/dotfiles

    Daily backlog management — full planning review OR add a single entry from a URL.

    285 GitHub stars~3k tokensUpdated 1 mo ago
    Auto-check passed
  • Concern Review

    meain/dotfiles

    Generate an interactive local HTML review page for a large PR or diff, grouping the changed files by logical concern (not just by file) so a reviewer can go through one theme at a time instead of a…

    285 GitHub stars~2.2k tokensUpdated 1 mo ago
    Auto-check passed
  • My Weekly Report

    meain/dotfiles

    Generate a concise weekly status update in team format. An agent skill from meain/dotfiles.

    285 GitHub stars~2.5k tokensUpdated 1 mo ago
    Auto-check passed
  • Web Search

    meain/dotfiles

    Search the web using lynx and DuckDuckGo. An agent skill from meain/dotfiles.

    285 GitHub stars~830 tokensUpdated 1 mo ago
    Auto-check passed

Questions about Taskwarrior

What does Taskwarrior do?

Manage tasks using Taskwarrior (task CLI) - create, list, update, complete, annotate, and manage dependencies between tasks. Taskwarrior is an agent skill from meain/dotfiles. Manage tasks using Taskwarrior (task CLI) - create, list, update, complete, annotate, and manage dependencies between tasks.

How do I install Taskwarrior in Claude Code?

Run `npx skills add meain/dotfiles --skill taskwarrior -a claude-code`. Or copy the skill folder (agents/.agents/skills/taskwarrior in meain/dotfiles) into .claude/skills/taskwarrior in your project. Claude Code loads it when a task matches its description.

How do I install Taskwarrior in Codex?

Run `npx skills add meain/dotfiles --skill taskwarrior -a codex`. Or copy the skill folder (agents/.agents/skills/taskwarrior in meain/dotfiles) into .agents/skills/taskwarrior in your project. Codex loads it when a task matches its description.

Can I use Taskwarrior in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add meain/dotfiles --skill taskwarrior -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/taskwarrior, .gemini/skills/taskwarrior, .github/skills/taskwarrior and .opencode/skills/taskwarrior in your project.

What does Taskwarrior need to run?

Going by SKILL.md and its folder, Taskwarrior needs the command-line tools its instructions call (gh).

Does Taskwarrior access the network?

SKILL.md contains no URLs. Its commands use gh, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is Taskwarrior safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Taskwarrior use?

Taskwarrior is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Taskwarrior use?

About 2.9k tokens (SKILL.md is roughly 12k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Taskwarrior?

Skills that share tags, products or a category with Taskwarrior: C Tasks (daxaur/openpaw, 174 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Taskwarrior?

meain (a GitHub user) maintains it in meain/dotfiles, which has 285 GitHub stars. The repository holds 36 skills in this directory. The repository was last updated on September 5, 2026.

Source: meain/dotfiles on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.