feat: war-room multi-agent mode

[casperpanduro]

Overview

Add a storm war-room command that spins up multiple named Claude Code agents
in a shared workspace. Instead of one agent working alone, a team of agents with
defined roles collaborate, debate, and divide work until the task is done.

Motivation

Complex issues benefit from multiple perspectives — an Architect to plan, an
Engineer to implement, and a QA agent to validate. Rather than one agent doing
everything sequentially, war-room lets them run in parallel and self-organize.

Proposed CLI

storm war-room --issue 42
storm war-room --issue 42 --agents architect,engineer,qa
storm war-room --prompt "Build a dark mode toggle"

How it should work

1. Storm reads the issue (or prompt) and creates a shared war-room session
2. Each agent is a separate claude -p process with a defined role + personality
3. Agents communicate via a shared append-only event log (JSON file or SQLite)
4. Each agent has a kibble budget — expensive operations (bash, file reads) cost kibble
5. Agents can use these tools:
   • talk [room] [message] — post a message to the shared room
   • bash [command] — run a shell command (costs kibble)
   • transfer-kibble [amount] [agent] — send budget to another agent
   • read-file [path] — read a file (costs kibble)
6. An orchestrator loop manages turn order (event-driven: agent A talks → agent B is prompted)
7. When all agents agree the task is done, one outputs %%STORM_DONE%% and a PR is opened

Agent roles (defaults)

Agent	Role	Responsibility
Storm	Architect	Reads the issue, creates a plan, delegates tasks
Johnny	Engineer	Implements the code based on the plan
Alan	QA	Runs tests, reports failures back to the room

Roles should be configurable via .storm/agents/ directory (same primitive pattern
as contexts and instructions).

.storm/agents/ structure

.storm/
└── agents/
├── architect/
│ └── AGENT.md # role description, kibble budget, personality
├── engineer/
│ └── AGENT.md
└── qa/
└── AGENT.md

AGENT.md frontmatter

---

name: Johnny
role: Engineer
kibble: 20
model: sonnet

You are Luna, a pragmatic senior engineer. You implement what the Architect
specifies, ask clarifying questions when the spec is unclear, and always run
the typecheck before declaring work done.

Shared event log format

Each event is a JSON line appended to .storm/session/{id}/events.jsonl:

{ "ts": 1234567890, "agent": "Johnny", "type": "talk", "room": "war-room", "data": "..." }
{ "ts": 1234567890, "agent": "Storm", "type": "bash", "room": "war-room", "data": "git diff" }
{ "ts": 1234567890, "agent": "Johnny", "type": "kibble", "room": "war-room", "data": { "to": "Storm", "amount": 3 } }

Terminal UI

Split view similar to the reference screenshot:

• Left panel: agent list with kibble budgets + room membership
• Right panel: live event stream
• Bottom panel: most recent agent messages

Acceptance criteria

• storm war-room --issue <n> starts a session with default agents
• Each agent runs as an independent claude -p process
• Agents communicate only via the shared event log (no direct process coupling)
• Kibble budget is enforced — agent stops acting when budget hits 0
• Terminal UI updates in real time
• Session ends and PR is opened when %%STORM_DONE%% is emitted
• Agent roles are configurable via .storm/agents/

References

• Inspired by ralphify and otto-agent
• Storm base tool: see existing storm run implementation

[casperpanduro]

Pull request created: #39