agenthub-multiagent-mcp 1.46.0 → 1.48.0

package/skills/skills/multiagent-brainstorm/SKILL.md

@@ -0,0 +1,142 @@
+---
+name: multiagent-brainstorm
+description: Brainstorm a design with another AgentHub agent, mostly autonomously. Use when you want two agents (e.g. krishi-dev ↔ sumit-mobile) to work through a topic together — a background subagent drives each side, polling the shared session and exchanging turns, pausing for a human only on real decisions, and concluding with a structured outcome that seeds an OpenSpec change.
+license: MIT
+---
+
+# Multi-Agent Brainstorm
+
+Two AgentHub agents brainstorm a topic through a **server-tracked session**. Each
+side is driven by a **fully autonomous background subagent** that polls the
+session, reasons, and posts turns — surfacing to a human only when a decision
+genuinely needs one. A concluded brainstorm produces a structured outcome that
+seeds an OpenSpec change.
+
+Requires the server kill switch `AGENTHUB_BRAINSTORM_ENABLED=true` (tools return
+`brainstorm_disabled` otherwise) and `agent_register` first (the tools bind to
+your project). Runs on the latest Sonnet fine — no special model needed.
+
+## Two roles
+
+You are one of:
+
+- **initiator** — your human said "brainstorm X with `<peer>`". You call
+  `brainstorm_open`, which delivers an invite to the peer.
+- **responder** — you received a `[[BRAINSTORM INVITE]]` message (via your
+  auto-inbox at session start, or mid-session). Call `brainstorm_accept` and
+  mirror the initiator.
+
+If you got a brainstorm invite in your inbox, run the **responder** flow below.
+Otherwise, if the user asked you to brainstorm with someone, run **initiator**.
+
+## Initiator flow
+
+1. `brainstorm_open({ peer, topic, escalation })` — `escalation` is `local`
+   (default; you'll ask your local human via a decision prompt) or `slack` (the
+   subagent DMs the operator and polls for the reply). Note the returned
+   `session_id`.
+2. **Spawn the autonomous subagent** (see below) with role `initiator`,
+   the `session_id`, `after_seq=0`, the topic, and your human's framing.
+3. Wait. Handle any `NEED_HUMAN` return (see *Human escalation*).
+4. When the subagent reports `concluded`, run the **Conclusion → OpenSpec** step.
+
+## Responder flow
+
+1. `brainstorm_accept({ session_id })` (idempotent — safe if the invite was
+   redelivered).
+2. Spawn the autonomous subagent with role `responder`, the `session_id`,
+   `after_seq=0`, and the topic from the invite.
+3. Handle `NEED_HUMAN` the same way. When the subagent reports `concluded`, you're
+   done — **only the initiator authors the OpenSpec** (avoids double-proposing).
+
+## The autonomous subagent
+
+Spawn it with the `Agent` tool (background). Give it this loop, verbatim in
+spirit — it holds the whole transcript in its own context so your main session
+stays clean:
+
+```
+after_seq = 0
+loop:
+  { turns, state, turn_count } = brainstorm_poll(session_id, after_seq)
+  after_seq = max(seq of turns, after_seq)
+
+  if state != "active":
+      return { done: state }          # concluded | aborted | exhausted | abandoned
+
+  peer_turns = turns authored by the OTHER agent
+  if peer's latest turn.kind == "propose_conclude":
+      if you agree with their outcome:
+          brainstorm_conclude(session_id, outcome)   # mutual consensus
+      else:
+          brainstorm_turn(session_id, "<why not yet, what's open>")
+      continue
+
+  if it's your turn (peer has posted since your last, or you're the initiator on seq 0):
+      reason about the dialogue and form your next contribution
+      if a decision here really needs a human (scope, tradeoff, commitment):
+          return { need_human: { question, digest, after_seq } }
+      else:
+          brainstorm_turn(session_id, "<your turn>")
+          # when you believe you're done, post kind="propose_conclude" with a draft outcome instead
+      continue
+
+  # nothing new and not your move → wait for the peer
+  backoff sleep (start ~5s, cap ~30s), then re-poll
+  # if last_turn_at is older than the silence deadline, brainstorm_close(state="abandoned")
+```
+
+**Discipline:** one contribution per turn; stay on the topic; don't rubber-stamp
+— push back when the design isn't right yet; propose_conclude only when the
+problem, approach, and key decisions are actually settled.
+
+## Human escalation (return-and-resume)
+
+A background subagent can't ask a human directly. When it returns
+`{ need_human: { question, digest, after_seq } }`:
+
+- **`escalation=local`** — ask your human with `AskUserQuestion` (include the
+  `digest` for context).
+- **`escalation=slack`** — `slack_dm` the operator and poll your inbox for the
+  reply.
+
+Then **resume the same subagent** (SendMessage to its agent id, context intact)
+with the human's answer and the `after_seq` it gave you. It posts the
+human-informed turn and continues. Do **not** spawn a fresh subagent — you'd lose
+the transcript.
+
+## Peer is a headless daemon?
+
+Employee daemons (eng-ic, expert, …) can't run a live loop — one inbound message
+is one shift. If the peer never `brainstorm_accept`s but replies via ordinary
+A2A, the subagent should **fall back to async round-trips**: post a turn, then
+`check_inbox`/`brainstorm_poll` on a longer cadence, one shift per turn. The
+session still tracks turns; you just can't expect a mirror subagent on their end.
+
+## Conclusion → OpenSpec (initiator only)
+
+On `concluded`, `brainstorm_get(session_id)` returns the structured `outcome`
+(`problem`, `agreed_approach`, `key_decisions`, `open_questions`,
+`suggested_change_id`, `summary`). Then:
+
+1. **Render the outcome to your human** and ask (via `AskUserQuestion`): author
+   the OpenSpec now? — matches the repo's plan-first mandate; a human verifies the
+   agreed design before any spec is written.
+2. On approval, invoke the **`openspec:proposal`** skill seeded from the outcome
+   (use `suggested_change_id` as the change id), then `openspec_publish` to sync
+   to AgentHub (the mandate: a change on disk only isn't done).
+3. `brainstorm_link_change(session_id, change_id)` to stamp the change onto the
+   session — closes the traceability loop (brainstorm → change).
+
+## Stopping early
+
+Either operator can halt: `brainstorm_close({ session_id, reason })` →
+`aborted`. The safety backstops (`exhausted` at `max_turns`, `abandoned` on peer
+silence) fire automatically so a runaway loop or an offline peer can't hang.
+
+## Tool reference
+
+`brainstorm_open` · `brainstorm_accept` · `brainstorm_turn` · `brainstorm_poll` ·
+`brainstorm_conclude` · `brainstorm_close` · `brainstorm_get` ·
+`brainstorm_link_change`. Full design: the `multiagent-brainstorm-design` doc;
+guide: `multiagent-brainstorm-guide`.

package/dist/.agenthub/activity

@@ -1 +0,0 @@
-{"active_at":"2026-06-20T12:20:44.058Z","category":"other"}