@yemi33/minions 0.1.86 → 0.1.87

package/engine/meeting.js

@@ -6,11 +6,14 @@
 const fs = require('fs');
 const path = require('path');
 const shared = require('./shared');
-const { safeJson, safeWrite, safeRead, uid } = shared;
+const { safeJson, safeWrite, safeRead, uid, log, ENGINE_DEFAULTS } = shared;
 const queries = require('./queries');
-const { getDispatch } = queries;
+const { getDispatch, getConfig } = queries;
 const { renderPlaybook } = require('./playbook');
 
+/** Patterns that indicate an agent returned no meaningful output */
+const EMPTY_OUTPUT_PATTERNS = ['(no output)', '(no findings)', '(no response)'];
+
 let _engine = null;
 function engine() { if (!_engine) _engine = require('../engine'); return _engine; }
 
@@ -43,6 +46,7 @@ function createMeeting({ title, agenda, participants }) {
     participants: participants || [],
     createdBy: 'human',
     createdAt: new Date().toISOString(),
+    roundStartedAt: new Date().toISOString(),
     findings: {},
     debate: {},
     conclusion: null,
@@ -175,12 +179,20 @@ function discoverMeetingWork(config) {
  * Called from runPostCompletionHooks when type === 'meeting'.
  */
 function collectMeetingFindings(meetingId, agentId, roundName, output) {
-  const e = engine();
   const meeting = getMeeting(meetingId);
   if (!meeting) return;
 
   const { text } = shared.parseStreamJsonOutput(output, { maxTextLength: 50000 });
-  const content = text || '(no output)';
+  const rawContent = (text || '').trim();
+
+  // Validate output — reject empty or placeholder responses
+  if (!rawContent || EMPTY_OUTPUT_PATTERNS.includes(rawContent)) {
+    e.log('warn', `Meeting ${meetingId}: agent ${agentId} returned empty output for ${roundName} — rejecting`);
+    // Don't record it — agent will be re-dispatched on next tick
+    saveMeeting(meeting);
+    return;
+  }
+  const content = rawContent;
 
   if (roundName === 'investigate') {
     meeting.findings[agentId] = { content, submittedAt: new Date().toISOString() };
@@ -204,7 +216,7 @@ function collectMeetingFindings(meetingId, agentId, roundName, output) {
       `meeting-${meetingId}-${new Date().toISOString().slice(0, 10)}.md`);
     safeWrite(inboxPath, `# Meeting Transcript: ${meeting.title}\n\n${transcript}`);
 
-    e.log('info', `Meeting ${meetingId} completed — transcript written to inbox`);
+    log('info', `Meeting ${meetingId} completed — transcript written to inbox`);
     saveMeeting(meeting);
     return;
   }
@@ -221,11 +233,13 @@ function collectMeetingFindings(meetingId, agentId, roundName, output) {
     if (meeting.status === 'investigating') {
       meeting.status = 'debating';
       meeting.round = 2;
-      e.log('info', `Meeting ${meetingId}: all findings in — advancing to debate`);
+      meeting.roundStartedAt = new Date().toISOString();
+      log('info', `Meeting ${meetingId}: all findings in — advancing to debate`);
     } else if (meeting.status === 'debating') {
       meeting.status = 'concluding';
       meeting.round = 3;
-      e.log('info', `Meeting ${meetingId}: all debate responses in — advancing to conclusion`);
+      meeting.roundStartedAt = new Date().toISOString();
+      log('info', `Meeting ${meetingId}: all debate responses in — advancing to conclusion`);
     }
   }
 
@@ -246,6 +260,7 @@ function advanceMeetingRound(meetingId) {
   if (!meeting || meeting.status === 'completed') return null;
   if (meeting.status === 'investigating') { meeting.status = 'debating'; meeting.round = 2; }
   else if (meeting.status === 'debating') { meeting.status = 'concluding'; meeting.round = 3; }
+  meeting.roundStartedAt = new Date().toISOString();
   saveMeeting(meeting);
   return meeting;
 }
@@ -284,8 +299,57 @@ function deleteMeeting(id) {
   return true;
 }
 
+/**
+ * Check for meeting rounds that have exceeded the timeout.
+ * Auto-advances to the next round with whatever responses were received.
+ * Called from engine.js tick cycle.
+ */
+function checkMeetingTimeouts(config) {
+  const e = engine();
+  const meetings = getMeetings();
+  const timeout = (config.engine || {}).meetingRoundTimeout
+    || ENGINE_DEFAULTS.meetingRoundTimeout;
+
+  for (const meeting of meetings) {
+    if (meeting.status === 'completed') continue;
+    if (!meeting.roundStartedAt) continue;
+
+    const elapsed = Date.now() - new Date(meeting.roundStartedAt).getTime();
+    if (elapsed < timeout) continue;
+
+    const respondedCount = meeting.status === 'investigating'
+      ? Object.keys(meeting.findings || {}).length
+      : meeting.status === 'debating'
+        ? Object.keys(meeting.debate || {}).length
+        : 0;
+    const totalCount = meeting.participants.length;
+
+    if (meeting.status === 'investigating') {
+      e.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: new Date().toISOString() });
+      meeting.status = 'debating';
+      meeting.round = 2;
+      meeting.roundStartedAt = new Date().toISOString();
+      saveMeeting(meeting);
+    } else if (meeting.status === 'debating') {
+      e.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: new Date().toISOString() });
+      meeting.status = 'concluding';
+      meeting.round = 3;
+      meeting.roundStartedAt = new Date().toISOString();
+      saveMeeting(meeting);
+    } else if (meeting.status === 'concluding') {
+      e.log('warn', `Meeting ${meeting.id}: conclusion round timed out after ${Math.round(elapsed / 60000)}min — ending meeting without conclusion`);
+      meeting.transcript.push({ round: meeting.round, agent: 'system', type: 'timeout', content: 'Conclusion round timed out — meeting ended without conclusion', at: new Date().toISOString() });
+      meeting.status = 'completed';
+      meeting.completedAt = new Date().toISOString();
+      saveMeeting(meeting);
+    }
+  }
+}
 module.exports = {
   MEETINGS_DIR, getMeetings, getMeeting, saveMeeting, createMeeting,
-  discoverMeetingWork, collectMeetingFindings,
+  discoverMeetingWork, collectMeetingFindings, checkMeetingTimeouts,
   addMeetingNote, advanceMeetingRound, endMeeting, archiveMeeting, unarchiveMeeting, deleteMeeting,
+  EMPTY_OUTPUT_PATTERNS,
 };

