implement broadcast messaging: send to '*' reaches all agents with hint

hive-ag3nt/prompts/agent.md

@@ -3,7 +3,7 @@ You are hyperhive agent `{label}` in a multi-agent system. The operator (recipie
 Tools (hyperhive surface):
 
 - `mcp__hyperhive__recv(wait_seconds?)` — drain one more message from your inbox (returns `(empty)` if nothing pending). Without `wait_seconds` (or with `0`) it returns immediately — a cheap "anything pending?" peek you can sprinkle between tool calls. To **wait** for work when you have nothing else useful to do this turn, call with a long wait (e.g. `wait_seconds: 180`, the max) — incoming messages wake you instantly, otherwise the call returns empty at the timeout. That's strictly better than a fixed `sleep` shell command: lower latency on new work, no busy-loop.
-- `mcp__hyperhive__send(to, body)` — message a peer (by their name) or the operator (recipient `operator`, surfaces in the dashboard). Some agents have a per-agent allow-list (`hyperhive.allowedRecipients` in their `agent.nix`) — if so the tool refuses recipients outside the list with a clear error; route through the manager (`send(to: "manager", …)`) which is always reachable.
+- `mcp__hyperhive__send(to, body)` — message a peer (by their name) or the operator (recipient `operator`, surfaces in the dashboard). Use `to: "*"` to broadcast to all agents (they receive a hint that it's a broadcast and may not need action). Some agents have a per-agent allow-list (`hyperhive.allowedRecipients` in their `agent.nix`) — if so the tool refuses recipients outside the list with a clear error; route through the manager (`send(to: "manager", …)`) which is always reachable.
 - (some agents only) **extra MCP tools** surfaced as `mcp__<server>__<tool>` — these are agent-specific (matrix client, scraper, db connector, etc.) declared in your `agent.nix` under `hyperhive.extraMcpServers`. Treat them as first-class tools alongside the hyperhive surface; the operator already auto-approved them at deploy time.
 - `mcp__hyperhive__ask_operator(question, options?, multi?, ttl_seconds?)` — surface a question to the human operator on the dashboard. Returns immediately with a question id — do NOT wait inline. When the operator answers, a system message with event `operator_answered { id, question, answer }` lands in your inbox; handle it on a future turn. Use this for clarifications, permission for risky actions, or choice between options. `options` is advisory: a short fixed-choice list when applicable, otherwise leave empty for free text. `multi: true` lets the operator pick multiple (checkboxes), answer comes back comma-joined. `ttl_seconds` auto-cancels with answer `[expired]` when the decision becomes moot.
 

hive-ag3nt/prompts/manager.md

@@ -3,7 +3,7 @@ You are the hyperhive manager `{label}` in a multi-agent system. You coordinate
 Tools (hyperhive surface):
 
 - `mcp__hyperhive__recv(wait_seconds?)` — drain one more message from your inbox. Without `wait_seconds` (or with `0`) it returns immediately — a cheap inbox peek you can drop between actions. To **wait** when you have nothing else to do, call with a long wait (e.g. `wait_seconds: 180`, the max) — you'll wake instantly on new work, otherwise return after the timeout. Use that instead of ending the turn or sleeping in a Bash command.
-- `mcp__hyperhive__send(to, body)` — message an agent (by name), another peer, or the operator (`operator` surfaces in the dashboard).
+- `mcp__hyperhive__send(to, body)` — message an agent (by name), another peer, or the operator (`operator` surfaces in the dashboard). Use `to: "*"` to broadcast to all agents (they receive a hint that it's a broadcast and may not need action).
 - `mcp__hyperhive__request_spawn(name)` — queue a brand-new sub-agent for operator approval (≤9 char name).
 - `mcp__hyperhive__kill(name)` — graceful stop on a sub-agent. No approval required.
 - `mcp__hyperhive__start(name)` — start a stopped sub-agent. No approval required.

hive-c0re/src/agent_server.rs

@@ -102,6 +102,32 @@ async fn dispatch(req: &AgentRequest, agent: &str, coord: &Arc<Coordinator>) ->
     let broker = &coord.broker;
     match req {
         AgentRequest::Send { to, body } => {
+            // Handle broadcast sends (recipient = "*")
+            if to == "*" {
+                let agents = coord.list_agents();
+                let broadcast_hint = "\n\n⚠️ _hint: this was a broadcast and may not need any action from you_";
+                let broadcast_body = format!("{}{}", body, broadcast_hint);
+                let mut errors = Vec::new();
+
+                for agent_name in agents {
+                    if let Err(e) = broker.send(&Message {
+                        from: agent.to_owned(),
+                        to: agent_name.clone(),
+                        body: broadcast_body.clone(),
+                    }) {
+                        errors.push(format!("{}: {e}", agent_name));
+                    }
+                }
+
+                if errors.is_empty() {
+                    AgentResponse::Ok
+                } else {
+                    AgentResponse::Err {
+                        message: format!("broadcast failed for agents: {}", errors.join(", ")),
+                    }
+                }
+            } else {
+                // Normal unicast send
                 match broker.send(&Message {
                     from: agent.to_owned(),
                     to: to.clone(),
@@ -113,6 +139,7 @@ async fn dispatch(req: &AgentRequest, agent: &str, coord: &Arc<Coordinator>) ->
                     },
                 }
             }
+        }
         AgentRequest::Recv { wait_seconds } => match broker
             .recv_blocking(agent, recv_timeout(*wait_seconds))
             .await

hive-c0re/src/coordinator.rs

@@ -117,6 +117,9 @@ impl Coordinator {
             let _ = std::fs::remove_file(&socket.path);
         }
     }
+    pub fn list_agents(&self) -> Vec<String> {
+        self.agents.lock().unwrap().keys().cloned().collect()
+    }
 
     /// Mark an agent as in-progress (only one state per agent for now).
     pub fn set_transient(&self, name: &str, kind: TransientKind) {