agentmesh-ai 0.2.1 → 0.3.0

package/dist/mcp/conversation-tools.js

@@ -1,11 +1,32 @@
 /**
  * MCP tool definitions for conversation space operations.
+ *
+ * Supports both legacy WebSocket client and cloud Supabase client.
+ * The cloud client uses push events (waitForMessage) instead of polling.
  */
 import { z } from 'zod';
 import { randomUUID } from 'node:crypto';
+import { CloudConversationClient } from '../cloud/cloud-conversation.js';
 import { writeMemoryEntry } from '../memory/writer.js';
 import { readHubConfig } from '../memory/reader.js';
-export function registerConversationTools(server, getAgentHubDir, getAgentId, getOrConnectClient) {
+import { cloudWriteMemory } from '../cloud/supabase-client.js';
+/** Format ISO timestamp as local time + relative ("14:23:05 (3m ago)"). */
+function formatTime(isoTimestamp) {
+    const date = new Date(isoTimestamp);
+    const diffMin = Math.floor((Date.now() - date.getTime()) / 60000);
+    const local = date.toLocaleTimeString('en-US', { hour12: false, hour: '2-digit', minute: '2-digit', second: '2-digit' });
+    if (diffMin < 1)
+        return `${local} (just now)`;
+    if (diffMin < 60)
+        return `${local} (${diffMin}m ago)`;
+    if (diffMin < 1440)
+        return `${local} (${Math.floor(diffMin / 60)}h ago)`;
+    return `${local} (${Math.floor(diffMin / 1440)}d ago)`;
+}
+export function registerConversationTools(server, getAgentHubDir, getAgentId, getOrConnectClient, getTeamId) {
+    const noConnectionMsg = (teamId) => teamId
+        ? 'Cannot connect to cloud conversation. Check your network connection.'
+        : 'No conversation space is running. A human can start one with: npx agentmesh-ai serve';
     server.tool('start_meeting', `Start a meeting — check that all required team members are online before discussing.
 
 Use this BEFORE using discuss when you need a team decision. It ensures everyone
@@ -17,15 +38,10 @@ to come online. You can call start_meeting again to check if they've joined.`, {
         requiredAgents: z.array(z.string()).optional().describe('Agent IDs that must attend. If omitted, all agents from hub.yaml are required.'),
     }, async ({ topic, requiredAgents }) => {
         const client = await getOrConnectClient();
+        const teamId = getTeamId?.();
         if (!client?.isConnected) {
-            return {
-                content: [{
-                        type: 'text',
-                        text: 'Cannot start meeting: no conversation space is running. A human can start one with: npx agentmesh-ai serve'
-                    }]
-            };
+            return { content: [{ type: 'text', text: noConnectionMsg(teamId) }] };
         }
-        // If no specific agents given, require all from hub.yaml
         let required = requiredAgents;
         if (!required || required.length === 0) {
             const dir = getAgentHubDir();
@@ -34,8 +50,10 @@ to come online. You can call start_meeting again to check if they've joined.`, {
         }
         const meetingId = `meeting-${randomUUID()}`;
         client.startMeeting(meetingId, topic, required);
-        // Wait for server to process and send back status
-        await new Promise(resolve => setTimeout(resolve, 2000));
+        // Cloud mode: meeting status is computed locally; legacy: wait for server broadcast
+        if (!(client instanceof CloudConversationClient)) {
+            await new Promise(resolve => setTimeout(resolve, 2000));
+        }
         const status = client.meetings.find(m => m.meetingId === meetingId);
         if (!status) {
             return {
@@ -67,18 +85,16 @@ to come online. You can call start_meeting again to check if they've joined.`, {
 Returns the list of online agents and what topics are being discussed.
 If no conversation space is running, tells you so.`, {}, async () => {
         const client = await getOrConnectClient();
+        const teamId = getTeamId?.();
         if (!client?.isConnected) {
-            return {
-                content: [{
-                        type: 'text',
-                        text: 'No conversation space is running. A human can start one with: npx agentmesh-ai serve'
-                    }]
-            };
+            return { content: [{ type: 'text', text: noConnectionMsg(teamId) }] };
         }
         const agents = client.agents;
         const topics = client.topics;
         const myId = getAgentId();
         const lines = [];
+        const mode = teamId ? '☁️ Cloud' : '🔌 Local';
+        lines.push(`${mode} conversation space\n`);
         lines.push(`Connected agents (${agents.length}):`);
         for (const a of agents) {
             lines.push(`  - ${a.displayName} (${a.role}) using ${a.tool}`);
@@ -90,7 +106,7 @@ If no conversation space is running, tells you so.`, {}, async () => {
                 const msgs = client.getTopicMessages(t);
                 const participants = [...new Set(msgs.map(m => m.from.displayName))];
                 const lastMsg = msgs[msgs.length - 1];
-                const lastTime = lastMsg ? lastMsg.timestamp.slice(11, 19) : '?';
+                const lastTime = lastMsg ? formatTime(lastMsg.timestamp) : '?';
                 const myParticipation = msgs.some(m => m.from.id === myId) ? '✓ you spoke' : '⏳ waiting for you';
                 lines.push(`  - "${t}" — ${msgs.length} msgs, participants: ${participants.join(', ')}, last: ${lastTime} (${myParticipation})`);
             }
@@ -109,25 +125,19 @@ Your message will be seen by all connected agents.`, {
         related_to: z.string().optional().describe('Memory topic or file path this relates to'),
     }, async ({ topic, message, related_to }) => {
         const client = await getOrConnectClient();
+        const teamId = getTeamId?.();
         if (!client?.isConnected) {
-            return {
-                content: [{
-                        type: 'text',
-                        text: 'Cannot send message: no conversation space is running. A human can start one with: npx agentmesh-ai serve'
-                    }]
-            };
+            return { content: [{ type: 'text', text: noConnectionMsg(teamId) }] };
         }
         client.sendMessage(topic, message, related_to);
-        // Wait a moment for replies
-        await new Promise(resolve => setTimeout(resolve, 2000));
-        // Return recent messages on this topic
+        // Legacy mode: wait for server broadcast; cloud mode: skip
+        if (!(client instanceof CloudConversationClient)) {
+            await new Promise(resolve => setTimeout(resolve, 2000));
+        }
         const recent = client.getTopicMessages(topic).slice(-10);
         if (recent.length === 0) {
             return {
-                content: [{
-                        type: 'text',
-                        text: `Message sent to topic "${topic}". No replies yet.`
-                    }]
+                content: [{ type: 'text', text: `Message sent to topic "${topic}". No replies yet.` }]
             };
         }
         const lines = [`Messages on "${topic}":\n`];
@@ -142,13 +152,9 @@ Use this to check if other agents have replied to your earlier message.`, {
         since: z.string().optional().describe('Only get messages after this ISO timestamp'),
     }, async ({ topic, since }) => {
         const client = await getOrConnectClient();
+        const teamId = getTeamId?.();
         if (!client?.isConnected) {
-            return {
-                content: [{
-                        type: 'text',
-                        text: 'No conversation space is running.'
-                    }]
-            };
+            return { content: [{ type: 'text', text: noConnectionMsg(teamId) }] };
         }
         let messages = client.getTopicMessages(topic);
         if (since) {
@@ -157,15 +163,12 @@ Use this to check if other agents have replied to your earlier message.`, {
         }
         if (messages.length === 0) {
             return {
-                content: [{
-                        type: 'text',
-                        text: `No messages on "${topic}"${since ? ' since ' + since : ''}.`
-                    }]
+                content: [{ type: 'text', text: `No messages on "${topic}"${since ? ' since ' + since : ''}.` }]
             };
         }
         const lines = [`Messages on "${topic}" (${messages.length}):\n`];
         for (const m of messages) {
-            const time = m.timestamp.slice(11, 19);
+            const time = formatTime(m.timestamp);
             lines.push(`[${time}] ${m.from.displayName}: ${m.content}`);
         }
         return { content: [{ type: 'text', text: lines.join('\n') }] };
@@ -177,9 +180,15 @@ when you want a real back-and-forth conversation.
 
 HOW IT WORKS:
 1. You send your message to the topic
-2. The tool waits for other agents to reply (up to 60 seconds)
-3. Returns ALL replies so you can see the full discussion
-4. You then decide: call discuss again to continue, or save_to_memory to conclude
+2. The tool waits for other agents to reply
+3. If someone replies "hold on" / "wait" / "等一下", it automatically extends the wait
+4. Returns ALL replies so you can see the full discussion
+5. You then decide: call discuss again to continue, or save_to_memory to conclude
+
+WAIT TIME:
+- Default: 60 seconds. Max: 1800 seconds (30 minutes).
+- If the human says something like "wait for 10 minutes", set wait_seconds to 600.
+- If someone sends a "hold on" message, the wait is automatically extended by 5 minutes.
 
 WHEN TO USE:
 - You need team consensus on a decision (tech stack, architecture, conventions)
@@ -191,50 +200,32 @@ You drive the discussion loop yourself — keep calling discuss until consensus
 then call save_to_memory to record the conclusion.
 
 ASYNC FALLBACK:
-If the conversation space is not running or some members are offline,
-you can discuss asynchronously through shared memory:
+If no other agents are online, you can discuss asynchronously through shared memory:
 1. Write your proposal with write_memory, topic prefix "Discussion: ", status "proposal"
 2. Other agents will see it when they read_memory (marked 📋)
 3. They can respond by writing their own entries on the same topic
 4. Once consensus forms in memory, upgrade the conclusion to status "protected"`, {
         topic: z.string().describe('Discussion topic'),
         message: z.string().describe('Your message — proposal, question, or response to others'),
-        wait_seconds: z.number().optional().describe('How long to wait for replies (default: 30, max: 120)'),
+        wait_seconds: z.number().optional().describe('How long to wait for replies (default: 60, max: 1800 = 30 min). Set higher if the human asks to wait longer.'),
         related_to: z.string().optional().describe('Memory topic or file path this discussion relates to'),
     }, async ({ topic, message, wait_seconds, related_to }) => {
         const client = await getOrConnectClient();
+        const teamId = getTeamId?.();
         if (!client?.isConnected) {
-            return {
-                content: [{
-                        type: 'text',
-                        text: 'Cannot discuss: no conversation space is running. A human can start one with: npx agentmesh-ai serve'
-                    }]
-            };
+            return { content: [{ type: 'text', text: noConnectionMsg(teamId) }] };
         }
-        // Record the timestamp before sending so we can filter for new replies
         const beforeSend = new Date().toISOString();
-        // Send our message
         client.sendMessage(topic, message, related_to);
-        // Wait for replies
-        const waitMs = Math.min((wait_seconds ?? 30), 120) * 1000;
-        const pollInterval = 3000; // check every 3 seconds
-        const deadline = Date.now() + waitMs;
-        let lastCount = 0;
-        let silentSince = Date.now();
-        // Poll for new messages, with early exit if replies stop coming
-        while (Date.now() < deadline) {
-            await new Promise(resolve => setTimeout(resolve, pollInterval));
-            const newMessages = client.getTopicMessages(topic).filter(m => new Date(m.timestamp).getTime() > new Date(beforeSend).getTime()
-                && m.from.id !== getAgentId());
-            if (newMessages.length > lastCount) {
-                // New replies came in — reset silence timer
-                lastCount = newMessages.length;
-                silentSince = Date.now();
-            }
-            else if (Date.now() - silentSince > 15000 && lastCount > 0) {
-                // 15 seconds of silence after getting at least one reply — discussion round is done
-                break;
-            }
+        const waitMs = Math.min((wait_seconds ?? 60), 1800) * 1000;
+        const myId = getAgentId();
+        // Cloud mode: use push events (waitForMessage)
+        // Legacy mode: poll every 3 seconds
+        if (client instanceof CloudConversationClient) {
+            await waitForRepliesCloud(client, topic, myId, waitMs);
+        }
+        else {
+            await waitForRepliesPolling(client, topic, myId, beforeSend, waitMs);
         }
         // Collect all messages on this topic
         const allMessages = client.getTopicMessages(topic);
@@ -242,7 +233,7 @@ you can discuss asynchronously through shared memory:
             return {
                 content: [{
                         type: 'text',
-                        text: `Your message was sent to "${topic}". No other agents replied within ${wait_seconds ?? 30}s. They may be offline — the message will be there when they check.`
+                        text: `Your message was sent to "${topic}". No other agents replied within ${wait_seconds ?? 60}s. They may be offline — the message will be there when they check.`
                     }]
             };
         }
@@ -250,13 +241,12 @@ you can discuss asynchronously through shared memory:
         const lines = [];
         lines.push(`Discussion on "${topic}" (${allMessages.length} messages):\n`);
         for (const m of allMessages) {
-            const time = m.timestamp.slice(11, 19);
-            const isMe = m.from.id === getAgentId();
+            const time = formatTime(m.timestamp);
+            const isMe = m.from.id === myId;
             const prefix = isMe ? '(you)' : `${m.from.displayName} [${m.from.role}]`;
             lines.push(`[${time}] ${prefix}: ${m.content}`);
         }
-        // Count unique participants (excluding self)
-        const others = new Set(allMessages.filter(m => m.from.id !== getAgentId()).map(m => m.from.id));
+        const others = new Set(allMessages.filter(m => m.from.id !== myId).map(m => m.from.id));
         lines.push('');
         lines.push(`--- ${others.size} other agent(s) participated ---`);
         lines.push('');
@@ -278,13 +268,17 @@ This records the conclusion permanently so all agents (including offline ones) w
         const agentId = getAgentId();
         const hub = await readHubConfig(dir);
         const agentInfo = hub?.agents.find(a => a.id === agentId);
-        // Write to memory
-        await writeMemoryEntry(dir, agentId, agentInfo?.role ?? 'developer', agentInfo?.tool ?? 'unknown', { topic, content, tags, decided_with });
-        // Also send CONCLUDE to conversation space
-        const client = await getOrConnectClient();
-        if (client?.isConnected) {
-            client.conclude(topic, content, tags);
-        }
+        const role = agentInfo?.role ?? 'developer';
+        const tool = agentInfo?.tool ?? 'unknown';
+        // Write to local + cloud in parallel, and send conclusion
+        const teamId = getTeamId?.() ?? hub?.team_id;
+        const writeOpts = { topic, content, tags, decided_with };
+        await Promise.all([
+            writeMemoryEntry(dir, agentId, role, tool, writeOpts),
+            teamId ? cloudWriteMemory(teamId, agentId, role, tool, writeOpts).catch(() => { }) : Promise.resolve(),
+            getOrConnectClient().then(client => { if (client?.isConnected)
+                client.conclude(topic, content, tags); }),
+        ]);
         return {
             content: [{
                     type: 'text',
@@ -326,13 +320,10 @@ Flow:
             '',
             recommendation ? `💡 Recommendation: ${recommendation}` : '',
         ].filter(Boolean).join('\n');
-        // Generate a unique decision ID
         const decisionId = `decision-${randomUUID()}`;
-        // Broadcast proposal to conversation space (so other agents see it)
         if (client?.isConnected) {
             client.proposeDecision(decisionId, title, options, recommendation);
         }
-        // Ask THIS human via elicitation
         try {
             const result = await server.server.elicitInput({
                 mode: 'form',
@@ -369,7 +360,6 @@ Flow:
                 const reason = result.content.reason;
                 if (choice === '__none_of_the_above__') {
                     const userDirection = reason || 'No specific direction given';
-                    // Vote reject and broadcast the reason to the conversation space
                     if (client?.isConnected) {
                         client.vote(decisionId, 'reject', undefined, userDirection);
                         client.sendMessage(title, `❌ Human rejected all proposed options. Feedback: "${userDirection}". Discussion should restart with this new direction.`);
@@ -381,13 +371,11 @@ Flow:
                             }]
                     };
                 }
-                // Vote approve in the conversation space
                 if (client?.isConnected) {
                     client.vote(decisionId, 'approve', choice, reason);
                     // Wait for other votes
-                    const waitMs = 60000; // wait up to 60s for all votes
+                    const deadline = Date.now() + 60000;
                     const pollInterval = 3000;
-                    const deadline = Date.now() + waitMs;
                     while (Date.now() < deadline) {
                         await new Promise(resolve => setTimeout(resolve, pollInterval));
                         const resolved = client.resolvedDecisions.find(d => d.decisionId === decisionId);
@@ -411,7 +399,6 @@ Flow:
                             }
                         }
                     }
-                    // Timeout — not all voted yet
                     return {
                         content: [{
                                 type: 'text',
@@ -419,7 +406,6 @@ Flow:
                             }]
                     };
                 }
-                // No conversation space — single user decision
                 return {
                     content: [{
                             type: 'text',
@@ -429,20 +415,13 @@ Flow:
             }
             else {
                 return {
-                    content: [{
-                            type: 'text',
-                            text: '⏸️ User declined to vote right now. Continue with other work and come back to this later.',
-                        }]
+                    content: [{ type: 'text', text: '⏸️ User declined to vote right now. Continue with other work and come back to this later.' }]
                 };
             }
         }
         catch {
-            // Elicitation not supported — fall back to text
             return {
-                content: [{
-                        type: 'text',
-                        text: `❓ Decision needed: ${title}\n\n${message}\n\nPlease tell me which option you prefer.`,
-                    }]
+                content: [{ type: 'text', text: `❓ Decision needed: ${title}\n\n${message}\n\nPlease tell me which option you prefer.` }]
             };
         }
     });
@@ -468,73 +447,147 @@ Flow:
     });
     server.tool('vote_on_decision', `Vote on a pending team decision that was proposed by another agent.
 
-When you see a DECISION_PROPOSED in the conversation space, use this tool to ask your human
-to vote. This shows them the options and sends their vote back to the conversation space.
-A decision is only finalized when ALL humans have voted.`, {
+You can vote in two ways:
+1. If the user already told you their choice, pass it directly via the "choice" parameter
+2. If you need to ask the user, leave "choice" empty and this tool will try to show a form
+
+Always ask the user which option they prefer BEFORE calling this tool, then pass their answer.`, {
         decisionId: z.string().describe('The decision ID from the proposal'),
-        topic: z.string().describe('The decision topic (for display)'),
-        options: z.array(z.object({
-            label: z.string(),
-            description: z.string(),
-        })).describe('The options to vote on'),
-        recommendation: z.string().optional().describe('The proposer\'s recommendation'),
-    }, async ({ decisionId, topic, options, recommendation }) => {
+        topic: z.string().describe('The decision topic'),
+        choice: z.string().optional().describe('The chosen option (e.g. "PostgreSQL"). If provided, votes directly without showing a form.'),
+        vote: z.enum(['approve', 'reject']).optional().describe('approve or reject. Default: approve if choice is given.'),
+        reason: z.string().optional().describe('Reason for the vote'),
+    }, async ({ decisionId, topic, choice, vote, reason }) => {
         const client = await getOrConnectClient();
-        const optionLabels = options.map(o => o.label);
-        const message = [
-            `Team decision requested: ${topic}`,
-            '',
-            'Options:',
-            ...options.map(o => `• ${o.label} — ${o.description}`),
-            '',
-            recommendation ? `💡 Proposer recommends: ${recommendation}` : '',
-        ].filter(Boolean).join('\n');
+        if (choice) {
+            const voteType = (choice === '__none_of_the_above__' || vote === 'reject') ? 'reject' : 'approve';
+            client?.vote(decisionId, voteType, voteType === 'approve' ? choice : undefined, reason);
+            if (voteType === 'reject') {
+                return { content: [{ type: 'text', text: `❌ Vote: rejected. ${reason ? `Reason: ${reason}` : ''}` }] };
+            }
+            return {
+                content: [{ type: 'text', text: `✅ Vote: approved "${choice}". ${reason ? `Reason: ${reason}` : ''}\nWaiting for other team members...` }]
+            };
+        }
         try {
             const result = await server.server.elicitInput({
                 mode: 'form',
-                message,
+                message: `Team decision: ${topic}`,
                 requestedSchema: {
                     type: 'object',
                     properties: {
-                        choice: {
-                            type: 'string',
-                            title: topic,
-                            oneOf: [
-                                ...optionLabels.map(label => ({ const: label, title: label })),
-                                { const: '__none_of_the_above__', title: 'None of the above — reject' },
-                            ],
-                        },
-                        reason: {
-                            type: 'string',
-                            title: 'Reason (optional)',
-                        },
+                        choice: { type: 'string', title: topic },
+                        reason: { type: 'string', title: 'Reason (optional)' },
                     },
                     required: ['choice'],
                 },
             });
             if (result.action === 'accept' && result.content) {
-                const choice = result.content.choice;
-                const reason = result.content.reason;
-                if (choice === '__none_of_the_above__') {
-                    client?.vote(decisionId, 'reject', undefined, reason || 'Rejected all options');
-                    return {
-                        content: [{ type: 'text', text: `❌ Vote: rejected. ${reason ? `Reason: ${reason}` : ''}` }]
-                    };
-                }
-                client?.vote(decisionId, 'approve', choice, reason);
+                const userChoice = result.content.choice;
+                const userReason = result.content.reason;
+                client?.vote(decisionId, 'approve', userChoice, userReason);
                 return {
-                    content: [{ type: 'text', text: `✅ Vote: approved "${choice}". Waiting for other team members...` }]
+                    content: [{ type: 'text', text: `✅ Vote: approved "${userChoice}". Waiting for other team members...` }]
                 };
             }
             return {
-                content: [{ type: 'text', text: '⏸️ User skipped voting for now.' }]
+                content: [{ type: 'text', text: '⏸️ User skipped voting. Ask the user which option they prefer, then call this tool again with their choice.' }]
             };
         }
         catch {
             return {
-                content: [{ type: 'text', text: `❓ Vote needed on: ${topic}\n\n${message}\n\nTell me which option you prefer, or say "reject" if none work.` }]
+                content: [{ type: 'text', text: `❓ Could not show vote form. Please ask the user which option they prefer for "${topic}", then call vote_on_decision again with their choice.` }]
             };
         }
     });
 }
+// ── Wait strategies ──────────────────────────────────────────────────────────
+/** How long to extend when someone says "hold on" (5 minutes). */
+const HOLD_ON_EXTENSION_MS = 5 * 60 * 1000;
+/** Patterns that mean "wait for me, I'm coming". */
+const HOLD_ON_PATTERNS = [
+    /hold\s*on/i,
+    /wait/i,
+    /one\s*(moment|minute|sec)/i,
+    /coming/i,
+    /be\s*right\s*(there|back)/i,
+    /brb/i,
+    /give\s*me\s*(a\s*)?(moment|minute|sec)/i,
+    /等一下/,
+    /稍等/,
+    /马上/,
+    /等等/,
+    /来了/,
+    /等我/,
+];
+function isHoldOnMessage(content) {
+    return HOLD_ON_PATTERNS.some(p => p.test(content));
+}
+/**
+ * Cloud mode: use push events via waitForMessage.
+ * If someone says "hold on", automatically extends the deadline.
+ */
+async function waitForRepliesCloud(client, topic, myId, waitMs) {
+    let deadline = Date.now() + waitMs;
+    let gotRealReply = false;
+    while (Date.now() < deadline) {
+        const remaining = deadline - Date.now();
+        if (remaining <= 0)
+            break;
+        // After getting a real reply, use shorter silence timeout (15s)
+        const timeout = gotRealReply ? Math.min(15000, remaining) : remaining;
+        try {
+            const msg = await client.waitForMessage(topic, timeout);
+            if (isHoldOnMessage(msg.content)) {
+                // Extend deadline — someone is coming
+                deadline = Math.max(deadline, Date.now() + HOLD_ON_EXTENSION_MS);
+                // Don't count "hold on" as a real reply for silence detection
+            }
+            else {
+                gotRealReply = true;
+            }
+        }
+        catch {
+            // Timeout
+            if (gotRealReply)
+                break;
+            break;
+        }
+    }
+}
+/**
+ * Legacy mode: poll every 3 seconds (for WebSocket ConversationClient).
+ * Also supports "hold on" detection.
+ */
+async function waitForRepliesPolling(client, topic, myId, beforeSend, waitMs) {
+    const pollInterval = 3000;
+    let deadline = Date.now() + waitMs;
+    let lastCount = 0;
+    let silentSince = Date.now();
+    while (Date.now() < deadline) {
+        await new Promise(resolve => setTimeout(resolve, pollInterval));
+        const newMessages = client.getTopicMessages(topic).filter(m => new Date(m.timestamp).getTime() > new Date(beforeSend).getTime()
+            && m.from.id !== myId);
+        if (newMessages.length > lastCount) {
+            const latestNew = newMessages.slice(lastCount);
+            lastCount = newMessages.length;
+            // Check if any new message is "hold on"
+            const hasHoldOn = latestNew.some(m => isHoldOnMessage(m.content));
+            if (hasHoldOn) {
+                deadline = Math.max(deadline, Date.now() + HOLD_ON_EXTENSION_MS);
+            }
+            // Check if there's a real (non-hold-on) reply
+            const hasRealReply = latestNew.some(m => !isHoldOnMessage(m.content));
+            if (hasRealReply) {
+                silentSince = Date.now();
+            }
+        }
+        else if (Date.now() - silentSince > 15000 && lastCount > 0) {
+            // 15 seconds of silence after real replies — round done
+            const hasAnyRealReply = newMessages.some(m => !isHoldOnMessage(m.content));
+            if (hasAnyRealReply)
+                break;
+        }
+    }
+}
 //# sourceMappingURL=conversation-tools.js.map