cliban

Durable memory and orchestration for coding agents.

Agents lose context. Teams of agents also collide, duplicate work, and leave
half-finished branches behind. cliban gives them a durable local control plane:
specs, plans, progress, dependencies, claims, decisions, and reusable lessons
live on one SQLite board and survive crashes, compaction, and handoffs.

$ cliban issue current --json                 # recover the ticket for this branch
$ cliban issue cat PROJ-42 --section plan     # recover the living plan
$ cliban activity --issue PROJ-42             # recover decisions and dead ends
$ cliban project search PROJ "wal mode" --json # recall durable project knowledge

Every read is available as JSON. Every mutation is atomic. Every event is
attributed. Nothing requires a hosted service.

_{scope · coordinate · observe · recover}

The agent system

The board is the memory. The shipped skills are the operating system around it:

cliban-flow now owns the lifecycle through a small dispatcher: ticket start,
sync, ready, integration, abandonment, and milestone recovery use the same
board-and-git contract. Plans may be one sentence or a structured checklist;
verification is executable; review is spent where risk justifies it. End-to-end
scenarios exercise both standalone tickets and orchestrated milestone tickets.

idea → explore → scope → dependency waves → isolated agents → verified handoff
                  bug → triage → diagnose → complete ────────┘
                                      ↑
                          board + git make it resumable

Install the plugins:

claude plugin marketplace add LioraLabs/claude-plugins
claude plugin install cliban@lioralabs
claude plugin install cliban-flow@lioralabs

cliban contains the CLI skill and repository binding. cliban-flow adds the
workflow skills; it is optional and depends on cliban for mechanics.

_{read · act · tick · log · resume}

Install

curl -fsSL https://raw.githubusercontent.com/LioraLabs/cliban/main/install.sh | sh

Or:

brew install lioralabs/tap/cliban
cargo binstall cliban
cargo install cliban

cliban project add PROJ "My project"
cliban issue add "First issue" --project PROJ --priority high
cliban

Memory that agents can mutate safely

An issue description is structured Markdown. Agents replace one section without
touching the others:

## Spec
## Plan
## Activity Log
## Notes
## Files

cliban issue edit PROJ-42 --section spec --description-file -
cliban issue tick PROJ-42 --task 1 --step 2
cliban issue log PROJ-42 "reproduction fails after the second reorder"
cliban issue lint PROJ-42

Project notes are long-lived knowledge, retrieved progressively instead of
dumped into every prompt:

cliban project note add PROJ "tests share a tempdir" --body -
cliban project search PROJ "flaky tempdir" --json

Claims prevent duplicate work. Native blocking edges produce dispatchable waves:

cliban issue ls --ready --project PROJ --json
cliban issue claim PROJ-42
cliban milestone waves --project PROJ "v1" --json

Human control plane

Run cliban with no arguments for the TUI: five status columns, fuzzy search,
milestone progress, projects, and an attributed activity feed. Press e to edit
an issue as frontmatter plus Markdown in $EDITOR.

_{`e` → edit → save → synchronized board}

Connect when needed

• Linear: import assigned work, keep local plans and logs, then push one
  living progress comment. Field ownership prevents re-imports from eating an
  agent's plan.
• Other harnesses: plugin/skills/cliban/SKILL.md
  follows the Agent Skills format and is checked against the real CLI in CI.

Why a board instead of a plan file?

A file remembers text. cliban remembers work: ownership, dependencies, atomic
plan progress, searchable lessons, and an attributed timeline. A fresh agent can
query what is ready, what changed, what failed, and where to resume without
reconstructing the answer from prose and git diffs.

Everything stays local unless you explicitly connect Linear.

Build

cargo test --workspace

cliban is pre-1.0 and MIT licensed.