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.
The agent system
The board is the memory. The shipped skills are the operating system around it:
| Skill | What it does |
|---|---|
cliban |
Teaches agents the complete, machine-readable CLI surface. |
setup-cliban |
Binds a repository to its board and injects live state into new sessions. |
cliban-workflow |
Defines the shared artifact, status, git, and recovery contract. |
explore-feature |
Turns a rough idea into an approved design. |
scope-milestone |
Grills the design, slices tracer-bullet tickets, and records dependency edges. |
triage-bug |
Searches duplicates, reproduces the report, and leaves an actionable ticket. |
diagnose-issue |
Proves root cause while preserving the hypothesis ledger on the ticket. |
complete-issue |
Plans proportionally, implements, verifies, and hands off one ticket. |
complete-milestone |
Dispatches one agent per ticket in dependency waves and isolated worktrees. |
recover-milestone |
Reconstructs an interrupted run from board and git state. |
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:
cliban contains the CLI skill and repository binding. cliban-flow adds the
workflow skills; it is optional and depends on cliban for mechanics.
Install
|
Or:
Memory that agents can mutate safely
An issue description is structured Markdown. Agents replace one section without touching the others:
Project notes are long-lived knowledge, retrieved progressively instead of dumped into every prompt:
Claims prevent duplicate work. Native blocking edges produce dispatchable waves:
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.
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.mdfollows 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
cliban is pre-1.0 and MIT licensed.