docs: Rewrite README with professional structure

- Add badges (npm, build, license, stars)
- Remove 'Work in Progress' placeholder
- Put npx skills add command front and center after intro
- Add agent integration section with configuration guidance
- Replace generic alt text with descriptive text
- Add complete installation, usage, architecture sections
- Add contributing guidelines and changelog
- Add MIT license link
- Professional, production-ready documentation
This commit is contained in:
zenchantlive 2026-03-05 16:54:03 -08:00
parent ce4700849b
commit 0bd12ca597

513
README.md
View file

@ -1,108 +1,185 @@
# BeadBoard # BeadBoard
**Work in Progress, please contribute!**
**BeadBoard is a multi-agent swarm coordination system built on [Beads](https://github.com/steveyegge/beads) inspired by [Gastown](https://github.com/steveyegge/gastown).** Thanks [Steve Yegge](https://github.com/steveyegge)!
BB is a visual operations layer for running agent teams against real dependency-constrained work. [![npm version](https://img.shields.io/npm/v/beadboard.svg)](https://www.npmjs.com/package/beadboard)
[![Build Status](https://img.shields.io/github/actions/workflow/status/zenchantlive/beadboard/ci.yml?branch=main)](https://github.com/zenchantlive/beadboard/actions)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![GitHub stars](https://img.shields.io/github/stars/zenchantlive/beadboard?style=social)](https://github.com/zenchantlive/beadboard/stargazers)
**Multi-agent swarm coordination system for dependency-constrained work.**
Built on [Beads](https://github.com/steveyegge/beads) and inspired by [Gastown](https://github.com/steveyegge/gastown).
--- ---
## What This App Is ## 🚀 Add BeadBoard to Your Agent
BeadBoard is not just a task board. It is an execution system for coordinating agents around shared Beads workflows:
- Agent-to-agent communication with explicit categories (`HANDOFF`, `BLOCKED`, `DECISION`, `INFO`) ```bash
- Conversation threads merged from activity events, agent messages, and local interactions npx skills add zenchantlive/beadboard --skill beadboard-driver
- Graph/topology context for deciding what should move next ```
- Global project scope switching across single and aggregate workspaces
- Swarm orchestration with archetypes/templates and assignment controls This one command installs the BeadBoard driver skill, enabling your AI agents to:
- Coordinate work through dependency-constrained task graphs
- Communicate with other agents via structured message passing
- Track progress with real-time updates and activity streams
- Manage work state through the `bd` CLI
**[→ Full Agent Integration Guide](#agent-integration)**
--- ---
![alt text](image-9.png) ## Quick Start
### For Human Users
```bash
npm install -g beadboard
beadboard start
```
Open [http://localhost:3000](http://localhost:3000) to access the coordination dashboard.
### For Agent Developers
```bash
# Install the skill to your project
npx skills add zenchantlive/beadboard --skill beadboard-driver
# Or install globally for all your projects
npx skills add zenchantlive/beadboard --skill beadboard-driver --global
```
Then add to your project's `AGENTS.md`:
```markdown
## BeadBoard Integration
- Working directory: Run all `bd` commands from project root
- Source of truth: `bd` CLI manages all work state
- Evidence required: Never claim done without verification gates
```
---
Open [http://localhost:3000](http://localhost:3000) to access the dashboard.
---
## Agent Integration
BeadBoard is designed for AI agent coordination. Agents work in their own project repositories while humans observe and coordinate through the BeadBoard UI.
### Configuration
Add the following to your project's `AGENTS.md` or `CLAUDE.md`:
```markdown
## BeadBoard Integration
- Install driver: `npx skills add zenchantlive/beadboard --skill beadboard-driver`
- Working directory: run all `bd` commands from project root
- Source of truth: `bd` CLI manages all work state
- Evidence required: never claim done without running verification gates
```
### Key Concepts
| Component | Purpose |
|-----------|---------|
| `bd` | Beads CLI - task and dependency management |
| `bb` | BeadBoard CLI - dashboard launcher |
| `beadboard-driver` skill | Agent operating contract for coordination |
See [skills/beadboard-driver/SKILL.md](skills/beadboard-driver/SKILL.md) for the complete agent runbook.
---
## What BeadBoard Does
BeadBoard is an execution system for coordinating agents around shared Beads workflows:
- **Agent-to-agent communication** with explicit categories (`HANDOFF`, `BLOCKED`, `DECISION`, `INFO`)
- **Conversation threads** merged from activity events, agent messages, and local interactions
- **Graph/topology context** for deciding what should move next
- **Global project scope switching** across single and aggregate workspaces
- **Swarm orchestration** with archetypes/templates and assignment controls
![BeadBoard Dashboard - Multi-agent coordination interface showing task graph, agent pool, and activity stream](image-9.png)
--- ---
## Core Features ## Core Features
### 1. Agent Communication System ### 1. Agent Communication System
- Structured message lifecycle: `send`, `inbox`, `read`, `ack`
- Message states: `unread`, `read`, `acked` Structured message lifecycle for inter-agent coordination:
- Per-task conversation threads combining:
- activity events - **Message states**: `unread`, `read`, `acked`
- agent mail - **Required acknowledgment** for high-signal categories (`HANDOFF`, `BLOCKED`)
- local bd interactions - **Per-task threads** combining activity events, agent mail, and local interactions
- Required acknowledgment semantics for high-signal categories (`HANDOFF`, `BLOCKED`)
```bash
bd mail inbox
bd mail send --to <agent> --bead <id> --category HANDOFF --subject "Ready for review"
bd mail ack <message-id>
```
### 2. Swarm Coordination Surface ### 2. Swarm Coordination Surface
- Agent Pool Monitor with:
- Archetypes Agent Pool Monitor with:
- Templates
- Needs Agent queue - Archetypes and templates for agent specialization
- Pre-assigned queue - "Needs Agent" queue for unassigned work
- Squad roster - Pre-assigned queue for reserved tasks
- Assignment workflow through the graph workspace and right panel - Squad roster for active team members
![alt text](image-7.png)
![Swarm Coordination Panel - Agent pool monitor showing archetypes, assignment queues, and squad roster](image-7.png)
### 3. Graph + Dependency Topology ### 3. Graph + Dependency Topology
- DAG-oriented graph workspace for execution decisions
DAG-oriented workspace for execution decisions:
- Task/dependency tab modes for different planning lenses - Task/dependency tab modes for different planning lenses
- Blocker/unblock context surfaced directly in task cards - Blocker/unblock context surfaced in task cards
- Graph analysis support (cycle and blocked-chain context) - Graph analysis support (cycle detection, blocked-chain identification)
![alt text](image-8.png)
![Dependency Graph View - DAG visualization showing task dependencies and execution order](image-8.png)
### 4. Global Project Scope + Scanner ### 4. Global Project Scope + Scanner
- Project registry and scanner-backed discovery - Project registry and scanner-backed discovery
- Single-project and aggregate modes - Single-project and aggregate modes
- Runtime scope switching without leaving the primary workspace - Runtime scope switching without leaving the workspace
### 5. Realtime Operations Layer ### 5. Realtime Operations Layer
- Live updates via watchers + SSE
- Live updates via file watchers + Server-Sent Events
- Activity stream integration with session/task context - Activity stream integration with session/task context
- Mutation/writeback feedback integrated into the same operational surface - Mutation/writeback feedback integrated into the operational surface
--- ---
## Runtime Surface ## Installation & Setup
### Active Route
- `/`
### View Modes
- `/?view=social`
- `/?view=graph`
- `/?view=activity`
### Compatibility Redirects
- `/graph` -> `/?view=graph`
- `/sessions` -> `/?view=social`
- `/timeline` -> `/?view=activity`
- `/mockup` -> `/`
### Archived Route Vault
Legacy route implementations are preserved in `reference/routes/**` and excluded from active runtime validation scope.
---
## Install
### Prerequisites ### Prerequisites
- Node.js `18.18+` (Node `20 LTS` recommended) - Node.js `18.18+` (Node `20 LTS` recommended)
- npm - npm
### Clone + Install ### Clone + Install
```bash ```bash
git clone https://github.com/zenchantlive/beadboard.git git clone https://github.com/zenchantlive/beadboard.git
cd beadboard cd beadboard
npm install npm install
``` ```
### Global CLI Install (Optional) ### Global CLI Install
Primary install path:
```bash ```bash
npm i -g beadboard npm install -g beadboard
``` ```
Fallback wrappers from repo root: **Alternative: Platform-specific wrappers**
POSIX (Linux/macOS): POSIX (Linux/macOS):
```bash ```bash
@ -122,113 +199,205 @@ Runtime home:
- `~/.beadboard/runtime/<version>` - `~/.beadboard/runtime/<version>`
- `~/.beadboard/runtime/current.json` - `~/.beadboard/runtime/current.json`
Launcher commands: ### Development Setup
- `beadboard start`
- `beadboard start --dolt` (runs `bd dolt start` in the current project folder, then starts BeadBoard)
- `beadboard open`
- `beadboard status`
Startup note:
- In project repositories, run `bd dolt start` from the project directory (the folder with `.beads`).
- If you want one command for both steps, use `beadboard start --dolt`.
---
## Quick Start
```bash ```bash
npm run dev npm run dev
``` ```
Open: Open [http://localhost:3000](http://localhost:3000)
```text ### Production Deployment
http://localhost:3000
```
---
## Configuration
No external service is required for core local usage.
Runtime behavior is driven by:
- Local Beads project data
- Registered/scanned project roots
- URL query state (`view`, `task`, `swarm`, `agent`, `epic`, `graphTab`, panel state)
---
## Operating Flow
### 1. Coordinate through Graph + Pool
Open `/?view=graph`, inspect dependency topology, and drive assignment from the pool panel.
### 2. Communicate in Context
Open a task thread to read merged conversation context and process message acknowledgments.
### 3. Switch Scope as Work Expands
Use registry/scanner controls to move between local and aggregate project scope.
### 4. Track Live Signal
Use social/activity views to monitor execution movement and operational events.
---
## Roadmap Notes
- Cross-view assign controls in all major views.
- Social naming/UX evolution (including possible shift toward “swim” terminology).
- Continued expansion of global project config/scanner workflows.
---
## Scripts
```bash ```bash
npm run dev
npm run build npm run build
npm run start npm run start
npm run typecheck ```
npm run lint
npm run test ---
npm run video
npm run video:render ## Usage & Examples
npm run video:thumbnail
### CLI Commands
```bash
# Start BeadBoard dashboard
beadboard start
# Start with Dolt database
beadboard start --dolt
# Open dashboard in browser
beadboard open
# Check status
beadboard status
```
### Workflow Example
```bash
# 1. Navigate to your project
cd ~/my-project
# 2. Start Dolt (if using version-controlled data)
bd dolt start
# 3. Start BeadBoard
beadboard start --dolt
# 4. Open dashboard
beadboard open
```
### Common Patterns
**Coordinate through Graph + Pool:**
```
Open /?view=graph → inspect dependency topology → drive assignment from pool panel
```
**Communicate in Context:**
```
Open task thread → read merged conversation → process message acknowledgments
```
**Switch Scope:**
```
Use registry/scanner controls → move between local and aggregate project scope
```
**Track Live Signal:**
```
Use social/activity views → monitor execution movement and operational events
``` ```
--- ---
## Architecture ## Architecture
- **Frontend**: Next.js App Router + React 19 + Tailwind + Framer Motion + Radix
- **Graph stack**: XYFlow + Dagre ### High-Level Design
- **Core domain**: Beads issue model, graph/kanban/session/social builders
- **Coordination layer**: agent mail + session communication + swarm orchestration state ```
- **Realtime**: watchers + SSE + snapshot differ + activity persistence ┌─────────────────────────────────────────────────────────────┐
- **Validation/typing**: strict TypeScript + Zod contracts where applicable │ BeadBoard UI │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ Social │ │ Graph │ │ Activity │ │ Swarm │ │
│ │ View │ │ View │ │ View │ │ Panel │ │
│ └──────────┘ └──────────┘ └──────────┘ └──────────┘ │
└─────────────────────────────────────────────────────────────┘
┌────────────┼────────────┐
│ │ │
┌─────▼─────┐ ┌────▼────┐ ┌────▼─────┐
│ SSE │ │ Dolt │ │ Watchers│
│ Events │ │ DB │ │ (Chokidar)│
└───────────┘ └─────────┘ └──────────┘
│ │ │
└────────────┼────────────┘
┌──────▼──────┐
│ bd │
│ (Beads CLI)│
└─────────────┘
```
### Tech Stack
| Layer | Technologies |
|-------|-------------|
| Frontend | Next.js 15, React 19, TypeScript |
| Styling | Tailwind CSS, Radix UI, Framer Motion |
| Graph | XYFlow, Dagre |
| Database | Dolt (version-controlled SQL) |
| Realtime | Chokidar watchers, Server-Sent Events |
| Validation | Zod schemas, strict TypeScript |
### Data Flow
1. **Write Path**: `bd` commands write to `.beads/issues.jsonl` and Dolt DB
2. **Read Path**: UI queries Dolt SQL server (falls back to JSONL if unreachable)
3. **Realtime**: `bd` touches `.beads/last-touched` → Chokidar fires → SSE event → UI update
### Runtime Artifacts
| Directory | Purpose | Git Status |
|-----------|---------|------------|
| `.beads/` | Beads database, issues, coordination state | gitignored |
| `.agents/` | Agent skills and configuration | gitignored |
--- ---
## Project Structure ## Project Structure
```text ```text
src/ beadboard/
app/ ├── src/
page.tsx # active runtime route │ ├── app/
api/ # runtime API routes │ │ ├── page.tsx # Active runtime route
components/ │ │ └── api/ # Runtime API routes
shared/ graph/ social/ activity/ sessions/ swarm/ kanban/ │ ├── components/
hooks/ │ │ ├── shared/ # Reusable UI components
lib/ │ │ ├── graph/ # Dependency graph components
reference/ │ │ ├── social/ # Social/activity views
routes/ # archived route implementations │ │ ├── swarm/ # Swarm coordination panel
│ │ └── sessions/ # Agent session components
│ ├── hooks/ # React hooks
│ └── lib/ # Core domain logic
├── skills/
│ └── beadboard-driver/ # Agent skill package
├── install/ # Platform install scripts
├── reference/
│ └── routes/ # Archived route implementations
├── docs/ # Documentation
└── tests/ # Test suite
``` ```
### Key Files
| File | Purpose |
|------|---------|
| `src/app/page.tsx` | Main dashboard entry point |
| `src/lib/` | Core domain: Beads model, graph builders, coordination |
| `skills/beadboard-driver/SKILL.md` | Agent operating contract |
| `AGENTS.md` | Agent operating manual for this repo |
| `next.config.ts` | Route redirects and Next.js config |
---
## Routes
### Active Route
- `/` - Main dashboard (query-driven)
### View Modes
| URL | View |
|-----|------|
| `/?view=social` | Agent social feed |
| `/?view=graph` | Dependency graph |
| `/?view=activity` | Activity timeline |
### Compatibility Redirects
| Old Route | Redirects To |
|-----------|--------------|
| `/graph` | `/?view=graph` |
| `/sessions` | `/?view=social` |
| `/timeline` | `/?view=activity` |
| `/mockup` | `/` |
--- ---
## Contributing ## Contributing
1. Keep active runtime pages in `src/app` minimal.
2. Promote reusable logic into `src/lib`, `src/components`, `src/hooks`. ### Development Workflow
3. Archive non-runtime route experiments in `reference/routes`.
4. Run quality gates before merge: 1. Fork the repository
2. Create a feature branch: `git checkout -b feature/my-feature`
3. Make changes following existing patterns
4. Run quality gates:
```bash ```bash
npm run typecheck npm run typecheck
@ -236,7 +405,69 @@ npm run lint
npm run test npm run test
``` ```
5. Submit a pull request
### Code Guidelines
- Keep active runtime pages minimal in `src/app`
- Promote reusable logic to `src/lib`, `src/components`, `src/hooks`
- Archive experimental routes in `reference/routes`
- Follow existing TypeScript and React patterns
- Add tests for new functionality
### Code of Conduct
- Be respectful and inclusive
- Focus on constructive feedback
- Support newcomers to the project
---
## Scripts
```bash
npm run dev # Development server
npm run build # Production build
npm run start # Production server
npm run typecheck # TypeScript validation
npm run lint # ESLint
npm run test # Test suite
npm run video # Remotion video preview
npm run video:render # Render video
```
---
## Changelog
### v0.1.0 (Current)
- Initial release
- Multi-agent coordination system
- Graph-based dependency visualization
- Real-time updates via SSE
- Agent mail and communication system
- Swarm coordination panel
- Global project scope switching
---
## Roadmap
- Cross-view assignment controls in all major views
- Enhanced swarm UX and terminology
- Expanded global project configuration workflows
- Witness enforcement layer for agent liveness
- Additional graph analysis features
--- ---
## License ## License
MIT
[MIT](LICENSE)
---
## Acknowledgments
Built on [Beads](https://github.com/steveyegge/beads) and inspired by [Gastown](https://github.com/steveyegge/gastown). Thanks [Steve Yegge](https://github.com/steveyegge)!