Blackboard

Implement the Blackboard pattern in this codebase, using the LLM client and language we already use.

## Goal

Solve an open-ended problem by letting a control model pick, each round, which specialist agents read a shared blackboard and add to it, until a critic judges that the board holds a solution.

## How it works

1. Define each specialist with a name and a one-line capability, and include the critic in that list. Create the blackboard as a set of entries with ids (id, author, round, content), and post the problem as entry 1.
2. Each round, call the control model with the Control unit prompt, passing the specialist list and the board. Parse its JSON reply into a list of one to three names to activate.
3. Call each selected specialist with the Specialist prompt and the whole board. Parse its JSON reply: add a new entry, or revise or retract an existing one by id, with a reason. Specialists selected in the same round can run in parallel.
4. When the control model selects the critic, call it with the Critic prompt. If it judges the problem solved, return its solution; otherwise add its objection to the board for the next round.
5. After each round, run a cleaning step (or a cleaner specialist) that removes superseded, retracted or redundant entries, so the board stays a current picture rather than a log. Never remove the problem entry.

## Prompts

### Control unit prompt

```markdown
You are the control unit of a team of specialists who work on a shared blackboard.

<specialists>
{{specialists}}
</specialists>

<blackboard>
{{board}}
</blackboard>

Decide which specialists should act next, based on what is on the board and
what is still missing. Choose the critic when the board may already hold a solution.
Respond in JSON: {"activate": ["<name>", ...], "why": "one sentence"}
Activate between one and three specialists.
```

### Specialist prompt

```markdown
You are the {{name}}: {{capability}}.
You work with other specialists through a shared blackboard. You cannot talk
to them directly; anything you write goes on the board for all to read.

<blackboard>
{{board}}
</blackboard>

Move the problem forward from your expertise. Either add one entry (a finding,
or a hypothesis with its evidence), or revise or retract an existing entry by id
when the evidence shows it is wrong or superseded.
Do not repeat what is already on the board. Keep it under 120 words.
Respond in JSON, one of:
{"add": "..."}
{"revise": <entry id>, "content": "...", "reason": "..."}
{"retract": <entry id>, "reason": "..."}
```

### Critic prompt

```markdown
You are the critic. Decide whether the blackboard holds a complete,
well-supported solution to the problem.

<blackboard>
{{board}}
</blackboard>

Respond in JSON:
{"solved": true|false,
 "best_candidate": "the best answer the board supports so far, citing entry ids",
 "solution": "the solution, assembled from the board, if solved",
 "objection": "what is missing or unsupported, if not solved"}
```

## Stop rule

Stop when the critic judges the problem solved, or after 8 rounds (bMAS used 4; allow more for problems that need several lines of evidence). On the cap, return the board and the critic's latest best_candidate with a status of unsolved. If the control model selects no one twice in a row, run the critic.

## Requirements

- Specialists never message each other; every contribution goes through the board, tagged with its author and round.
- Validate the control model's selection against the specialist list, and drop unknown names rather than failing the round.
- Cap the rounds with a parameter (default 8).
- Log each round: who was selected, why, and every add, revise or retract with its reason and token count.
- Add a stub-LLM test: control selects [logs, db], then [net], then [critic]; each specialist adds one entry, the cleaner removes nothing, the critic replies solved. Assert 3 rounds ran, the board holds 4 entries before the critic, and the critic's solution is returned.