@yemi33/minions 0.1.1708 → 0.1.1710

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.1.1710 (2026-05-04)
+
+### Other
+- Fix meeting lifecycle edge cases
+
+## 0.1.1709 (2026-05-04)
+
+### Fixes
+-  auto-heal projects with missing workSources at engine boot
+
 ## 0.1.1708 (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/cli.js

@@ -379,6 +379,28 @@ const commands = {
     // refactor. No disk write — the on-disk config still carries `ccModel`.
     try { shared.applyLegacyCcModelMigration(config, { logger: e.log }); }
     catch (err) { e.log('warn', `legacy ccModel migration failed: ${err.message}`); }
+
+    // Auto-heal projects missing workSources (cloned-repo / hand-rolled-config
+    // footgun): without this block, discoverFromWorkItems / discoverFromPrs
+    // bail silently and the engine looks healthy but never dispatches. The
+    // disk-side mutation re-derives heal state from the on-disk copy so we
+    // don't clobber a concurrent dashboard write between the in-memory check
+    // and the lock acquire. skipWriteIfUnchanged makes the write a no-op when
+    // nothing needed healing (e.g. dashboard already fixed it).
+    try {
+      const heal = shared.backfillProjectWorkSourceDefaults(config);
+      if (heal.changed) {
+        const configPath = path.join(shared.MINIONS_DIR, 'config.json');
+        shared.mutateJsonFileLocked(configPath, (onDisk) => {
+          shared.backfillProjectWorkSourceDefaults(onDisk);
+          return onDisk;
+        }, { defaultValue: {}, skipWriteIfUnchanged: true });
+        for (const h of heal.healed) {
+          e.log('info', `Auto-healed project "${h.project}" — backfilled missing workSources: ${h.sources.join(', ')}`);
+        }
+        console.log(`  Auto-healed ${heal.healed.length} project(s) with missing workSources defaults — engine will now dispatch their work.`);
+      }
+    } catch (err) { e.log('warn', `workSources auto-heal failed: ${err.message}`); }
     const interval = config.engine?.tickInterval || shared.ENGINE_DEFAULTS.tickInterval;
 
     const { getProjects } = require('./shared');

package/engine/copilot-models.json

@@ -1,5 +1,5 @@
 {
   "runtime": "copilot",
   "models": null,
-  "cachedAt": "2026-05-04T16:42:47.140Z"
+  "cachedAt": "2026-05-04T17:10:04.905Z"
 }

package/engine/lifecycle.js

@@ -2662,7 +2662,7 @@ 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);
     } catch (err) { log('warn', `Meeting collect: ${err.message}`); }
   }
 

package/engine/meeting.js

@@ -20,6 +20,21 @@ 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 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 isEmptyMeetingContent(text) {
   const value = String(text || '').trim();
@@ -278,10 +293,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') {
@@ -413,14 +429,28 @@ 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) {
   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 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;
+  }
+
   const content = resolveMeetingContributionContent(output, structuredCompletion);
 
   // Validate output — reject empty or placeholder responses
@@ -494,21 +524,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; }
 }
 
@@ -572,10 +635,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'

package/engine/shared.js

@@ -1185,6 +1185,44 @@ function projectWorkSourceWarnings(config, getDataCounts) {
   return warnings;
 }
 
+/**
+ * Boot-time auto-heal for the cloned-repo / hand-rolled-config footgun: any
+ * project missing a `workSources.workItems` or `workSources.pullRequests`
+ * sub-block gets the dashboard's default backfilled. We only touch *missing*
+ * sub-blocks — an explicit `enabled: false` is treated as user intent and
+ * left alone.
+ *
+ * Pure helper — mutates `config` in place and returns
+ * `{ changed: boolean, healed: Array<{ project, sources }> }` so the caller
+ * can decide whether to persist + log. Returns `{ changed: false, healed: [] }`
+ * for null/empty/malformed input.
+ */
+function backfillProjectWorkSourceDefaults(config) {
+  const result = { changed: false, healed: [] };
+  if (!config || typeof config !== 'object') return result;
+  const projects = Array.isArray(config.projects) ? config.projects : [];
+  for (const project of projects) {
+    if (!project || typeof project !== 'object') continue;
+    const filled = [];
+    if (!project.workSources || typeof project.workSources !== 'object') {
+      project.workSources = {};
+    }
+    if (!project.workSources.pullRequests) {
+      project.workSources.pullRequests = { enabled: true, cooldownMinutes: 30 };
+      filled.push('pullRequests');
+    }
+    if (!project.workSources.workItems) {
+      project.workSources.workItems = { enabled: true, cooldownMinutes: 0 };
+      filled.push('workItems');
+    }
+    if (filled.length > 0) {
+      result.changed = true;
+      result.healed.push({ project: project.name, sources: filled });
+    }
+  }
+  return result;
+}
+
 // ─── Status & Type Constants ─────────────────────────────────────────────────
 
 const WI_STATUS = {
@@ -2581,6 +2619,7 @@ module.exports = {
   applyLegacyCcModelMigration, _resetLegacyCcModelMigrationFlag,
   runtimeConfigWarnings,
   projectWorkSourceWarnings,
+  backfillProjectWorkSourceDefaults,
   WI_STATUS, DONE_STATUSES, PLAN_TERMINAL_STATUSES, WORK_TYPE, PLAN_STATUS, PRD_ITEM_STATUS, PRD_MATERIALIZABLE, PR_STATUS, PR_POLLABLE_STATUSES, PR_PENDING_REASON, DISPATCH_RESULT, trackReviewMetric, queuePlanToPrd,
   WATCH_STATUS, WATCH_TARGET_TYPE, WATCH_CONDITION, WATCH_ABSOLUTE_CONDITIONS,
   PIPELINE_STATUS, STAGE_TYPE, MEETING_STATUS, AGENT_STATUS,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.1708",
+  "version": "0.1.1710",
   "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"