diff --git a/src/roundtable/web/viewer.css b/src/roundtable/web/viewer.css
index 10ff4a9..9d89d48 100644
--- a/src/roundtable/web/viewer.css
+++ b/src/roundtable/web/viewer.css
@@ -550,6 +550,15 @@
background: var(--rt-brand);
animation: pulse 2s infinite;
}
+ .status-badge.assembling {
+ background: rgba(245, 158, 11, 0.12);
+ color: var(--rt-warning);
+ border: 1px solid rgba(245, 158, 11, 0.35);
+ }
+ .status-badge.assembling .badge-dot {
+ background: var(--rt-warning);
+ animation: pulse 1.8s infinite;
+ }
.status-badge.ended {
background: var(--rt-success-bg);
color: var(--rt-success);
@@ -633,6 +642,88 @@
}
@keyframes spin { to { transform: rotate(360deg); } }
+ .dispatch-status-panel {
+ background: rgba(15, 23, 42, 0.42);
+ border: 1px solid var(--rt-border);
+ border-radius: var(--rt-radius-md);
+ padding: var(--rt-space-4);
+ margin: 0 0 var(--rt-space-4);
+ box-shadow: var(--rt-shadow-sm);
+ }
+ .dispatch-panel-header {
+ display: flex;
+ align-items: center;
+ justify-content: space-between;
+ gap: var(--rt-space-3);
+ margin-bottom: var(--rt-space-3);
+ }
+ .dispatch-panel-title {
+ color: var(--rt-text-primary);
+ font-size: var(--rt-font-size-sm);
+ font-weight: 700;
+ }
+ .dispatch-panel-meta {
+ color: var(--rt-text-muted);
+ font-size: var(--rt-font-size-xs);
+ margin-top: 2px;
+ }
+ .dispatch-rows {
+ display: flex;
+ flex-direction: column;
+ gap: var(--rt-space-2);
+ }
+ .dispatch-row {
+ display: grid;
+ grid-template-columns: minmax(0, 1fr) auto;
+ gap: var(--rt-space-3);
+ align-items: center;
+ padding: var(--rt-space-3);
+ background: rgba(255, 255, 255, 0.03);
+ border: 1px solid var(--rt-border);
+ border-radius: var(--rt-radius-sm);
+ }
+ .dispatch-row-title {
+ display: flex;
+ align-items: center;
+ flex-wrap: wrap;
+ gap: var(--rt-space-2);
+ min-width: 0;
+ }
+ .dispatch-mode {
+ color: var(--rt-text-primary);
+ font-size: var(--rt-font-size-sm);
+ font-weight: 600;
+ }
+ .dispatch-ready {
+ padding: 1px 7px;
+ border-radius: var(--rt-radius-full);
+ font-size: var(--rt-font-size-xs);
+ font-weight: 700;
+ }
+ .dispatch-ready.ready {
+ color: var(--rt-success);
+ background: var(--rt-success-bg);
+ }
+ .dispatch-ready.waiting {
+ color: var(--rt-warning);
+ background: rgba(245, 158, 11, 0.12);
+ }
+ .dispatch-row-meta {
+ color: var(--rt-text-muted);
+ font-size: var(--rt-font-size-xs);
+ margin-top: 3px;
+ }
+ .dispatch-row-counts {
+ display: flex;
+ align-items: center;
+ justify-content: flex-end;
+ flex-wrap: wrap;
+ gap: var(--rt-space-2);
+ color: var(--rt-text-secondary);
+ font-size: var(--rt-font-size-xs);
+ text-align: right;
+ }
+
/* Participant avatar */
.avatar {
width: 36px; height: 36px;
@@ -1719,4 +1810,4 @@
}
.replay-speed-btn.active {
background: var(--rt-replay-accent); color: #fff;
- }
\ No newline at end of file
+ }
diff --git a/src/roundtable/web/viewer.js b/src/roundtable/web/viewer.js
index 770ad72..ac33811 100644
--- a/src/roundtable/web/viewer.js
+++ b/src/roundtable/web/viewer.js
@@ -24,6 +24,8 @@
roundSummaries: [],
roundSummarySet: new Set(),
streamSpeechMap: new Map(),
+ dispatches: [],
+ dispatchSummary: null,
};
// Token batching buffer (rAF-based)
@@ -50,6 +52,7 @@
const $conclusionContent = document.getElementById('conclusionContent');
const $revokedState = document.getElementById('revokedState');
const $scrollBottomBtn = document.getElementById('scrollBottomBtn');
+ const $dispatchStatusPanel = document.getElementById('dispatchStatusPanel');
// ---- Auto-scroll logic ----
const mainEl = document.querySelector('main');
@@ -235,6 +238,12 @@
updateStatusUI();
}
+ if (Array.isArray(data.dispatches)) {
+ state.dispatches = data.dispatches;
+ state.dispatchSummary = data.dispatch_summary || null;
+ renderDispatchStatus();
+ }
+
// Conclusion
if (data.conclusion && !state.conclusion) {
state.conclusion = data.conclusion;
@@ -779,6 +788,7 @@
function updateStatusUI() {
const statusMap = {
waiting: { cls: 'waiting', label: t('statusWaiting') },
+ assembling: { cls: 'assembling', label: t('statusAssembling') },
active: { cls: 'live', label: 'LIVE' },
concluded: { cls: 'ended', label: t('statusConcluded') },
};
@@ -791,6 +801,76 @@
}
}
+ function dispatchCounts(item) {
+ const summons = Array.isArray(item?.summons) ? item.summons : [];
+ const counts = Object.assign(
+ { pending: 0, delivered: 0, accepted: 0, declined: 0, timeout: 0, failed: 0 },
+ item?.readiness?.counts || {}
+ );
+ if (!item?.readiness?.counts && summons.length > 0) {
+ for (const summon of summons) {
+ const status = summon.status || 'pending';
+ counts[status] = (counts[status] || 0) + 1;
+ }
+ }
+ return counts;
+ }
+
+ function renderDispatchStatus() {
+ if (!$dispatchStatusPanel) return;
+ const dispatches = Array.isArray(state.dispatches) ? state.dispatches : [];
+ if (dispatches.length === 0 || state.status === 'concluded') {
+ $dispatchStatusPanel.classList.add('hidden');
+ $dispatchStatusPanel.innerHTML = '';
+ return;
+ }
+
+ const summary = state.dispatchSummary || {};
+ const total = Number(summary.total_summons ?? dispatches.reduce((sum, item) => sum + (item.summons?.length || 0), 0));
+ const accepted = Number(summary.accepted || 0);
+ const waiting = Number(summary.pending || 0) + Number(summary.delivered || 0);
+ const failed = Number(summary.failed || 0) + Number(summary.timeout || 0);
+ const title = state.status === 'assembling' ? t('dispatchAssembling') : t('dispatchStatus');
+ const rows = dispatches.map(item => {
+ const dispatch = item.dispatch || {};
+ const readiness = item.readiness || {};
+ const counts = dispatchCounts(item);
+ const itemTotal = Number(readiness.total ?? item.summons?.length ?? 0);
+ const modeLabel = dispatch.mode === 'managed' ? t('dispatchModeManaged') : t('dispatchModeFederated');
+ const readyClass = readiness.ready ? 'ready' : 'waiting';
+ const readyText = readiness.ready ? t('dispatchReady') : t('dispatchWaiting');
+ const policy = `${escapeHtml(dispatch.start_policy || 'quorum')} · ${t('dispatchMinAccepts', { count: dispatch.min_accepts ?? 1 })}`;
+ return `
+
+
+
+ ${modeLabel}
+ ${readyText}
+
+
${policy}
+
+
+ ${t('dispatchAccepted')}: ${Number(counts.accepted || 0)}/${itemTotal}
+ ${t('dispatchPending')}: ${Number(counts.pending || 0) + Number(counts.delivered || 0)}
+ ${t('dispatchDeclined')}: ${Number(counts.declined || 0)}
+ ${Number(counts.failed || 0) || Number(counts.timeout || 0) ? `${t('dispatchFailed')}: ${Number(counts.failed || 0) + Number(counts.timeout || 0)}` : ''}
+
+
+ `;
+ }).join('');
+
+ $dispatchStatusPanel.innerHTML = `
+
+
${rows}
+ `;
+ $dispatchStatusPanel.classList.remove('hidden');
+ }
+
function showRevoked() {
$revokedState.classList.remove('hidden');
if (eventSource) eventSource.close();
@@ -1599,4 +1679,4 @@
});
}
- connectSSE();
\ No newline at end of file
+ connectSSE();
diff --git a/src/roundtable/web_publisher.py b/src/roundtable/web_publisher.py
index 5b952a6..175fea4 100644
--- a/src/roundtable/web_publisher.py
+++ b/src/roundtable/web_publisher.py
@@ -123,6 +123,7 @@ def start(
token: str | None = None,
topic: str | None = None,
participants: list[dict[str, Any]] | None = None,
+ status: str = "active",
expires_at: float | None = None,
) -> str:
"""Start the web viewer service and return the full URL.
@@ -136,6 +137,7 @@ def start(
self._token = token or _generate_token()
self._topic = topic or f"Discussion {discussion_id}"
self._participants = participants or []
+ self._status = status
self._expires_at = expires_at
self._write_discussion_json()
@@ -455,7 +457,7 @@ def _write_discussion_json(self) -> None:
"""Write current state to discussion.json with atomic file lock."""
token_hash = _hash_token(self._token) if self._token else None
data = {
- "schema_version": 2,
+ "schema_version": 3,
"discussion_id": self._discussion_id,
"topic": self._topic,
"status": self._status,
@@ -631,6 +633,12 @@ def _write_discussion_json_raw(self, data: dict[str, Any]) -> None:
if existing.get("status") == "concluded" and data.get("status") != "concluded":
data["status"] = "concluded"
self._status = "concluded"
+ elif existing.get("status") == "active" and data.get("status") == "assembling":
+ data["status"] = "active"
+ self._status = "active"
+ elif existing.get("status") == "cancelled" and data.get("status") in {"assembling", "active"}:
+ data["status"] = "cancelled"
+ self._status = "cancelled"
existing_conclusion = existing.get("conclusion")
new_conclusion = data.get("conclusion")
@@ -686,6 +694,28 @@ def get_event_sig(ev: dict[str, Any]) -> Any:
if existing.get("password_hash") and not data.get("password_hash"):
data["password_hash"] = existing["password_hash"]
+ # 8. Preserve cross-process dispatch snapshots and joiners.
+ # The in-memory publisher may have been created before summoned
+ # agents accepted. Avoid reverting DB-backed sync fields.
+ for key in ("dispatches", "dispatch_summary"):
+ if key in existing and key not in data:
+ data[key] = existing[key]
+
+ existing_participants = existing.get("participants", [])
+ new_participants = data.get("participants", [])
+ if existing_participants:
+ participant_map = {
+ p.get("profile") or p.get("participant"): p
+ for p in existing_participants
+ if p.get("profile") or p.get("participant")
+ }
+ for p in new_participants:
+ key = p.get("profile") or p.get("participant")
+ if key:
+ participant_map[key] = p
+ data["participants"] = list(participant_map.values())
+ self._participants = data["participants"]
+
with open(tmp, "w", encoding="utf-8") as f:
json.dump(data, f, ensure_ascii=False, indent=2)
f.flush()
diff --git a/src/roundtable/web_sync.py b/src/roundtable/web_sync.py
index 0c86416..af2205d 100644
--- a/src/roundtable/web_sync.py
+++ b/src/roundtable/web_sync.py
@@ -28,6 +28,63 @@ class WebDiscussionSync:
def __init__(self, db: RoundtableDB):
self.db = db
+ def _participants_snapshot(self, conn: sqlite3.Connection, discussion_id: str) -> list[dict[str, Any]]:
+ return [
+ {
+ "profile": participant.participant,
+ "participant": participant.participant,
+ "display_name": participant.display_name or participant.participant,
+ "role": participant.role or "",
+ "perspective": participant.perspective or "",
+ "is_active": participant.is_active,
+ }
+ for participant in self.db.get_participants(conn, discussion_id)
+ ]
+
+ def _dispatch_snapshot(
+ self,
+ conn: sqlite3.Connection,
+ discussion_id: str,
+ ) -> tuple[list[dict[str, Any]], dict[str, Any]]:
+ dispatch_items: list[dict[str, Any]] = []
+ summary = {
+ "count": 0,
+ "total_summons": 0,
+ "accepted": 0,
+ "declined": 0,
+ "pending": 0,
+ "delivered": 0,
+ "failed": 0,
+ "timeout": 0,
+ "ready": False,
+ "active": 0,
+ "waiting": 0,
+ }
+ for dispatch in self.db.list_dispatches(conn, discussion_id=discussion_id):
+ readiness_result = self.db.apply_dispatch_readiness(conn, dispatch["id"])
+ updated_dispatch = readiness_result.get("dispatch") or dispatch
+ summons = self.db.get_summons(conn, dispatch_id=dispatch["id"])
+ readiness = readiness_result.get("readiness") or {}
+ counts = readiness.get("counts") or {}
+ for key in ("accepted", "declined", "pending", "delivered", "failed", "timeout"):
+ summary[key] += int(counts.get(key, 0) or 0)
+ summary["count"] += 1
+ summary["total_summons"] += len(summons)
+ if readiness.get("ready"):
+ summary["ready"] = True
+ if updated_dispatch.get("status") == "active":
+ summary["active"] += 1
+ elif updated_dispatch.get("status") == "pending":
+ summary["waiting"] += 1
+ dispatch_items.append(
+ {
+ "dispatch": updated_dispatch,
+ "readiness": readiness,
+ "summons": summons,
+ }
+ )
+ return dispatch_items, summary
+
def append_token_stream(self, web_dir: Path, event: dict[str, Any]) -> None:
target = web_dir / "token_stream.jsonl"
try:
@@ -63,11 +120,29 @@ def sync_state(self, web_dir: Path, discussion_id: str, conn: sqlite3.Connection
if not disc:
return
+ dispatches, dispatch_summary = self._dispatch_snapshot(conn, discussion_id)
+ refreshed_disc = self.db.get_discussion(conn, discussion_id)
+ if refreshed_disc:
+ disc = refreshed_disc
+
old_status = data.get("status")
if old_status != disc.status:
data["status"] = disc.status
changed = True
+ participants = self._participants_snapshot(conn, discussion_id)
+ if data.get("participants") != participants:
+ data["participants"] = participants
+ changed = True
+
+ if data.get("dispatches") != dispatches:
+ data["dispatches"] = dispatches
+ changed = True
+
+ if data.get("dispatch_summary") != dispatch_summary:
+ data["dispatch_summary"] = dispatch_summary
+ changed = True
+
if disc.status == "concluded" and data.get("conclusion") != disc.conclusion:
data["conclusion"] = disc.conclusion
changed = True
diff --git a/tests/mcp/test_codex_bridge.py b/tests/mcp/test_codex_bridge.py
index ef6026e..e5dd843 100644
--- a/tests/mcp/test_codex_bridge.py
+++ b/tests/mcp/test_codex_bridge.py
@@ -118,6 +118,8 @@ def test_codex_parser_accepts_bridge_options():
"Codex Product",
"--db",
"/tmp/roundtable.db",
+ "--auth-token",
+ "codex-secret",
]
)
@@ -126,3 +128,4 @@ def test_codex_parser_accepts_bridge_options():
assert args.host == "localhost"
assert args.display_name == "Codex Product"
assert args.db == "/tmp/roundtable.db"
+ assert args.auth_token == "codex-secret"
diff --git a/tests/mcp/test_generic_bridge.py b/tests/mcp/test_generic_bridge.py
index b25a216..40ac154 100644
--- a/tests/mcp/test_generic_bridge.py
+++ b/tests/mcp/test_generic_bridge.py
@@ -57,11 +57,11 @@ def _get(port: int, path: str) -> dict:
return json.loads(r.read())
-def _post(port: int, path: str, body: dict) -> dict:
+def _post(port: int, path: str, body: dict, headers: dict[str, str] | None = None) -> dict:
req = urllib.request.Request(
f"http://127.0.0.1:{port}{path}",
data=json.dumps(body).encode(),
- headers={"Content-Type": "application/json"},
+ headers={"Content-Type": "application/json", **(headers or {})},
method="POST",
)
try:
@@ -151,6 +151,92 @@ def test_tool_dispatch_register_and_list(bridge):
assert "peer" in ids
+def test_auth_token_protects_mutating_endpoints(tmp_path):
+ port = _free_port()
+ bridge = GenericBridge(
+ agent_id="wb-secure",
+ platform="workbuddy",
+ port=port,
+ auth_token="bridge-secret",
+ db_path=str(tmp_path / "secure.db"),
+ )
+ bridge.start()
+ _wait_ready(port)
+ try:
+ denied = _post(
+ port,
+ "/tool",
+ {"name": "roundtable_list_agents", "arguments": {}},
+ )
+ assert denied["error"] == "unauthorized"
+
+ allowed = _post(
+ port,
+ "/tool",
+ {"name": "roundtable_list_agents", "arguments": {}},
+ headers={"Authorization": "Bearer bridge-secret"},
+ )
+ assert "agents" in allowed
+
+ conn = bridge._db.connect()
+ try:
+ public_agent = bridge._db.get_agent(conn, "wb-secure")
+ private_agent = bridge._db.get_agent(conn, "wb-secure", include_private=True)
+ finally:
+ conn.close()
+ assert "_bridge_auth_token" not in public_agent["metadata"]
+ assert private_agent["metadata"]["_bridge_auth_token"] == "bridge-secret"
+ finally:
+ bridge.stop()
+
+
+def test_http_summon_delivery_uses_registered_bridge_auth_token(tmp_path):
+ port = _free_port()
+ db_path = tmp_path / "secure-summon.db"
+ invited = GenericBridge(
+ agent_id="wb-secure-summoned",
+ platform="workbuddy",
+ port=port,
+ auth_token="summon-secret",
+ db_path=str(db_path),
+ )
+ invited.start()
+ _wait_ready(port)
+ try:
+ db = RoundtableDB(db_path)
+ core = RoundtableCore(db=db)
+ handle_tool_call(
+ core,
+ db,
+ "roundtable_register_agent",
+ {
+ "agent_id": "coord",
+ "platform": "claude-code",
+ "skills": ["agent-roundtable"],
+ "availability": "idle",
+ },
+ )
+
+ result = handle_tool_call(
+ core,
+ db,
+ "roundtable_summon_agents",
+ {
+ "topic": "Secure HTTP summon",
+ "coordinator_agent_id": "coord",
+ "agent_ids": ["wb-secure-summoned"],
+ "required_skill": "agent-roundtable",
+ "min_accepts": 1,
+ },
+ )
+
+ assert result["ok"] is True
+ assert result["deliveries"][0]["ok"] is True
+ assert result["summons"][0]["status"] == "accepted"
+ finally:
+ invited.stop()
+
+
def test_http_invite_delivery_accepts_and_adds_participant(tmp_path):
port = _free_port()
db_path = tmp_path / "shared.db"
@@ -208,6 +294,64 @@ def test_http_invite_delivery_accepts_and_adds_participant(tmp_path):
invited.stop()
+def test_http_summon_delivery_accepts_and_activates_discussion(tmp_path):
+ port = _free_port()
+ db_path = tmp_path / "summon.db"
+ invited = GenericBridge(
+ agent_id="wb-summoned",
+ platform="workbuddy",
+ port=port,
+ display_name="Summoned WorkBuddy",
+ db_path=str(db_path),
+ )
+ invited.start()
+ _wait_ready(port)
+ try:
+ db = RoundtableDB(db_path)
+ core = RoundtableCore(db=db)
+ handle_tool_call(
+ core,
+ db,
+ "roundtable_register_agent",
+ {
+ "agent_id": "coord",
+ "platform": "claude-code",
+ "skills": ["agent-roundtable"],
+ "availability": "idle",
+ },
+ )
+
+ result = handle_tool_call(
+ core,
+ db,
+ "roundtable_summon_agents",
+ {
+ "topic": "HTTP summon",
+ "coordinator_agent_id": "coord",
+ "agent_ids": ["wb-summoned"],
+ "required_skill": "agent-roundtable",
+ "min_accepts": 1,
+ },
+ )
+
+ assert result["ok"] is True
+ assert result["deliveries"][0]["ok"] is True
+ conn = db.connect()
+ try:
+ summons = db.get_summons(conn, discussion_id=result["discussion_id"], agent_id="wb-summoned")
+ active = db.get_active_participant_names(conn, result["discussion_id"])
+ discussion = db.get_discussion(conn, result["discussion_id"])
+ dispatch = db.get_dispatch(conn, result["dispatch"]["id"])
+ finally:
+ conn.close()
+ assert summons[0]["status"] == "accepted"
+ assert "wb-summoned" in active
+ assert discussion.status == "active"
+ assert dispatch["status"] == "active"
+ finally:
+ invited.stop()
+
+
def test_bridge_forwards_turn_to_webhook(tmp_path):
webhook_events: list[dict] = []
webhook_port = _free_port()
diff --git a/tests/mcp/test_inbox.py b/tests/mcp/test_inbox.py
index 1772da9..890dc1c 100644
--- a/tests/mcp/test_inbox.py
+++ b/tests/mcp/test_inbox.py
@@ -73,6 +73,14 @@ def test_mark_inbox_read_idempotent(db):
conn.close()
+def test_mark_inbox_read_empty_list_is_noop(db):
+ conn = db.connect()
+ try:
+ assert db.mark_inbox_read(conn, []) == 0
+ finally:
+ conn.close()
+
+
def test_invitation_lifecycle(db):
conn = db.connect()
try:
diff --git a/tests/mcp/test_tools.py b/tests/mcp/test_tools.py
index 489a59e..6431e1d 100644
--- a/tests/mcp/test_tools.py
+++ b/tests/mcp/test_tools.py
@@ -59,6 +59,49 @@ def test_list_agents(setup):
assert len(result["agents"]) == 2
+def test_register_agent_metadata_filters_and_heartbeat(setup):
+ core, db = setup
+ handle_tool_call(
+ core,
+ db,
+ "roundtable_register_agent",
+ {
+ "agent_id": "codex-agent",
+ "platform": "codex",
+ "skills": ["agent-roundtable"],
+ "availability": "idle",
+ "accept_policy": "auto",
+ },
+ )
+ handle_tool_call(
+ core,
+ db,
+ "roundtable_register_agent",
+ {
+ "agent_id": "plain-agent",
+ "platform": "cursor",
+ "skills": ["other"],
+ "availability": "idle",
+ },
+ )
+
+ filtered = handle_tool_call(
+ core,
+ db,
+ "roundtable_list_agents",
+ {"required_skill": "agent-roundtable", "availability": "idle"},
+ )
+ assert [agent["agent_id"] for agent in filtered["agents"]] == ["codex-agent"]
+
+ heartbeat = handle_tool_call(
+ core,
+ db,
+ "roundtable_heartbeat",
+ {"agent_id": "codex-agent", "availability": "busy"},
+ )
+ assert heartbeat["metadata"]["availability"] == "busy"
+
+
def test_create_discussion_and_invite(setup):
core, db = setup
handle_tool_call(
@@ -101,6 +144,229 @@ def test_create_discussion_and_invite(setup):
assert inbox["messages"][0]["type"] == "invitation"
+def test_summon_agents_creates_assembling_discussion_and_activates_on_accept(setup):
+ core, db = setup
+ handle_tool_call(
+ core,
+ db,
+ "roundtable_register_agent",
+ {
+ "agent_id": "coord",
+ "platform": "claude-code",
+ "skills": ["agent-roundtable"],
+ "availability": "idle",
+ },
+ )
+ handle_tool_call(
+ core,
+ db,
+ "roundtable_register_agent",
+ {
+ "agent_id": "agent-1",
+ "platform": "codex",
+ "skills": ["agent-roundtable"],
+ "availability": "idle",
+ },
+ )
+
+ summon = handle_tool_call(
+ core,
+ db,
+ "roundtable_summon_agents",
+ {
+ "topic": "Summon flow",
+ "coordinator_agent_id": "coord",
+ "required_skill": "agent-roundtable",
+ "availability": "idle",
+ "agent_ids": ["agent-1"],
+ "min_accepts": 1,
+ },
+ )
+
+ assert summon["ok"] is True
+ assert summon["created"]["status"] == "assembling"
+ assert summon["summons"][0]["agent_id"] == "agent-1"
+ assert summon["readiness"]["ready"] is False
+
+ inbox = handle_tool_call(core, db, "roundtable_inbox", {"agent_id": "agent-1", "mark_read": False})
+ assert inbox["messages"][0]["type"] == "summon"
+
+ accepted = handle_tool_call(
+ core,
+ db,
+ "roundtable_accept_summon",
+ {"discussion_id": summon["discussion_id"], "agent_id": "agent-1"},
+ )
+ assert accepted["status"] == "accepted"
+ assert accepted["dispatch"]["dispatch"]["status"] == "active"
+
+ status = handle_tool_call(core, db, "roundtable_status", {"discussion_id": summon["discussion_id"]})
+ assert status["status"] == "active"
+ assert status["participant_count"] == 1
+
+
+def test_dispatch_status_by_discussion(setup):
+ core, db = setup
+ handle_tool_call(core, db, "roundtable_register_agent", {"agent_id": "coord", "platform": "claude-code"})
+ handle_tool_call(
+ core,
+ db,
+ "roundtable_register_agent",
+ {
+ "agent_id": "agent-1",
+ "platform": "codex",
+ "skills": ["agent-roundtable"],
+ "availability": "idle",
+ },
+ )
+ summon = handle_tool_call(
+ core,
+ db,
+ "roundtable_summon_agents",
+ {
+ "topic": "Dispatch status",
+ "coordinator_agent_id": "coord",
+ "agent_ids": ["agent-1"],
+ "required_skill": "agent-roundtable",
+ },
+ )
+
+ status = handle_tool_call(core, db, "roundtable_dispatch_status", {"discussion_id": summon["discussion_id"]})
+ assert status["ok"] is True
+ assert status["count"] == 1
+ assert status["dispatches"][0]["dispatch"]["id"] == summon["dispatch"]["id"]
+
+
+def test_retry_summon_requeues_without_duplicate_rows(setup):
+ core, db = setup
+ handle_tool_call(core, db, "roundtable_register_agent", {"agent_id": "coord", "platform": "claude-code"})
+ handle_tool_call(
+ core,
+ db,
+ "roundtable_register_agent",
+ {
+ "agent_id": "agent-1",
+ "platform": "codex",
+ "skills": ["agent-roundtable"],
+ "availability": "idle",
+ },
+ )
+ summon = handle_tool_call(
+ core,
+ db,
+ "roundtable_summon_agents",
+ {
+ "topic": "Retry summon",
+ "coordinator_agent_id": "coord",
+ "agent_ids": ["agent-1"],
+ "required_skill": "agent-roundtable",
+ "dispatch_timeout_seconds": 1,
+ },
+ )
+ summon_id = summon["summons"][0]["id"]
+
+ conn = db.connect()
+ try:
+ db.mark_summon_delivered(conn, summon_id, {"ok": False, "error": "network"})
+ finally:
+ conn.close()
+
+ retry = handle_tool_call(
+ core,
+ db,
+ "roundtable_retry_summon",
+ {
+ "dispatch_id": summon["dispatch"]["id"],
+ "retry_timeout_seconds": 30,
+ "redeliver_http": False,
+ },
+ )
+
+ assert retry["ok"] is True
+ assert retry["count"] == 1
+ assert retry["retried"][0]["id"] == summon_id
+ assert retry["retried"][0]["status"] == "pending"
+
+ conn = db.connect()
+ try:
+ summons = db.get_summons(conn, dispatch_id=summon["dispatch"]["id"])
+ inbox = db.read_inbox(conn, "agent-1", unread_only=False)
+ events = db.list_summon_events(conn, summon_id=summon_id)
+ finally:
+ conn.close()
+ assert len(summons) == 1
+ assert len([msg for msg in inbox if msg["type"] == "summon"]) == 2
+ assert "summon.retry" in [event["event"] for event in events]
+
+
+def test_summon_agents_allows_terminal_dispatch_retry_with_same_key(setup):
+ core, db = setup
+ handle_tool_call(core, db, "roundtable_register_agent", {"agent_id": "coord", "platform": "claude-code"})
+ handle_tool_call(
+ core,
+ db,
+ "roundtable_register_agent",
+ {
+ "agent_id": "agent-1",
+ "platform": "codex",
+ "skills": ["agent-roundtable"],
+ "availability": "idle",
+ },
+ )
+ first = handle_tool_call(
+ core,
+ db,
+ "roundtable_summon_agents",
+ {
+ "topic": "Retry dispatch key",
+ "coordinator_agent_id": "coord",
+ "agent_ids": ["agent-1"],
+ "required_skill": "agent-roundtable",
+ "idempotency_key": "mcp-retry-key",
+ },
+ )
+
+ conn = db.connect()
+ try:
+ db.update_dispatch_status(conn, first["dispatch"]["id"], "cancelled")
+ finally:
+ conn.close()
+
+ second = handle_tool_call(
+ core,
+ db,
+ "roundtable_summon_agents",
+ {
+ "discussion_id": first["discussion_id"],
+ "coordinator_agent_id": "coord",
+ "agent_ids": ["agent-1"],
+ "required_skill": "agent-roundtable",
+ "idempotency_key": "mcp-retry-key",
+ "allow_terminal_retry": True,
+ },
+ )
+
+ assert second["ok"] is True
+ assert second["dispatch"]["id"] != first["dispatch"]["id"]
+ assert second["summons"][0]["id"] == first["summons"][0]["id"]
+ assert second["summons"][0]["dispatch_id"] == second["dispatch"]["id"]
+ assert second["summons"][0]["status"] == "pending"
+
+ conn = db.connect()
+ try:
+ summons = db.get_summons(conn, discussion_id=first["discussion_id"], agent_id="agent-1")
+ old_dispatch = db.get_dispatch(conn, first["dispatch"]["id"])
+ old_events = db.list_summon_events(conn, dispatch_id=first["dispatch"]["id"])
+ summon_events = db.list_summon_events(conn, summon_id=first["summons"][0]["id"])
+ finally:
+ conn.close()
+
+ assert len(summons) == 1
+ assert old_dispatch["idempotency_key"] == f"mcp-retry-key#released:{first['dispatch']['id']}"
+ assert "dispatch.idempotency_key.released" in [event["event"] for event in old_events]
+ assert "summon.reused_for_retry" in [event["event"] for event in summon_events]
+
+
def test_create_discussion_disables_web_by_default(setup, monkeypatch):
core, db = setup
calls = []
diff --git a/tests/test_agent_runtime.py b/tests/test_agent_runtime.py
new file mode 100644
index 0000000..3f46633
--- /dev/null
+++ b/tests/test_agent_runtime.py
@@ -0,0 +1,79 @@
+"""Tests for the lightweight agent daemon runtime."""
+
+from __future__ import annotations
+
+from roundtable.agent import AgentDaemon
+from roundtable.db import RoundtableDB
+from roundtable.mcp.tools import handle_tool_call
+
+
+def test_agent_daemon_registers_heartbeats_and_accepts_summon(tmp_path):
+ db = RoundtableDB(tmp_path / "daemon.db")
+ daemon = AgentDaemon(agent_id="daemon-1", platform="codex", db=db, poll_interval=0.1)
+
+ registration = daemon.register()
+ assert registration["agent_id"] == "daemon-1"
+
+ handle_tool_call(daemon.core, db, "roundtable_register_agent", {"agent_id": "coord", "platform": "claude-code"})
+ summon = handle_tool_call(
+ daemon.core,
+ db,
+ "roundtable_summon_agents",
+ {
+ "topic": "Daemon summon",
+ "coordinator_agent_id": "coord",
+ "agent_ids": ["daemon-1"],
+ "required_skill": "agent-roundtable",
+ "min_accepts": 1,
+ },
+ )
+ assert summon["ok"] is True
+ assert summon["readiness"]["ready"] is False
+
+ tick = daemon.tick()
+ assert tick["handled"][0]["type"] == "summon"
+ assert tick["handled"][0]["result"]["status"] == "accepted"
+
+ conn = db.connect()
+ try:
+ discussion = db.get_discussion(conn, summon["discussion_id"])
+ dispatch = db.get_dispatch(conn, summon["dispatch"]["id"])
+ assert discussion.status == "active"
+ assert dispatch["status"] == "active"
+ assert "daemon-1" in db.get_active_participant_names(conn, summon["discussion_id"])
+ finally:
+ conn.close()
+
+
+def test_agent_daemon_manual_policy_leaves_summon_pending(tmp_path):
+ db = RoundtableDB(tmp_path / "manual.db")
+ daemon = AgentDaemon(
+ agent_id="manual-agent",
+ platform="codex",
+ db=db,
+ accept_policy="manual",
+ poll_interval=0.1,
+ )
+ daemon.register()
+ handle_tool_call(daemon.core, db, "roundtable_register_agent", {"agent_id": "coord", "platform": "claude-code"})
+ summon = handle_tool_call(
+ daemon.core,
+ db,
+ "roundtable_summon_agents",
+ {
+ "topic": "Manual summon",
+ "coordinator_agent_id": "coord",
+ "agent_ids": ["manual-agent"],
+ "required_skill": "agent-roundtable",
+ },
+ )
+
+ tick = daemon.tick()
+ assert tick["handled"][0]["status"] == "ignored"
+
+ conn = db.connect()
+ try:
+ summons = db.get_summons(conn, discussion_id=summon["discussion_id"], agent_id="manual-agent")
+ assert summons[0]["status"] == "pending"
+ finally:
+ conn.close()
diff --git a/tests/test_core_web_integration.py b/tests/test_core_web_integration.py
index cb6c1c6..128f8c7 100644
--- a/tests/test_core_web_integration.py
+++ b/tests/test_core_web_integration.py
@@ -214,6 +214,31 @@ def test_publisher_cleanup_failure_no_error(self, core):
assert end_result["ok"] is True
assert disc_id not in core._publishers
+ def test_publisher_conclude_failure_releases_publisher(self, core):
+ """Conclude failures should not leave a stale in-memory publisher."""
+ disc_id, mock_pub = self._create_web_discussion(core)
+ mock_pub.conclude.side_effect = RuntimeError("PM2 crash")
+
+ end_result = core.end_discussion(disc_id)
+
+ assert end_result["ok"] is True
+ assert end_result["web_retained"] is False
+ assert disc_id not in core._publishers
+
+ def test_concluded_update_releases_publisher(self, core):
+ """Updating an already concluded discussion should also release publisher state."""
+ disc_id, _mock_pub = self._create_web_discussion(core)
+ core.end_discussion(disc_id, conclusion="Initial conclusion")
+ update_pub = _mock_publisher()
+ core._publishers[disc_id] = update_pub
+
+ end_result = core.end_discussion(disc_id, conclusion="Updated conclusion")
+
+ assert end_result["ok"] is True
+ assert end_result["web_retained"] is True
+ update_pub.conclude.assert_called_once_with("Updated conclusion")
+ assert disc_id not in core._publishers
+
# ---------------------------------------------------------------------------
# Schema validation
diff --git a/tests/test_cross_process_sync.py b/tests/test_cross_process_sync.py
index d2a213f..cca5263 100644
--- a/tests/test_cross_process_sync.py
+++ b/tests/test_cross_process_sync.py
@@ -776,3 +776,61 @@ def test_fallback_conclude_preserves_final_summary_verdict(tmp_path, monkeypatch
# If final_summary was written, its verdict should match
if data.get("final_summary"):
assert data["final_summary"]["verdict"] == "使用 Python"
+
+
+def test_web_sync_writes_dispatch_snapshot_and_joiners(tmp_path, monkeypatch):
+ from roundtable.mcp.tools import handle_tool_call
+ from roundtable.web_publisher import WebPublisher
+
+ monkeypatch.setattr(WebPublisher, "_ensure_shared_server_running", lambda *args, **kwargs: None)
+ monkeypatch.setattr(WebPublisher, "stop", lambda *args, **kwargs: None)
+
+ db_path = tmp_path / "roundtable.db"
+ db = RoundtableDB(db_path)
+ core = RoundtableCore(db)
+ web_base_dir = tmp_path / "roundtable_web"
+ web_base_dir.mkdir(parents=True, exist_ok=True)
+ monkeypatch.setattr(core, "_get_web_dir", lambda discussion_id: web_base_dir / discussion_id)
+
+ handle_tool_call(core, db, "roundtable_register_agent", {"agent_id": "coord", "platform": "claude-code"})
+ handle_tool_call(
+ core,
+ db,
+ "roundtable_register_agent",
+ {
+ "agent_id": "agent-1",
+ "platform": "codex",
+ "skills": ["agent-roundtable"],
+ "availability": "idle",
+ },
+ )
+
+ summon = handle_tool_call(
+ core,
+ db,
+ "roundtable_summon_agents",
+ {
+ "topic": "Web dispatch snapshot",
+ "coordinator_agent_id": "coord",
+ "agent_ids": ["agent-1"],
+ "required_skill": "agent-roundtable",
+ "web": True,
+ "min_accepts": 1,
+ },
+ )
+
+ disc_id = summon["discussion_id"]
+ disc_json_path = web_base_dir / disc_id / "discussion.json"
+ data = json.loads(disc_json_path.read_text())
+ assert data["schema_version"] == 3
+ assert data["status"] == "assembling"
+ assert data["dispatch_summary"]["total_summons"] == 1
+ assert data["dispatches"][0]["dispatch"]["id"] == summon["dispatch"]["id"]
+ assert data["dispatches"][0]["summons"][0]["agent_id"] == "agent-1"
+
+ handle_tool_call(core, db, "roundtable_accept_summon", {"discussion_id": disc_id, "agent_id": "agent-1"})
+
+ data = json.loads(disc_json_path.read_text())
+ assert data["status"] == "active"
+ assert data["dispatch_summary"]["accepted"] == 1
+ assert [participant["profile"] for participant in data["participants"]] == ["agent-1"]
diff --git a/tests/test_db.py b/tests/test_db.py
index d457584..a23f4d1 100644
--- a/tests/test_db.py
+++ b/tests/test_db.py
@@ -6,9 +6,13 @@
from __future__ import annotations
+import sqlite3
+import time
+
import pytest
from roundtable.db import RoundtableDB
+from roundtable.schema import CURRENT_SCHEMA_VERSION, migrate_db
@pytest.fixture
@@ -41,7 +45,114 @@ def db_conn(rt_db):
def test_connect_creates_tables(db_conn):
rows = db_conn.execute("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name").fetchall()
names = {r["name"] for r in rows}
- assert {"discussions", "participants", "speeches", "findings", "convergence_history"} <= names
+ assert {
+ "discussions",
+ "participants",
+ "speeches",
+ "findings",
+ "convergence_history",
+ "agents",
+ "agent_inbox",
+ "invitations",
+ "dispatches",
+ "summons",
+ "summon_events",
+ } <= names
+
+
+def test_connect_creates_v4_indexes_and_sets_user_version(db_conn):
+ rows = db_conn.execute("SELECT name FROM sqlite_master WHERE type='index'").fetchall()
+ indexes = {r["name"] for r in rows}
+ assert {
+ "idx_dispatches_coordinator",
+ "idx_summons_timeout",
+ "idx_inbox_discussion",
+ } <= indexes
+ assert db_conn.execute("PRAGMA user_version").fetchone()[0] == CURRENT_SCHEMA_VERSION
+
+
+def test_v2_migration_allows_assembling_discussions_and_creates_summon_tables(tmp_path):
+ db_path = tmp_path / "v2.db"
+ raw = sqlite3.connect(db_path)
+ try:
+ raw.executescript("""
+ CREATE TABLE discussions (
+ id TEXT PRIMARY KEY,
+ topic TEXT NOT NULL,
+ context TEXT,
+ status TEXT DEFAULT 'active'
+ CHECK(status IN ('active', 'concluded', 'cancelled')),
+ max_rounds INTEGER DEFAULT 5,
+ current_round INTEGER DEFAULT 0,
+ speech_order TEXT DEFAULT 'fixed'
+ CHECK(speech_order IN ('fixed', 'random', 'priority', 'free')),
+ created_by TEXT NOT NULL,
+ created_at INTEGER NOT NULL,
+ concluded_at INTEGER,
+ conclusion TEXT,
+ convergence_score REAL,
+ output_path TEXT,
+ notifications TEXT
+ );
+ INSERT INTO discussions
+ (id, topic, status, max_rounds, current_round, speech_order, created_by, created_at)
+ VALUES ('rt_old', 'Old discussion', 'active', 3, 0, 'fixed', 'coord', 1);
+ PRAGMA user_version = 2;
+ """)
+ finally:
+ raw.close()
+
+ migrated = RoundtableDB(db_path)
+ conn = migrated.connect()
+ try:
+ table_sql = conn.execute(
+ "SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'discussions'"
+ ).fetchone()[0]
+ names = {r["name"] for r in conn.execute("SELECT name FROM sqlite_master WHERE type='table'").fetchall()}
+
+ assert "assembling" in table_sql
+ assert {"dispatches", "summons", "summon_events"} <= names
+ assert migrated.get_discussion(conn, "rt_old").topic == "Old discussion"
+
+ disc = migrated.create_discussion(conn, topic="Assembling", participants=[], status="assembling")
+ assert disc.status == "assembling"
+ finally:
+ conn.close()
+
+
+def test_v3_to_v4_migration_adds_query_indexes(tmp_path):
+ db_path = tmp_path / "v3.db"
+ raw = sqlite3.connect(db_path)
+ try:
+ raw.executescript("""
+ CREATE TABLE dispatches (
+ id TEXT PRIMARY KEY,
+ coordinator_agent_id TEXT
+ );
+ CREATE TABLE summons (
+ id TEXT PRIMARY KEY,
+ status TEXT,
+ expires_at INTEGER
+ );
+ CREATE TABLE agent_inbox (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ discussion_id TEXT,
+ read_at INTEGER
+ );
+ PRAGMA user_version = 3;
+ """)
+
+ migrate_db(raw)
+
+ indexes = {row[0] for row in raw.execute("SELECT name FROM sqlite_master WHERE type='index'").fetchall()}
+ assert {
+ "idx_dispatches_coordinator",
+ "idx_summons_timeout",
+ "idx_inbox_discussion",
+ } <= indexes
+ assert raw.execute("PRAGMA user_version").fetchone()[0] == CURRENT_SCHEMA_VERSION
+ finally:
+ raw.close()
def test_connect_is_idempotent(rt_db, db_conn):
@@ -169,6 +280,15 @@ def test_cancel_discussion(rt_db, db_conn):
assert fetched.status == "cancelled"
+def test_assembling_discussion_can_start_without_participants(rt_db, db_conn):
+ disc = rt_db.create_discussion(db_conn, topic="assembling", participants=[], status="assembling")
+ assert disc.status == "assembling"
+ assert rt_db.get_participants(db_conn, disc.id) == []
+
+ assert rt_db.activate_discussion(db_conn, disc.id) is True
+ assert rt_db.get_discussion(db_conn, disc.id).status == "active"
+
+
# ---------------------------------------------------------------------------
# Participants
# ---------------------------------------------------------------------------
@@ -180,6 +300,229 @@ def test_get_active_participant_names(rt_db, db_conn):
assert names == ["alice", "bob", "carol"]
+def test_add_participant_idempotent(rt_db, db_conn):
+ disc = rt_db.create_discussion(db_conn, topic="test", participants=PARTICIPANTS)
+ assert rt_db.add_participant(db_conn, disc.id, "dave", role="Observer") is True
+ assert rt_db.add_participant(db_conn, disc.id, "dave", role="Observer") is False
+ assert "dave" in rt_db.get_active_participant_names(db_conn, disc.id)
+
+
+# ---------------------------------------------------------------------------
+# Agent registry / dispatch / summons
+# ---------------------------------------------------------------------------
+
+
+def test_agent_metadata_heartbeat_and_filters(rt_db, db_conn):
+ rt_db.upsert_agent(
+ db_conn,
+ "agent-1",
+ "codex",
+ metadata={
+ "skills": ["agent-roundtable"],
+ "availability": "idle",
+ "accept_policy": "auto",
+ "_bridge_auth_token": "secret-token",
+ },
+ )
+ rt_db.upsert_agent(db_conn, "agent-2", "cursor", metadata={"skills": ["other"], "availability": "busy"})
+
+ filtered = rt_db.list_agents(
+ db_conn,
+ required_skill="agent-roundtable",
+ availability="idle",
+ online_only=True,
+ )
+ assert [agent["agent_id"] for agent in filtered] == ["agent-1"]
+
+ heartbeat = rt_db.heartbeat_agent(db_conn, "agent-1", availability="busy")
+ assert heartbeat["metadata"]["availability"] == "busy"
+ assert "_bridge_auth_token" not in heartbeat["metadata"]
+ assert rt_db.get_agent(db_conn, "agent-1")["availability"] == "busy"
+ assert "_bridge_auth_token" not in rt_db.get_agent(db_conn, "agent-1")["metadata"]
+ assert rt_db.get_agent(db_conn, "agent-1", include_private=True)["metadata"]["_bridge_auth_token"] == "secret-token"
+
+
+def test_summon_acceptance_activates_dispatch(rt_db, db_conn):
+ rt_db.upsert_agent(db_conn, "coord", "claude-code")
+ rt_db.upsert_agent(
+ db_conn,
+ "agent-1",
+ "codex",
+ metadata={"skills": ["agent-roundtable"], "availability": "idle"},
+ )
+ disc = rt_db.create_discussion(db_conn, topic="summon", participants=[], status="assembling")
+ dispatch = rt_db.create_dispatch(
+ db_conn,
+ disc.id,
+ "coord",
+ start_policy="quorum",
+ min_accepts=1,
+ timeout_seconds=60,
+ )
+ summon = rt_db.create_summon(
+ db_conn,
+ disc.id,
+ "agent-1",
+ "coord",
+ dispatch_id=dispatch["id"],
+ required_skill="agent-roundtable",
+ )
+
+ delivered = rt_db.mark_summon_delivered(db_conn, summon["id"], {"ok": True})
+ assert delivered["status"] == "delivered"
+
+ accepted = rt_db.respond_summon(db_conn, disc.id, "agent-1", accept=True)
+ assert accepted["status"] == "accepted"
+ assert "agent-1" in rt_db.get_active_participant_names(db_conn, disc.id)
+
+ readiness = rt_db.apply_dispatch_readiness(db_conn, dispatch["id"])
+ assert readiness["dispatch"]["status"] == "active"
+ assert readiness["readiness"]["ready"] is True
+ assert rt_db.get_discussion(db_conn, disc.id).status == "active"
+ events = [event["event"] for event in rt_db.list_summon_events(db_conn, dispatch_id=dispatch["id"])]
+ assert "summon.accepted" in events
+ assert "dispatch.active" in events
+
+
+def test_dispatch_times_out_when_quorum_missing(rt_db, db_conn):
+ rt_db.upsert_agent(db_conn, "coord", "claude-code")
+ rt_db.upsert_agent(db_conn, "agent-1", "codex", metadata={"skills": ["agent-roundtable"]})
+ disc = rt_db.create_discussion(db_conn, topic="timeout", participants=[], status="assembling")
+ dispatch = rt_db.create_dispatch(
+ db_conn,
+ disc.id,
+ "coord",
+ start_policy="quorum",
+ min_accepts=1,
+ timeout_seconds=0,
+ )
+ rt_db.create_summon(
+ db_conn,
+ disc.id,
+ "agent-1",
+ "coord",
+ dispatch_id=dispatch["id"],
+ expires_at=int(time.time()) - 1,
+ )
+
+ readiness = rt_db.apply_dispatch_readiness(db_conn, dispatch["id"])
+ assert readiness["dispatch"]["status"] == "timeout"
+ assert readiness["readiness"]["terminal_timeout"] is True
+ assert rt_db.get_summons(db_conn, dispatch_id=dispatch["id"])[0]["status"] == "timeout"
+
+
+def test_dispatch_idempotency_allows_explicit_terminal_retry(rt_db, db_conn):
+ disc = rt_db.create_discussion(db_conn, topic="retry dispatch", participants=[], status="assembling")
+
+ first = rt_db.create_dispatch(
+ db_conn,
+ disc.id,
+ "coord",
+ idempotency_key="retry-key",
+ )
+ duplicate = rt_db.create_dispatch(
+ db_conn,
+ disc.id,
+ "coord",
+ idempotency_key="retry-key",
+ )
+ assert duplicate["id"] == first["id"]
+
+ rt_db.update_dispatch_status(db_conn, first["id"], "cancelled")
+ terminal_duplicate = rt_db.create_dispatch(
+ db_conn,
+ disc.id,
+ "coord",
+ idempotency_key="retry-key",
+ )
+ assert terminal_duplicate["id"] == first["id"]
+
+ retried = rt_db.create_dispatch(
+ db_conn,
+ disc.id,
+ "coord",
+ idempotency_key="retry-key",
+ allow_terminal_retry=True,
+ )
+
+ assert retried["id"] != first["id"]
+ assert retried["idempotency_key"] == "retry-key"
+ released = rt_db.get_dispatch(db_conn, first["id"])
+ assert released["idempotency_key"] == f"retry-key#released:{first['id']}"
+ events = rt_db.list_summon_events(db_conn, dispatch_id=first["id"])
+ assert "dispatch.idempotency_key.released" in [event["event"] for event in events]
+
+
+def test_terminal_retry_reuses_declined_summon_without_duplicate_row(rt_db, db_conn):
+ rt_db.upsert_agent(db_conn, "agent-1", "codex", metadata={"skills": ["agent-roundtable"]})
+ disc = rt_db.create_discussion(db_conn, topic="retry summon", participants=[], status="assembling")
+ first_dispatch = rt_db.create_dispatch(db_conn, disc.id, "coord")
+ first = rt_db.create_summon(
+ db_conn,
+ disc.id,
+ "agent-1",
+ "coord",
+ dispatch_id=first_dispatch["id"],
+ required_skill="agent-roundtable",
+ idempotency_key="summon-key",
+ )
+ declined = rt_db.respond_summon(db_conn, disc.id, "agent-1", accept=False)
+ assert declined["status"] == "declined"
+
+ retry_dispatch = rt_db.create_dispatch(db_conn, disc.id, "coord")
+ retried = rt_db.create_summon(
+ db_conn,
+ disc.id,
+ "agent-1",
+ "coord",
+ dispatch_id=retry_dispatch["id"],
+ required_skill="agent-roundtable",
+ idempotency_key="summon-key",
+ allow_terminal_retry=True,
+ )
+
+ assert retried["id"] == first["id"]
+ assert retried["status"] == "pending"
+ assert retried["dispatch_id"] == retry_dispatch["id"]
+ assert retried["idempotency_key"] == "summon-key"
+ assert retried["responded_at"] is None
+ assert len(rt_db.get_summons(db_conn, discussion_id=disc.id, agent_id="agent-1")) == 1
+ events = rt_db.list_summon_events(db_conn, summon_id=first["id"])
+ assert "summon.reused_for_retry" in [event["event"] for event in events]
+
+
+def test_terminal_retry_does_not_reset_accepted_summon(rt_db, db_conn):
+ rt_db.upsert_agent(db_conn, "agent-1", "codex", metadata={"skills": ["agent-roundtable"]})
+ disc = rt_db.create_discussion(db_conn, topic="accepted summon", participants=[], status="assembling")
+ first_dispatch = rt_db.create_dispatch(db_conn, disc.id, "coord")
+ first = rt_db.create_summon(
+ db_conn,
+ disc.id,
+ "agent-1",
+ "coord",
+ dispatch_id=first_dispatch["id"],
+ required_skill="agent-roundtable",
+ )
+ accepted = rt_db.respond_summon(db_conn, disc.id, "agent-1", accept=True)
+ assert accepted["status"] == "accepted"
+ rt_db.update_dispatch_status(db_conn, first_dispatch["id"], "completed")
+
+ retry_dispatch = rt_db.create_dispatch(db_conn, disc.id, "coord")
+ retried = rt_db.create_summon(
+ db_conn,
+ disc.id,
+ "agent-1",
+ "coord",
+ dispatch_id=retry_dispatch["id"],
+ required_skill="agent-roundtable",
+ allow_terminal_retry=True,
+ )
+
+ assert retried["id"] == first["id"]
+ assert retried["status"] == "accepted"
+ assert retried["dispatch_id"] == first_dispatch["id"]
+
+
# ---------------------------------------------------------------------------
# Speeches
# ---------------------------------------------------------------------------
diff --git a/tests/test_orchestrator.py b/tests/test_orchestrator.py
new file mode 100644
index 0000000..7abfb7a
--- /dev/null
+++ b/tests/test_orchestrator.py
@@ -0,0 +1,60 @@
+"""Tests for managed and federated dispatch orchestration modes."""
+
+from __future__ import annotations
+
+from roundtable.db import RoundtableDB
+from roundtable.mcp.tools import handle_tool_call
+from roundtable.orchestrator import FederatedOrchestrator, ManagedOrchestrator
+
+
+def test_managed_orchestrator_starts_active_discussion(tmp_path):
+ db = RoundtableDB(tmp_path / "managed.db")
+ orchestrator = ManagedOrchestrator(db=db)
+
+ result = orchestrator.start_discussion(
+ topic="Managed meeting",
+ coordinator_agent_id="coord",
+ participants=[
+ {"profile": "coord", "role": "Coordinator"},
+ {"profile": "local-agent", "role": "Reviewer"},
+ ],
+ )
+
+ assert result["ok"] is True
+ assert result["mode"] == "managed"
+ assert result["dispatch"]["mode"] == "managed"
+ assert result["dispatch"]["status"] == "active"
+ assert result["discussion"]["status"] == "active"
+
+
+def test_federated_orchestrator_uses_registry_summon(tmp_path):
+ db = RoundtableDB(tmp_path / "federated.db")
+ orchestrator = FederatedOrchestrator(db=db)
+ handle_tool_call(
+ orchestrator.core,
+ db,
+ "roundtable_register_agent",
+ {"agent_id": "coord", "platform": "claude-code"},
+ )
+ handle_tool_call(
+ orchestrator.core,
+ db,
+ "roundtable_register_agent",
+ {
+ "agent_id": "federated-agent",
+ "platform": "codex",
+ "skills": ["agent-roundtable"],
+ "availability": "idle",
+ },
+ )
+
+ result = orchestrator.summon(
+ topic="Federated meeting",
+ coordinator_agent_id="coord",
+ agent_ids=["federated-agent"],
+ required_skill="agent-roundtable",
+ )
+
+ assert result["ok"] is True
+ assert result["dispatch"]["mode"] == "federated"
+ assert result["summons"][0]["agent_id"] == "federated-agent"