beads

Track multi-session work with a graph-based issue tracker and git-backed database.

1|1|Updated Dec 3, 2020
One-click install
npx skills add https://github.com/kaofelix/dotfiles --skill beads-kaofelix
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: beads
Source: https://github.com/kaofelix/dotfiles/tree/main/pi/.pi/agent/skills/beads
Command: npx skills add https://github.com/kaofelix/dotfiles --skill beads-kaofelix

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Beads provides a persistent, git-backed memory of multi-session work by tracking tasks and their dependencies in a graph. It allows work to span days or weeks and survive conversation compaction so you can resume where you left off.

Core Features & Use Cases

  • Graph-based memory: Dependency-aware task graph that shows blockers, parents/children, and related work.
  • Persistence across sessions: Git-backed storage that preserves state across compaction cycles.
  • Session-ready workflows: Commands like bd ready, bd show, bd update, and bd dep add to enable structured, repeatable work.
  • Collaboration & history: Audit trails, labels, and multi-user updates with a shared DB in .beads.

Quick Start

To begin, initialize beads in your repository with bd init, then create an epic and add child tasks, and finally synchronize with bd sync.

Frequently Asked Questions about beads

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I track complex task dependencies across multiple work sessions?

You can track complex task dependencies across multiple work sessions by using a graph-based issue tracker backed by git. It maps parent-child relationships and blockers, preserving your work state through compaction cycles so you can resume tasks exactly where you left off.

How do I preserve persistent memory for long-running tasks when conversation context is compacted?

Persistent memory for long-running tasks survives conversation compaction by storing task graphs and dependencies in a git-backed database. This ensures your multi-session work history and issue relationships remain intact and queryable even after context limits are reached.

What is the best way to manage a dependency-aware task graph for a software engineering project?

The best way to manage a dependency-aware task graph is using a git-backed database that records task relationships and blockers. This approach supports complex dependencies, maintains an audit trail, and enables structured workflows through commands that update and synchronize task states.

Can I use a git-backed database to collaborate on task management with my teammates?

Yes, you can collaborate on task management using a shared git-backed database stored in a `.beads` directory. It supports multi-user updates, audit trails, and labels, allowing teammates to synchronize their work and maintain a consistent view of the task graph.

How do I initialize and manage a multi-session task graph using the beads CLI?

To initialize and manage a multi-session task graph, run `bd init` in your repository to set up the git-backed database. Then use commands like `bd ready`, `bd show`, `bd update`, `bd dep`, and `bd sync` to create, update, and synchronize tasks and their dependencies.