@yemi33/minions 0.1.1709 → 0.1.1711

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.1.1711 (2026-05-04)
+
+### Other
+- Ensure meetings advance after terminal outcomes
+
+## 0.1.1710 (2026-05-04)
+
+### Other
+- Fix meeting lifecycle edge cases
+
 ## 0.1.1709 (2026-05-04)
 
 ### Fixes

package/dashboard/js/command-center.js

@@ -969,7 +969,7 @@ async function ccExecuteAction(action, targetTabId) {
       status.style.color = 'var(--green)';
     }
     ccAddMessage('action', status.outerHTML, false, targetTabId);
-    if (['dispatch','fix','implement','explore','review','test'].includes(action.type)) wakeEngine();
+    if (['dispatch','fix','implement','explore','review','test','create-meeting'].includes(action.type)) wakeEngine();
     refresh();
     return;
   }
@@ -1175,9 +1175,10 @@ async function ccExecuteAction(action, targetTabId) {
         break;
       }
       case 'create-meeting': {
+        var meetingParticipants = (Array.isArray(action.participants) && action.participants.length > 0) ? action.participants : (action.agents || []);
         var res6 = await fetch('/api/meetings', {
           method: 'POST', headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({ title: action.title, agenda: action.agenda, participants: action.agents, rounds: action.rounds, project: action.project })
+          body: JSON.stringify({ title: action.title, agenda: action.agenda, participants: meetingParticipants, rounds: action.rounds, project: action.project })
         });
         if (!res6.ok) { var d6 = await res6.json().catch(function() { return {}; }); throw new Error(d6.error || 'Meeting create failed'); }
         var d6r = await res6.json();

package/dashboard.js

@@ -1539,6 +1539,27 @@ function _parseWatchInterval(val) {
   return Math.max(60000, Math.round(u === 's' ? n * 1000 : u === 'm' ? n * 60000 : n * 3600000));
 }
 
+function normalizeMeetingParticipants(participants) {
+  if (!Array.isArray(participants)) return [];
+  const seen = new Set();
+  const normalized = [];
+  for (const participant of participants) {
+    const id = String(participant || '').trim();
+    if (!id || seen.has(id)) continue;
+    seen.add(id);
+    normalized.push(id);
+  }
+  return normalized;
+}
+
+function meetingParticipantsFromAction(action) {
+  return normalizeMeetingParticipants(
+    Array.isArray(action?.participants) && action.participants.length > 0
+      ? action.participants
+      : action?.agents
+  );
+}
+
 // Required-field validator for CC actions. Returns null when valid, an error string when not.
 // Centralises field-required checks so the model can't quietly emit a malformed action and have
 // the server silently fall back to placeholder values (e.g. "Untitled"). The handler invokes this
@@ -1567,6 +1588,12 @@ function _ccValidateAction(action) {
     case 'plan':
       if (!action.title) return 'plan action missing required field: title';
       return null;
+    case 'create-meeting': {
+      if (!action.title || typeof action.title !== 'string' || !action.title.trim()) return 'create-meeting action missing required field: title';
+      if (!action.agenda || typeof action.agenda !== 'string' || !action.agenda.trim()) return 'create-meeting action missing required field: agenda';
+      if (meetingParticipantsFromAction(action).length < 2) return 'create-meeting action requires at least 2 participants';
+      return null;
+    }
     default:
       return null; // unknown types fall through to existing handler / generic fallback
   }
@@ -1794,6 +1821,17 @@ async function executeCCActions(actions) {
           results.push({ type: 'create-watch', id: watch.id, ok: true });
           break;
         }
+        case 'create-meeting': {
+          const { createMeeting } = require('./engine/meeting');
+          const meeting = createMeeting({
+            title: action.title.trim(),
+            agenda: action.agenda.trim(),
+            participants: meetingParticipantsFromAction(action),
+          });
+          invalidateStatusCache();
+          results.push({ type: 'create-meeting', id: meeting.id, ok: true });
+          break;
+        }
         case 'delete-watch': {
           const deleted = watchesMod.deleteWatch(action.id);
           if (deleted) invalidateStatusCache();
@@ -6721,9 +6759,14 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     { method: 'POST', path: '/api/meetings', desc: 'Create a team meeting', params: 'title, agenda, participants[]', handler: async (req, res) => {
       const body = await readBody(req);
       const { title, agenda, participants } = body;
-      if (!title || !agenda) return jsonReply(res, 400, { error: 'title and agenda required' });
+      if (typeof title !== 'string' || !title.trim() || typeof agenda !== 'string' || !agenda.trim()) {
+        return jsonReply(res, 400, { error: 'title and agenda required' });
+      }
+      if (!Array.isArray(participants)) return jsonReply(res, 400, { error: 'participants must be an array' });
+      const meetingParticipants = normalizeMeetingParticipants(participants);
+      if (meetingParticipants.length < 2) return jsonReply(res, 400, { error: 'at least 2 participants required' });
       const { createMeeting } = require('./engine/meeting');
-      const meeting = createMeeting({ title, agenda, participants: participants || [] });
+      const meeting = createMeeting({ title: title.trim(), agenda: agenda.trim(), participants: meetingParticipants });
       invalidateStatusCache();
       return jsonReply(res, 200, { ok: true, meeting });
     }},
@@ -6923,6 +6966,8 @@ module.exports = {
   _filterCcTabSessions,
   _getVersionCheckInterval,
   _parseWatchInterval,
+  _normalizeMeetingParticipants: normalizeMeetingParticipants,
+  _meetingParticipantsFromAction: meetingParticipantsFromAction,
   parsePinnedEntries,
   _parseDocChatResultText,
   _messageRequestsOrchestration,

package/engine/copilot-models.json

@@ -1,5 +1,5 @@
 {
   "runtime": "copilot",
   "models": null,
-  "cachedAt": "2026-05-04T16:53:06.222Z"
+  "cachedAt": "2026-05-04T17:19:35.871Z"
 }

package/engine/lifecycle.js

@@ -2662,7 +2662,14 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
   if (type === WORK_TYPE.MEETING && meta?.meetingId) {
     try {
       const { collectMeetingFindings } = require('./meeting');
-      collectMeetingFindings(meta.meetingId, agentId, meta.roundName, stdout, structuredCompletion);
+      collectMeetingFindings(meta.meetingId, agentId, meta.roundName, stdout, structuredCompletion, meta.round, {
+        success: effectiveSuccess,
+        result,
+        code,
+        completionStatus,
+        agentReportedFailure,
+        summary: resultSummary,
+      });
     } catch (err) { log('warn', `Meeting collect: ${err.message}`); }
   }
 

package/engine/meeting.js

@@ -20,6 +20,106 @@ const EMPTY_OUTPUT_PATTERNS = ['(no output)', '(no findings)', '(no response)'];
 // tests can redirect the meetings directory without patching module internals.
 const MEETINGS_DIR = path.join(shared.MINIONS_DIR, 'meetings');
 const MEETING_NOTE_ARTIFACT_ROOT = path.join(shared.MINIONS_DIR, 'notes', 'inbox');
+const TERMINAL_MEETING_STATUSES = new Set(['completed', 'archived']);
+const ROUND_STATUS_BY_NAME = {
+  investigate: 'investigating',
+  debate: 'debating',
+  conclude: 'concluding',
+};
+const ROUND_NUMBER_BY_NAME = { investigate: 1, debate: 2, conclude: 3 };
+const ACTIVE_MEETING_STATUSES = new Set(Object.values(ROUND_STATUS_BY_NAME));
+
+function isTerminalMeetingStatus(status) {
+  return TERMINAL_MEETING_STATUSES.has(String(status || '').toLowerCase());
+}
+
+function expectedMeetingStatusForRound(roundName) {
+  return ROUND_STATUS_BY_NAME[String(roundName || '').toLowerCase()] || null;
+}
+
+function roundKeyFor(roundName, round) {
+  const numeric = Number(round);
+  if (Number.isFinite(numeric) && numeric > 0) return String(numeric);
+  return String(ROUND_NUMBER_BY_NAME[String(roundName || '').toLowerCase()] || 1);
+}
+
+function getRoundFailures(meeting, roundName, round, create = false) {
+  if (!meeting.roundFailures || typeof meeting.roundFailures !== 'object') {
+    if (!create) return {};
+    meeting.roundFailures = {};
+  }
+  const key = roundKeyFor(roundName, round);
+  if (!meeting.roundFailures[key] || typeof meeting.roundFailures[key] !== 'object') {
+    if (!create) return {};
+    meeting.roundFailures[key] = {};
+  }
+  return meeting.roundFailures[key];
+}
+
+function hasRoundFailure(meeting, roundName, agentId, round = meeting.round) {
+  return Boolean(getRoundFailures(meeting, roundName, round, false)[agentId]);
+}
+
+function hasRoundSuccess(meeting, roundName, agentId) {
+  if (roundName === 'investigate') return Boolean(meeting.findings?.[agentId]);
+  if (roundName === 'debate') return Boolean(meeting.debate?.[agentId]);
+  return Boolean(meeting.conclusion && meeting.conclusion.agent === agentId);
+}
+
+function hasRoundTerminalOutcome(meeting, roundName, agentId, round = meeting.round) {
+  return hasRoundSuccess(meeting, roundName, agentId) || hasRoundFailure(meeting, roundName, agentId, round);
+}
+
+function allParticipantsFinishedRound(meeting, roundName, round = meeting.round) {
+  const participants = Array.isArray(meeting.participants) ? meeting.participants : [];
+  return participants.length > 0 && participants.every(agentId =>
+    hasRoundTerminalOutcome(meeting, roundName, agentId, round)
+  );
+}
+
+function formatRoundFailuresForConclusion(meeting, roundName, round = meeting.round) {
+  const failures = getRoundFailures(meeting, roundName, round, false);
+  return Object.entries(failures)
+    .map(([agent, failure]) => `- **${agent}**: ${failure.reason || 'Agent failed before producing a meeting contribution.'}`)
+    .join('\n') || '- No structured failure details were captured.';
+}
+
+function buildFailedMeetingConclusion(meeting, agents, reason) {
+  const base = buildTimedOutMeetingConclusion(meeting, agents)
+    .replace('*Auto-generated — conclusion round timed out.*', '*Auto-generated — conclusion round failed.*');
+  return `${base}\n\n## Conclusion Failure\n${reason || formatRoundFailuresForConclusion(meeting, 'conclude', meeting.round)}`;
+}
+
+function advanceMeetingIfRoundComplete(meeting, roundName, meetingId, config = null) {
+  if (roundName === 'investigate') {
+    if (!allParticipantsFinishedRound(meeting, roundName, meeting.round)) return false;
+    meeting.status = 'debating';
+    meeting.round = 2;
+    meeting.roundStartedAt = ts();
+    log('info', `Meeting ${meetingId}: all findings finished — advancing to debate`);
+    return true;
+  }
+  if (roundName === 'debate') {
+    if (!allParticipantsFinishedRound(meeting, roundName, meeting.round)) return false;
+    meeting.status = 'concluding';
+    meeting.round = 3;
+    meeting.roundStartedAt = ts();
+    log('info', `Meeting ${meetingId}: all debate responses finished — advancing to conclusion`);
+    return true;
+  }
+  if (roundName === 'conclude' && !meeting.conclusion) {
+    const agents = (config || queries.getConfig()).agents || {};
+    const autoConclusion = buildFailedMeetingConclusion(meeting, agents);
+    meeting.conclusion = { content: autoConclusion, agent: 'system', submittedAt: ts() };
+    meeting.transcript.push({ round: meeting.round, agent: 'system', type: 'conclusion', content: autoConclusion, at: ts() });
+    meeting.status = 'completed';
+    meeting.completedAt = ts();
+    writeMeetingTranscriptToInbox(meeting, meetingId, agents);
+    log('warn', `Meeting ${meetingId}: conclusion failed — auto-generated fallback conclusion`);
+    return true;
+  }
+  return false;
+}
 
 function isEmptyMeetingContent(text) {
   const value = String(text || '').trim();
@@ -218,6 +318,15 @@ function buildTimedOutMeetingConclusion(meeting, agents) {
   return `*Auto-generated — conclusion round timed out.*\n\nThis summary is based on ${findingsCount} finding${findingsCount === 1 ? '' : 's'} and ${debateCount} debate response${debateCount === 1 ? '' : 's'}.\n\n## Findings Highlights\n${findingsHighlights.join('\n')}\n\n## Debate Takeaways\n${(debateTakeaways.length ? debateTakeaways : fallbackDebate).join('\n')}\n\n## Recommended Next Steps\n${nextSteps.join('\n')}`;
 }
 
+function writeMeetingTranscriptToInbox(meeting, meetingId, agents) {
+  try {
+    const transcript = meeting.transcript.map(t =>
+      `### ${agents[t.agent]?.name || t.agent} (${t.type}, Round ${t.round})\n\n${t.content}`
+    ).join('\n\n---\n\n');
+    shared.writeToInbox('meeting', meetingId, `# Meeting Transcript: ${meeting.title}\n\n${transcript}`);
+  } catch (e) { log('warn', `Meeting ${meetingId} inbox write: ${e.message}`); }
+}
+
 function getMeetings() {
   if (!fs.existsSync(MEETINGS_DIR)) return [];
   return fs.readdirSync(MEETINGS_DIR)
@@ -234,6 +343,8 @@ function getMeeting(id) {
     if (!m.debate) m.debate = {};
     if (!m.humanNotes) m.humanNotes = [];
     if (!m.participants) m.participants = [];
+    if (!m.transcript) m.transcript = [];
+    if (!m.roundFailures || typeof m.roundFailures !== 'object') m.roundFailures = {};
   }
   return m;
 }
@@ -257,6 +368,7 @@ function createMeeting({ title, agenda, participants }) {
     debate: {},
     conclusion: null,
     humanNotes: [],
+    roundFailures: {},
     transcript: [],
   };
   saveMeeting(meeting);
@@ -278,10 +390,11 @@ function discoverMeetingWork(config) {
   );
 
   for (const meeting of meetings) {
-    if (meeting.status === 'completed') continue;
+    if (isTerminalMeetingStatus(meeting.status)) continue;
 
     const round = meeting.round || 1;
     const roundName = meeting.status; // investigating, debating, concluding
+    if (!ACTIVE_MEETING_STATUSES.has(roundName)) continue;
     const agents = config.agents || {};
 
     if (roundName === 'concluding') {
@@ -357,6 +470,8 @@ function discoverMeetingWork(config) {
       // Skip if already submitted for this round
       if (roundName === 'investigating' && meeting.findings?.[agentId]) continue;
       if (roundName === 'debating' && meeting.debate?.[agentId]) continue;
+      const dispatchRoundName = roundName === 'investigating' ? 'investigate' : 'debate';
+      if (hasRoundFailure(meeting, dispatchRoundName, agentId, round)) continue;
 
       const key = `meeting-${meeting.id}-r${round}-${agentId}`;
       if (activeKeys.has(key)) continue;
@@ -401,7 +516,7 @@ function discoverMeetingWork(config) {
           source: 'meeting',
           meetingId: meeting.id,
           round,
-          roundName: roundName === 'investigating' ? 'investigate' : 'debate',
+          roundName: dispatchRoundName,
         }
       });
     }
@@ -413,20 +528,54 @@ function discoverMeetingWork(config) {
  * Collect findings from a completed meeting agent.
  * Called from runPostCompletionHooks when type === 'meeting'.
  */
-function collectMeetingFindings(meetingId, agentId, roundName, output, structuredCompletion = null) {
+function collectMeetingFindings(meetingId, agentId, roundName, output, structuredCompletion = null, expectedRound = null, completionInfo = {}) {
   const meeting = getMeeting(meetingId);
   if (!meeting) return;
-  if (meeting.status === 'completed' || meeting.status === 'archived') {
+  if (isTerminalMeetingStatus(meeting.status)) {
     log('info', `Ignoring late findings from ${agentId} for completed meeting ${meetingId}`);
     return;
   }
 
-  const content = resolveMeetingContributionContent(output, structuredCompletion);
+  const expectedStatus = expectedMeetingStatusForRound(roundName);
+  if (!expectedStatus) {
+    log('warn', `Meeting ${meetingId}: ignoring ${agentId} output for unknown round "${roundName || '(empty)'}"`);
+    return;
+  }
+  if (meeting.status !== expectedStatus) {
+    log('info', `Ignoring stale ${roundName} output from ${agentId} for meeting ${meetingId} currently ${meeting.status}`);
+    return;
+  }
+  if (expectedRound !== null && expectedRound !== undefined && Number(meeting.round || 1) !== Number(expectedRound)) {
+    log('info', `Ignoring stale round ${expectedRound} output from ${agentId} for meeting ${meetingId} currently on round ${meeting.round || 1}`);
+    return;
+  }
+  if (hasRoundTerminalOutcome(meeting, roundName, agentId, meeting.round)) {
+    log('info', `Ignoring duplicate ${roundName} output from ${agentId} for meeting ${meetingId}`);
+    return;
+  }
 
-  // Validate output — reject empty or placeholder responses
-  if (isEmptyMeetingContent(content)) {
-    log('warn', `Meeting ${meetingId}: agent ${agentId} returned empty output for ${roundName} — rejecting`);
-    // Don't record it — agent will be re-dispatched on next tick
+  const content = resolveMeetingContributionContent(output, structuredCompletion);
+  const completionSucceeded = completionInfo?.success !== false;
+
+  if (!completionSucceeded || isEmptyMeetingContent(content)) {
+    const failures = getRoundFailures(meeting, roundName, meeting.round, true);
+    const reason = !completionSucceeded
+      ? (completionInfo?.reason || completionInfo?.completionStatus || 'Agent failed before completing the meeting round')
+      : 'Agent produced empty meeting output';
+    failures[agentId] = {
+      reason,
+      content: content || completionInfo?.summary || '',
+      submittedAt: ts(),
+    };
+    meeting.transcript.push({
+      round: meeting.round,
+      agent: agentId,
+      type: 'failure',
+      content: reason,
+      at: ts(),
+    });
+    log('warn', `Meeting ${meetingId}: agent ${agentId} failed ${roundName} — ${reason}`);
+    advanceMeetingIfRoundComplete(meeting, roundName, meetingId);
     saveMeeting(meeting);
     return;
   }
@@ -446,11 +595,7 @@ function collectMeetingFindings(meetingId, agentId, roundName, output, structure
     // Write transcript to inbox so agents learn from it (slug-based dedup)
     try {
       const config = queries.getConfig();
-      const agents = config.agents || {};
-      const transcript = meeting.transcript.map(t =>
-        `### ${agents[t.agent]?.name || t.agent} (${t.type}, Round ${t.round})\n\n${t.content}`
-      ).join('\n\n---\n\n');
-      shared.writeToInbox('meeting', meetingId, `# Meeting Transcript: ${meeting.title}\n\n${transcript}`);
+      writeMeetingTranscriptToInbox(meeting, meetingId, config.agents || {});
     } catch (e) { log('warn', `Meeting ${meetingId} inbox write: ${e.message}`); }
 
     log('info', `Meeting ${meetingId} completed — transcript written to inbox`);
@@ -458,26 +603,7 @@ function collectMeetingFindings(meetingId, agentId, roundName, output, structure
     return;
   }
 
-  // Check if all participants have submitted for this round
-  const participantCount = meeting.participants.length;
-  const allSubmitted =
-    (meeting.status === 'investigating' && Object.keys(meeting.findings || {}).length >= participantCount) ||
-    (meeting.status === 'debating' && Object.keys(meeting.debate || {}).length >= participantCount);
-
-  if (allSubmitted) {
-    // Advance to next round
-    if (meeting.status === 'investigating') {
-      meeting.status = 'debating';
-      meeting.round = 2;
-      meeting.roundStartedAt = ts();
-      log('info', `Meeting ${meetingId}: all findings in — advancing to debate`);
-    } else if (meeting.status === 'debating') {
-      meeting.status = 'concluding';
-      meeting.round = 3;
-      meeting.roundStartedAt = ts();
-      log('info', `Meeting ${meetingId}: all debate responses in — advancing to conclusion`);
-    }
-  }
+  advanceMeetingIfRoundComplete(meeting, roundName, meetingId);
 
   saveMeeting(meeting);
 }
@@ -494,21 +620,54 @@ function addMeetingNote(meetingId, note) {
 function _killMeetingDispatches(meetingId) {
   try {
     const DISPATCH_PATH = path.join(shared.MINIONS_DIR, 'engine', 'dispatch.json');
-    const dispatch = safeJson(DISPATCH_PATH) || {};
-    const toKill = (dispatch.active || []).filter(d => d.meta?.meetingId === meetingId);
-    if (toKill.length === 0) return 0;
-    // Remove from active and move to completed
+    const tmpDir = path.join(shared.MINIONS_DIR, 'engine', 'tmp');
+    const entriesToStop = [];
+    const filesToDelete = [];
     shared.mutateJsonFileLocked(DISPATCH_PATH, (dp) => {
-      dp.active = (dp.active || []).filter(d => d.meta?.meetingId !== meetingId);
-      dp.completed = dp.completed || [];
-      for (const d of toKill) {
+      dp.pending = Array.isArray(dp.pending) ? dp.pending : [];
+      dp.active = Array.isArray(dp.active) ? dp.active : [];
+      dp.completed = Array.isArray(dp.completed) ? dp.completed : [];
+
+      for (const queue of ['pending', 'active']) {
+        const kept = [];
+        for (const d of dp[queue]) {
+          if (d.meta?.meetingId !== meetingId) {
+            kept.push(d);
+            continue;
+          }
+          entriesToStop.push(d);
+          filesToDelete.push(path.join(tmpDir, `pid-${d.id}.pid`));
+          filesToDelete.push(path.join(tmpDir, `prompt-${d.id}.md`));
+          filesToDelete.push(path.join(tmpDir, `sysprompt-${d.id}.md`));
+          filesToDelete.push(path.join(tmpDir, `sysprompt-${d.id}.md.tmp`));
+        }
+        dp[queue] = kept;
+      }
+
+      for (const d of entriesToStop) {
         dp.completed.push({ ...d, result: DISPATCH_RESULT.ERROR, reason: 'Meeting ended/advanced by human', completed_at: ts() });
       }
       if (dp.completed.length > 100) dp.completed = dp.completed.slice(-100);
       return dp;
     }, { defaultValue: { pending: [], active: [], completed: [] } });
-    log('info', `Killed ${toKill.length} active meeting dispatch(es) for ${meetingId}`);
-    return toKill.length;
+
+    const pidsToKill = [];
+    for (const d of entriesToStop) {
+      try {
+        const pidFile = path.join(tmpDir, `pid-${d.id}.pid`);
+        const pid = shared.validatePid(fs.readFileSync(pidFile, 'utf8').trim());
+        pidsToKill.push(pid);
+      } catch { /* pending entries and already-finished agents may not have PID files */ }
+    }
+    for (const pid of pidsToKill) {
+      try { shared.killGracefully({ pid }); } catch { /* process may already be dead */ }
+    }
+    for (const fp of filesToDelete) {
+      try { fs.unlinkSync(fp); } catch { /* sidecar may not exist */ }
+    }
+
+    if (entriesToStop.length > 0) log('info', `Killed ${entriesToStop.length} meeting dispatch(es) for ${meetingId}`);
+    return entriesToStop.length;
   } catch (e) { log('warn', 'kill meeting dispatches: ' + e.message); return 0; }
 }
 
@@ -563,7 +722,8 @@ function deleteMeeting(id) {
 
 /**
  * Check for meeting rounds that have exceeded the timeout.
- * Auto-advances to the next round with whatever responses were received.
+ * Timeout is observational: rounds advance only after every participant has
+ * succeeded or failed, and conclusion waits for the conclusion agent outcome.
  * Called from engine.js tick cycle.
  */
 function checkMeetingTimeouts(config) {
@@ -572,10 +732,13 @@ function checkMeetingTimeouts(config) {
     || ENGINE_DEFAULTS.meetingRoundTimeout;
 
   for (const meeting of meetings) {
-    if (meeting.status === 'completed') continue;
+    if (isTerminalMeetingStatus(meeting.status)) continue;
+    if (!ACTIVE_MEETING_STATUSES.has(meeting.status)) continue;
     if (!meeting.roundStartedAt) continue;
 
-    const elapsed = Date.now() - new Date(meeting.roundStartedAt).getTime();
+    const roundStartedMs = new Date(meeting.roundStartedAt).getTime();
+    if (!Number.isFinite(roundStartedMs)) continue;
+    const elapsed = Date.now() - roundStartedMs;
     if (elapsed < timeout) continue;
 
     const respondedCount = meeting.status === 'investigating'
@@ -585,38 +748,23 @@ function checkMeetingTimeouts(config) {
         : 0;
     const totalCount = meeting.participants.length;
 
-    if (meeting.status === 'investigating') {
-      log('warn', `Meeting ${meeting.id}: round 1 timed out after ${Math.round(elapsed / 60000)}min — ${respondedCount}/${totalCount} responded, advancing to debate`);
-      meeting.transcript.push({ round: meeting.round, agent: 'system', type: 'timeout', content: `Round 1 timed out — ${respondedCount}/${totalCount} findings received`, at: ts() });
-      meeting.status = 'debating';
-      meeting.round = 2;
-      meeting.roundStartedAt = ts();
-      saveMeeting(meeting);
-    } else if (meeting.status === 'debating') {
-      log('warn', `Meeting ${meeting.id}: round 2 timed out after ${Math.round(elapsed / 60000)}min — ${respondedCount}/${totalCount} responded, advancing to conclusion`);
-      meeting.transcript.push({ round: meeting.round, agent: 'system', type: 'timeout', content: `Round 2 timed out — ${respondedCount}/${totalCount} debate responses received`, at: ts() });
-      meeting.status = 'concluding';
-      meeting.round = 3;
-      meeting.roundStartedAt = ts();
-      saveMeeting(meeting);
+    const roundName = meeting.status === 'investigating'
+      ? 'investigate'
+      : meeting.status === 'debating'
+        ? 'debate'
+        : 'conclude';
+
+    if (roundName !== 'conclude') {
+      if (allParticipantsFinishedRound(meeting, roundName, meeting.round)) {
+        log('warn', `Meeting ${meeting.id}: round ${meeting.round} timed out after ${Math.round(elapsed / 60000)}min but all participants are terminal — advancing`);
+        meeting.transcript.push({ round: meeting.round, agent: 'system', type: 'timeout', content: `Round ${meeting.round} timed out after all participants finished`, at: ts() });
+        advanceMeetingIfRoundComplete(meeting, roundName, meeting.id, config);
+        saveMeeting(meeting);
+      } else {
+        log('warn', `Meeting ${meeting.id}: round ${meeting.round} timed out after ${Math.round(elapsed / 60000)}min — waiting for all participants to finish (${respondedCount}/${totalCount} succeeded)`);
+      }
     } else if (meeting.status === 'concluding') {
-      log('warn', `Meeting ${meeting.id}: conclusion round timed out after ${Math.round(elapsed / 60000)}min — auto-summarizing`);
-      const autoConclusion = buildTimedOutMeetingConclusion(meeting, config.agents || {});
-      meeting.conclusion = { content: autoConclusion, agent: 'system', submittedAt: ts() };
-      meeting.transcript.push({ round: meeting.round, agent: 'system', type: 'conclusion', content: autoConclusion, at: ts() });
-      meeting.status = 'completed';
-      meeting.completedAt = ts();
-
-      // Write transcript to inbox (same as normal conclusion path)
-      try {
-        const agents = config.agents || {};
-        const transcript = meeting.transcript.map(t =>
-          `### ${agents[t.agent]?.name || t.agent} (${t.type}, Round ${t.round})\n\n${t.content}`
-        ).join('\n\n---\n\n');
-        shared.writeToInbox('meeting', meeting.id, `# Meeting Transcript: ${meeting.title}\n\n${transcript}`);
-      } catch (e) { log('warn', `Meeting ${meeting.id} inbox write: ${e.message}`); }
-
-      saveMeeting(meeting);
+      log('warn', `Meeting ${meeting.id}: conclusion round timed out after ${Math.round(elapsed / 60000)}min — waiting for the conclusion agent to finish`);
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.1709",
+  "version": "0.1.1711",
   "description": "Multi-agent AI dev team that runs from ~/.minions/ — five autonomous agents share a single engine, dashboard, and knowledge base",
   "bin": {
     "minions": "bin/minions.js"