package/engine/playbook.js

@@ -9,21 +9,15 @@ const path = require('path');
 const shared = require('./shared');
 const queries = require('./queries');
 
-const { safeJson, safeRead, getProjects } = shared;
+const { safeJson, safeRead, getProjects, log, dateStamp } = shared;
 const { getConfig, getDispatch, getNotes, getAgentCharter, getPrs, AGENTS_DIR } = queries;
 
 const MINIONS_DIR = path.resolve(__dirname, '..');
 const PLAYBOOKS_DIR = path.join(MINIONS_DIR, 'playbooks');
 
-// Lazy require to avoid circular dependency with engine.js
-let _engine = null;
-function engine() { if (!_engine) _engine = require('../engine'); return _engine; }
-
 // Import tempAgents from routing module
 const { tempAgents } = require('./routing');
 
-function dateStamp() { return new Date().toISOString().slice(0, 10); }
-
 // ─── Repo Host Helpers ──────────────────────────────────────────────────────
 
 function getRepoHost(project) {
@@ -123,7 +117,7 @@ function resolveTaskContext(item, config) {
     name: (a.name || id).toLowerCase(),
   }));
   const resolved = { additionalContext: '', referencedFiles: [] };
-  const log = (...args) => engine().log(...args);
+
 
   // Match agent references: "ripley's plan", "dallas's pr", "lambert's output", etc.
   for (const agent of agentNames) {
@@ -194,7 +188,7 @@ function resolveTaskContext(item, config) {
   // If no specific reference was resolved but the text mentions "the plan" or "latest plan",
   // find the most recent plan
   if (!resolved.additionalContext && /\b(the|latest|last|recent)\s+plan\b/i.test(text)) {
-    const log = (...args) => engine().log(...args);
+  
     try {
       const plans = fs.readdirSync(path.join(MINIONS_DIR, 'plans'))
         .filter(f => f.endsWith('.md') || f.endsWith('.json'))
@@ -218,7 +212,7 @@ function renderPlaybook(type, vars) {
   const pbPath = path.join(PLAYBOOKS_DIR, `${type}.md`);
   let content;
   try { content = fs.readFileSync(pbPath, 'utf8'); } catch {
-    engine().log('warn', `Playbook not found: ${type}`);
+    log('warn', `Playbook not found: ${type}`);
     return null;
   }
 
@@ -291,6 +285,22 @@ function renderPlaybook(type, vars) {
     content = content.replace(new RegExp(`\\{\\{${key}\\}\\}`, 'g'), String(val));
   }
 
+  // Warn on variables that resolved to empty string
+  const emptyVars = Object.entries(allVars)
+    .filter(([, val]) => String(val) === '')
+    .map(([key]) => key);
+  if (emptyVars.length > 0) {
+    const msg = `Playbook "${type}": template variables resolved to empty string: ${emptyVars.join(', ')}`;
+    try { engine().log('warn', msg); } catch { /* engine not ready */ }
+  }
+
+  // Warn on any remaining unresolved {{variable}} placeholders
+  const unresolved = [...new Set((content.match(/\{\{(\w+)\}\}/g) || []).map(m => m.slice(2, -2)))];
+  if (unresolved.length > 0) {
+    const msg = `Playbook "${type}": unresolved template variables: ${unresolved.join(', ')}`;
+    try { engine().log('warn', msg); } catch { /* engine not ready */ }
+  }
+
   return content;
 }
 
@@ -338,7 +348,7 @@ function buildSystemPrompt(agentId, config, project) {
 function buildAgentContext(agentId, config, project) {
   project = project || getProjects(config)[0] || {};
   let context = '';
-  const log = (...args) => engine().log(...args);
+
 
   // Agent history — last 5 tasks only (keeps it relevant, avoids 37KB dumps)
   const history = safeRead(path.join(AGENTS_DIR, agentId, 'history.md'));

package/engine/shared.js

@@ -8,6 +8,26 @@ const path = require('path');
 
 const MINIONS_DIR = path.resolve(__dirname, '..');
 const PR_LINKS_PATH = path.join(MINIONS_DIR, 'engine', 'pr-links.json');
+const LOG_PATH = path.join(__dirname, 'log.json');
+
+// ── Timestamps & Logging ────────────────────────────────────────────────────
+// Extracted from engine.js so engine/* modules can import directly without
+// circular-requiring the orchestrator.
+
+function ts() { return new Date().toISOString(); }
+function logTs() { return new Date().toLocaleTimeString(); }
+function dateStamp() { return new Date().toISOString().slice(0, 10); }
+
+function log(level, msg, meta = {}) {
+  const entry = { timestamp: ts(), level, message: msg, ...meta };
+  console.log(`[${logTs()}] [${level}] ${msg}`);
+
+  let logData = safeJson(LOG_PATH) || [];
+  if (!Array.isArray(logData)) logData = logData.entries || [];
+  logData.push(entry);
+  if (logData.length > 2000) logData.splice(0, logData.length - 2000);
+  safeWrite(LOG_PATH, logData);
+}
 
 // ── File I/O ─────────────────────────────────────────────────────────────────
 
@@ -41,16 +61,18 @@ function safeWrite(p, data) {
           try { const ab = new SharedArrayBuffer(4); Atomics.wait(new Int32Array(ab), 0, 0, delay); } catch { /* fallback busy-wait */ const start = Date.now(); while (Date.now() - start < delay) {} }
           continue;
         }
-        // Final attempt failed — fall through to direct write
+        // Final attempt failed — throw to let caller retry
+        try { fs.unlinkSync(tmp); } catch { /* cleanup */ }
+        throw e;
       }
     }
-    // All rename attempts failed — direct write as fallback (not atomic but won't lose data)
+    // All rename attempts exhausted without throw — should not happen, but clean up
     try { fs.unlinkSync(tmp); } catch { /* cleanup */ }
-    fs.writeFileSync(p, content);
+    throw new Error(`[safeWrite] All 5 rename attempts failed for ${p}`);
   } catch (err) {
-    // Even direct write failed — log and clean up tmp
-    console.error(`[safeWrite] FAILED to write ${p}: ${err.message}`);
+    // Clean up tmp if it still exists, then re-throw — never silently swallow
     try { fs.unlinkSync(tmp); } catch { /* cleanup */ }
+    throw err;
   }
 }
 
@@ -102,6 +124,9 @@ function mutateJsonFileLocked(filePath, mutateFn, {
   return withFileLock(lockPath, () => {
     let data = safeJson(filePath);
     if (data === null || typeof data !== 'object') data = Array.isArray(defaultValue) ? [...defaultValue] : { ...defaultValue };
+    // Back up last-known-good state before mutation (best-effort)
+    const backupPath = filePath + '.bak';
+    try { if (fs.existsSync(filePath)) fs.copyFileSync(filePath, backupPath); } catch { /* backup is best-effort */ }
     const next = mutateFn(data);
     const finalData = next === undefined ? data : next;
     safeWrite(filePath, finalData);
@@ -261,6 +286,7 @@ const ENGINE_DEFAULTS = {
   shutdownTimeout: 300000, // 5min — max wait for active agents during graceful shutdown
   allowTempAgents: false, // opt-in: spawn ephemeral agents when all permanent agents are busy
   autoDecompose: true, // auto-decompose implement:large items into sub-tasks
+  meetingRoundTimeout: 600000, // 10min per meeting round before auto-advance
 };
 
 const DEFAULT_AGENTS = {
@@ -380,6 +406,11 @@ function addPrLink(prId, itemId) {
 module.exports = {
   MINIONS_DIR,
   PR_LINKS_PATH,
+  LOG_PATH,
+  ts,
+  logTs,
+  dateStamp,
+  log,
   safeRead,
   safeReadDir,
   safeJson,

package/engine.js

@@ -82,30 +82,16 @@ function validateConfig(config) {
   }
 }
 
-const { getProjects, projectRoot, projectStateDir, projectWorkItemsPath, projectPrPath, getAdoOrgBase, sanitizeBranch, parseSkillFrontmatter, safeReadDir } = shared;
+const { getProjects, projectRoot, projectStateDir, projectWorkItemsPath, projectPrPath, getAdoOrgBase, sanitizeBranch, parseSkillFrontmatter, safeReadDir,
+  ts, logTs, dateStamp, log } = shared;
 
 // ─── Utilities ──────────────────────────────────────────────────────────────
 
-function ts() { return new Date().toISOString(); }
-function logTs() { return new Date().toLocaleTimeString(); }
-function dateStamp() { return new Date().toISOString().slice(0, 10); }
-
 const safeJson = shared.safeJson;
 const safeRead = shared.safeRead;
 const safeWrite = shared.safeWrite;
 const mutateJsonFileLocked = shared.mutateJsonFileLocked;
 
-function log(level, msg, meta = {}) {
-  const entry = { timestamp: ts(), level, message: msg, ...meta };
-  console.log(`[${logTs()}] [${level}] ${msg}`);
-
-  let logData = safeJson(LOG_PATH) || [];
-  if (!Array.isArray(logData)) logData = logData.entries || [];
-  logData.push(entry);
-  if (logData.length > 2000) logData.splice(0, logData.length - 2000);
-  safeWrite(LOG_PATH, logData);
-}
-
 // ─── Dispatch Management (extracted to engine/dispatch.js) ───────────────────
 
 const { mutateDispatch, addToDispatch, isRetryableFailureReason, completeDispatch,
@@ -2051,6 +2037,12 @@ async function tickInner() {
   checkSteering(config);
   checkIdleThreshold(config);
 
+  // 1b. Check for meeting round timeouts
+  try {
+    const { checkMeetingTimeouts } = require('./engine/meeting');
+    checkMeetingTimeouts(config);
+  } catch (e) { log('warn', 'check meeting timeouts: ' + e.message); }
+
   // In stopping state, only track agent completions — skip discovery and dispatch
   if (control.state === 'stopping') {
     log('info', `Engine stopping — ${activeProcesses.size} agent(s) still active, skipping discovery/dispatch`);

package/package.json

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

package/tools/generate-pixel-art.js

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+/**
+ * generate-pixel-art.js
+ *
+ * Generates a 16x16 pixel art BMP image of a little robot character.
+ * Uses only Node.js built-ins — no external dependencies.
+ *
+ * Usage: node tools/generate-pixel-art.js [output-path]
+ * Default output: tools/pixel-robot.bmp
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// --- Color palette (R, G, B) ---
+const COLORS = {
+  _: [0, 0, 0, 0],       // transparent (white background)
+  B: [30, 30, 30],        // black (outline)
+  G: [80, 80, 80],        // dark gray (body shadow)
+  S: [160, 160, 160],     // silver (body)
+  W: [220, 220, 220],     // white (highlight)
+  R: [220, 50, 50],       // red (antenna light / accent)
+  C: [60, 180, 220],      // cyan (eyes)
+  Y: [240, 200, 60],      // yellow (chest light)
+  D: [100, 100, 100],     // mid gray (limbs)
+};
+
+// 16x16 pixel grid — a cute robot sprite
+// Each character maps to COLORS above
+// Row 0 = top of image
+const SPRITE = [
+  '______RR________',  // row 0:  antenna light
+  '______BB________',  // row 1:  antenna stem
+  '____BBBBBB______',  // row 2:  head top
+  '___BWSSSSSWB____',  // row 3:  head
+  '___BCCSSWCCB____',  // row 4:  eyes (cyan pupils)
+  '___BCCSSWCCB____',  // row 5:  eyes
+  '___BSSGGSSSB____',  // row 6:  mouth
+  '____BBBBBB______',  // row 7:  head bottom
+  '___BSSYYSSB_____',  // row 8:  chest top + yellow light
+  '___DBSSSSSBD____',  // row 9:  chest + arms
+  '___DBSSSSSBD____',  // row 10: chest + arms
+  '___DBSSSSSBD____',  // row 11: chest + arms
+  '____BBBBBB______',  // row 12: waist
+  '____BD__DB______',  // row 13: legs
+  '____BD__DB______',  // row 14: legs
+  '___BBDD_DDBB____',  // row 15: feet
+];
+
+const WIDTH = 16;
+const HEIGHT = 16;
+
+function createBMP(pixelGrid, width, height) {
+  // BMP with 24-bit color (no alpha)
+  const rowSize = Math.ceil((width * 3) / 4) * 4; // rows padded to 4-byte boundary
+  const pixelDataSize = rowSize * height;
+  const fileSize = 54 + pixelDataSize; // 14 (file header) + 40 (DIB header) + pixels
+
+  const buf = Buffer.alloc(fileSize);
+
+  // --- BMP File Header (14 bytes) ---
+  buf.write('BM', 0);                    // signature
+  buf.writeUInt32LE(fileSize, 2);         // file size
+  buf.writeUInt16LE(0, 6);               // reserved1
+  buf.writeUInt16LE(0, 8);               // reserved2
+  buf.writeUInt32LE(54, 10);             // pixel data offset
+
+  // --- DIB Header (BITMAPINFOHEADER, 40 bytes) ---
+  buf.writeUInt32LE(40, 14);             // DIB header size
+  buf.writeInt32LE(width, 18);           // width
+  buf.writeInt32LE(height, 22);          // height (positive = bottom-up)
+  buf.writeUInt16LE(1, 26);             // color planes
+  buf.writeUInt16LE(24, 28);            // bits per pixel
+  buf.writeUInt32LE(0, 30);             // compression (none)
+  buf.writeUInt32LE(pixelDataSize, 34);  // image size
+  buf.writeInt32LE(2835, 38);           // horizontal resolution (72 DPI)
+  buf.writeInt32LE(2835, 42);           // vertical resolution (72 DPI)
+  buf.writeUInt32LE(0, 46);             // colors in palette
+  buf.writeUInt32LE(0, 50);             // important colors
+
+  // --- Pixel Data (bottom-up, BGR order) ---
+  for (let y = 0; y < height; y++) {
+    // BMP stores rows bottom-to-top
+    const srcRow = pixelGrid[height - 1 - y];
+    const rowOffset = 54 + y * rowSize;
+
+    for (let x = 0; x < width; x++) {
+      const char = srcRow[x] || '_';
+      const color = COLORS[char] || COLORS['_'];
+      const r = color[0], g = color[1], b = color[2];
+
+      // BMP uses BGR byte order
+      const pixelOffset = rowOffset + x * 3;
+      buf[pixelOffset] = b;
+      buf[pixelOffset + 1] = g;
+      buf[pixelOffset + 2] = r;
+    }
+    // Padding bytes are already 0 from Buffer.alloc
+  }
+
+  return buf;
+}
+
+// Parse sprite into proper grid
+function parseSpriteGrid(spriteLines, width) {
+  return spriteLines.map(line => {
+    const chars = [];
+    for (let i = 0; i < width; i++) {
+      chars.push(line[i] || '_');
+    }
+    return chars;
+  });
+}
+
+// Fill background with white for "transparent" pixels
+function fillBackground(grid) {
+  return grid.map(row =>
+    row.map(c => {
+      if (c === '_') return '_';
+      return c;
+    })
+  );
+}
+
+// Generate
+const grid = parseSpriteGrid(SPRITE, WIDTH);
+const bmpBuffer = createBMP(grid, WIDTH, HEIGHT);
+
+const outputPath = process.argv[2] || path.join(__dirname, 'pixel-robot.bmp');
+fs.writeFileSync(outputPath, bmpBuffer);
+
+console.log(`✓ Pixel art robot generated: ${outputPath}`);
+console.log(`  Size: ${WIDTH}x${HEIGHT} pixels, ${bmpBuffer.length} bytes`);
+console.log(`  Format: 24-bit BMP (uncompressed)`);