dex skill

safe

/skills/gricha/dex

This skill helps you create, track, and complete multi-session tasks using JSON files, coordinating async work across sessions.

npx playbooks add skill openclaw/skills --skill dex

Review the files below or copy the command above to add this skill to your agents.

Files (2)

SKILL.md

1.3 KB

---
name: dex
description: Task tracking for async/multi-step work. Use dex to create, track, and complete tasks that span multiple sessions or require coordination (e.g., coding agent dispatches, PR reviews, background jobs). Tasks stored as JSON files in .dex/tasks/.
---

# Dex Task Tracking

Track async work: coding agent dispatches, multi-step projects, anything needing follow-up.

## Commands
```bash
dex create -d "Description" --context "Background, goal, done-when"
dex list                    # Pending tasks
dex list --all              # Include completed
dex show <id>               # View task
dex show <id> --full        # Full context
dex complete <id> --result "What was done, decisions, follow-ups"
dex edit <id> --context "Updated context"
dex delete <id>
```

## Task Structure
- **Description**: One-line summary
- **Context**: Background, requirements, done criteria
- **Result**: What was built, decisions, follow-ups

## Example
```bash
# Before dispatching agent
dex create -d "Add caching to API" --context "Workspace: feat1 (100.x.x.x)
Branch: feat/cache
Done when: PR merged, CI green"

# After work complete
dex complete abc123 --result "Merged PR #50. Redis caching with 5min TTL."
```

## Storage
`.dex/tasks/{id}.json` — one file per task, git-friendly.

Overview

This skill provides a lightweight task tracker for asynchronous, multi-step work. Use it to create, inspect, update, and complete tasks that persist across sessions and team handoffs. Tasks are stored as simple JSON files under .dex/tasks/ so they are git-friendly and easy to audit.

How this skill works

You create tasks with a one-line description and richer context that explains background, requirements, and completion criteria. Tasks are managed via command-line operations to list, show, edit, complete, and delete. Completing a task records the result, decisions, and next steps into the task JSON so the history is preserved.

When to use it

Coordinating multi-step jobs that span sessions or agents (e.g., background jobs, deployments).
Tracking dispatched coding agents and collecting their outputs and follow-ups.
Managing review work such as PR reviews where outcome and decisions must be recorded.
Keeping lightweight, git-tracked notes for tasks that need auditability or versioning.
Handing off work between teammates or automation tools with persistent context.

Best practices

Write a concise description and include explicit 'done when' criteria in context.
Record decisions and follow-ups in the result when completing a task to avoid losing context.
Keep one task per JSON file to simplify diffs and merges in git.
Use the full show/edit options when adding technical context like branches or environment.
Delete only obsolete tasks; prefer completing to preserve history and traceability.

Example use cases

Before dispatching a code-generating agent, create a task with branch, workspace, and acceptance criteria.
List pending tasks to review outstanding async work during a planning meeting.
Complete a task after merging a PR and include the PR number, summary of changes, and any follow-ups.
Store repair actions for background jobs so on-call engineers have the exact context and resolution.
Archive cross-repo change requests as tasks for audit purposes and link to related commits or issues.

FAQ

Where are tasks stored?

Tasks are stored as individual JSON files under .dex/tasks/, making them easy to commit to git.

How do I mark a task done with details?

Use the complete command and provide a result that summarizes what was done, decisions made, and any follow-up actions.