@yemi33/minions 0.1.921 → 0.1.923

package/CHANGELOG.md

@@ -1,8 +1,9 @@
 # Changelog
 
-## 0.1.921 (2026-04-13)
+## 0.1.923 (2026-04-13)
 
 ### Features
+- add /api/work-items/reopen endpoint and reopen-work-item CC action (#982)
 - CC tab unread dot + reopened badge on work items
 - fix dep re-merge failure on retry with existing commits (#977)
 - audit and harden log buffering implementation (#971)
@@ -18,6 +19,8 @@
 - add red dot notification on CC tab when response completes (#934) (#946)
 
 ### Fixes
+-  429 retry on abort race applies to all sends, not just queued
+- show actionable failure context instead of Unknown error (#1003)
 - prioritize error_max_turns over permission-blocked in classifyFailure (#1001)
 -  optimistic archive hides both PRD and linked source plan simultaneously
 - align CC tab unread dot to same position as working dot
@@ -36,6 +39,8 @@
 - prohibit agents from self-merging their own PRs
 
 ### Other
+- test(preflight): add unit tests for findClaudeBinary, runPreflight, printPreflight, checkOrExit (#953)
+- test(meeting): add unit tests for key functions (#957)
 - [E2E] Architecture meeting Tier 1+2: 6 correctness bugs + 2 nested lock violations + log buffering (#972)
 
 ## 0.1.901 (2026-04-12)

package/dashboard/js/command-center.js

@@ -538,12 +538,11 @@ async function _ccDoSend(message, skipUserMsg, forceTabId) {
     });
 
     if (!res.ok) {
-      // 429 = server still processing previous request (abort race) — retry silently up to 3 times
+      // 429 = server still releasing previous request (abort race) — retry silently up to 3 times
       if (res.status === 429 && (!activeTab._429retries || activeTab._429retries < 3)) {
         activeTab._429retries = (activeTab._429retries || 0) + 1;
-        _cleanupStreamDiv();
         await new Promise(function(r) { setTimeout(r, 1500); });
-        return await _ccDoSend(message, true);
+        return await _ccDoSend(message, true); // retry with skipUserMsg=true (already displayed)
       }
       activeTab._429retries = 0;
       _cleanupStreamDiv();
@@ -1122,6 +1121,13 @@ async function ccExecuteAction(action, targetTabId) {
         status.style.color = 'var(--green)';
         break;
       }
+      case 'reopen-work-item': {
+        await _ccFetch('/api/work-items/reopen', { id: action.id, project: action.project || action.source || '', description: action.description });
+        status.innerHTML = '&#10003; Work item reopened: <strong>' + escHtml(action.id) + '</strong>';
+        status.style.color = 'var(--green)';
+        wakeEngine();
+        break;
+      }
       case 'reopen-prd-item': {
         await _ccFetch('/api/prd-items/update', { source: action.file, itemId: action.id, status: 'updated' });
         status.innerHTML = '&#10003; PRD item reopened: <strong>' + escHtml(action.id) + '</strong>';

package/dashboard.js

@@ -23,7 +23,7 @@ const queries = require('./engine/queries');
 const teams = require('./engine/teams');
 const os = require('os');
 
-const { safeRead, safeReadDir, safeWrite, safeJson, safeJsonObj, safeJsonArr, safeUnlink, mutateJsonFileLocked, mutateWorkItems, getProjects: _getProjects, DONE_STATUSES, WI_STATUS } = shared;
+const { safeRead, safeReadDir, safeWrite, safeJson, safeJsonObj, safeJsonArr, safeUnlink, mutateJsonFileLocked, mutateWorkItems, getProjects: _getProjects, DONE_STATUSES, WI_STATUS, reopenWorkItem } = shared;
 const { getAgents, getAgentDetail, getPrdInfo, getWorkItems, getDispatchQueue,
   getSkills, getInbox, getNotesWithMeta, getPullRequests,
   getEngineLog, getMetrics, getKnowledgeBaseEntries, timeSince,
@@ -616,6 +616,41 @@ async function executeCCActions(actions) {
           results.push({ type: 'knowledge', ok: true });
           break;
         }
+        case 'reopen-work-item': {
+          const project = action.project || '';
+          const targetProject = project ? PROJECTS.find(p => p.name?.toLowerCase() === project.toLowerCase()) : PROJECTS[0];
+          const wiPath = targetProject ? shared.projectWorkItemsPath(targetProject) : path.join(MINIONS_DIR, 'work-items.json');
+          let reopenResult = null;
+          mutateJsonFileLocked(wiPath, items => {
+            if (!Array.isArray(items)) items = [];
+            const item = items.find(i => i.id === action.id);
+            if (!item) { reopenResult = { error: 'item not found' }; return items; }
+            if (item.status !== WI_STATUS.DONE && item.status !== WI_STATUS.FAILED && !DONE_STATUSES.has(item.status)) {
+              reopenResult = { error: 'can only reopen done or failed items' }; return items;
+            }
+            reopenWorkItem(item);
+            if (action.description) item.description = action.description;
+            reopenResult = { ok: true };
+            return items;
+          }, { defaultValue: [] });
+          if (reopenResult?.ok) {
+            // Clear dispatch history outside lock
+            const sourcePrefix = targetProject ? `work-${targetProject.name}-` : 'central-work-';
+            const dispatchKey = sourcePrefix + action.id;
+            try {
+              const dispatchPath = path.join(MINIONS_DIR, 'engine', 'dispatch.json');
+              mutateJsonFileLocked(dispatchPath, dispatch => {
+                dispatch.completed = Array.isArray(dispatch.completed) ? dispatch.completed : [];
+                dispatch.completed = dispatch.completed.filter(d => d.meta?.dispatchKey !== dispatchKey);
+                dispatch.completed = dispatch.completed.filter(d => !d.meta?.parentKey || d.meta.parentKey !== dispatchKey);
+                return dispatch;
+              }, { defaultValue: { pending: [], active: [], completed: [] } });
+            } catch { /* best effort */ }
+            invalidateStatusCache();
+          }
+          results.push({ type: 'reopen-work-item', id: action.id, ...(reopenResult || { error: 'unexpected' }) });
+          break;
+        }
         default:
           // Server didn't handle — frontend must execute
           results.push({ type: action.type });
@@ -1358,6 +1393,66 @@ const server = http.createServer(async (req, res) => {
     } catch (e) { console.error('Archive fetch error:', e.message); return jsonReply(res, 500, { error: e.message }); }
   }
 
+  async function handleWorkItemsReopen(req, res) {
+    try {
+      const body = await readBody(req);
+      const { id, description } = body;
+      const project = body.project || body.source;
+      if (!id) return jsonReply(res, 400, { error: 'id required' });
+
+      // Find the right work-items file
+      let wiPath;
+      if (!project || project === 'central') {
+        wiPath = path.join(MINIONS_DIR, 'work-items.json');
+      } else {
+        const proj = PROJECTS.find(p => p.name === project);
+        if (proj) wiPath = shared.projectWorkItemsPath(proj);
+      }
+      if (!wiPath) return jsonReply(res, 404, { error: 'project not found' });
+
+      let result = null;
+      mutateJsonFileLocked(wiPath, (items) => {
+        if (!Array.isArray(items)) items = [];
+        const item = items.find(i => i.id === id);
+        if (!item) { result = { code: 404, body: { error: 'item not found' } }; return items; }
+        if (item.status !== WI_STATUS.DONE && item.status !== WI_STATUS.FAILED && !DONE_STATUSES.has(item.status)) {
+          result = { code: 400, body: { error: 'can only reopen done or failed items (current: ' + item.status + ')' } };
+          return items;
+        }
+        reopenWorkItem(item);
+        if (description !== undefined) item.description = description;
+        result = { code: 200, body: { ok: true, item } };
+        return items;
+      });
+      if (!result) return jsonReply(res, 500, { error: 'unexpected state' });
+      if (result.code !== 200) return jsonReply(res, result.code, result.body);
+
+      // Clear dispatch history and cooldowns outside lock
+      const sourcePrefix = (!project || project === 'central') ? 'central-work-' : `work-${project}-`;
+      const dispatchKey = sourcePrefix + id;
+      try {
+        const dispatchPath = path.join(MINIONS_DIR, 'engine', 'dispatch.json');
+        mutateJsonFileLocked(dispatchPath, (dispatch) => {
+          dispatch.completed = Array.isArray(dispatch.completed) ? dispatch.completed : [];
+          dispatch.completed = dispatch.completed.filter(d => d.meta?.dispatchKey !== dispatchKey);
+          dispatch.completed = dispatch.completed.filter(d => !d.meta?.parentKey || d.meta.parentKey !== dispatchKey);
+          return dispatch;
+        }, { defaultValue: { pending: [], active: [], completed: [] } });
+      } catch (e) { console.error('dispatch cleanup on reopen:', e.message); }
+      try {
+        const cooldownPath = path.join(MINIONS_DIR, 'engine', 'cooldowns.json');
+        const cooldowns = safeJsonObj(cooldownPath);
+        if (cooldowns[dispatchKey]) {
+          delete cooldowns[dispatchKey];
+          safeWrite(cooldownPath, cooldowns);
+        }
+      } catch (e) { console.error('cooldown cleanup on reopen:', e.message); }
+
+      invalidateStatusCache();
+      return jsonReply(res, result.code, result.body);
+    } catch (e) { return jsonReply(res, 400, { error: e.message }); }
+  }
+
   async function handleWorkItemsCreate(req, res) {
     try {
       const body = await readBody(req);
@@ -3895,6 +3990,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     { method: 'POST', path: '/api/work-items/delete', desc: 'Remove a work item, kill agent, clear dispatch', params: 'id, source?', handler: handleWorkItemsDelete },
     { method: 'POST', path: '/api/work-items/archive', desc: 'Move a completed/failed work item to archive', params: 'id, source?', handler: handleWorkItemsArchive },
     { method: 'GET', path: '/api/work-items/archive', desc: 'List archived work items', handler: handleWorkItemsArchiveList },
+    { method: 'POST', path: '/api/work-items/reopen', desc: 'Reopen a done/failed work item back to pending', params: 'id, project?, description?', handler: handleWorkItemsReopen },
     { method: 'POST', path: '/api/work-items/feedback', desc: 'Add human feedback on completed work', params: 'id, rating, comment?', handler: async (req, res) => {
       const body = await readBody(req);
       const { id, source, rating, comment } = body;

package/engine/dispatch.js

@@ -172,9 +172,26 @@ function completeDispatch(id, result = DISPATCH_RESULT.SUCCESS, reason = '', res
           }
         } catch (e) { log('warn', 'increment retry counter: ' + e.message); }
       } else {
+        // Human-readable labels for each failure class — used as fallback when reason is empty
+        const CLASS_LABELS = {
+          [FAILURE_CLASS.EMPTY_OUTPUT]: 'agent produced no output \u2014 likely crashed on startup',
+          [FAILURE_CLASS.BUILD_FAILURE]: 'build/test/lint failure in output',
+          [FAILURE_CLASS.MERGE_CONFLICT]: 'merge conflict',
+          [FAILURE_CLASS.MAX_TURNS]: 'reached max turn limit',
+          [FAILURE_CLASS.TIMEOUT]: 'timed out waiting for agent',
+          [FAILURE_CLASS.SPAWN_ERROR]: 'agent process failed to start',
+          [FAILURE_CLASS.NETWORK_ERROR]: 'network or API error',
+          [FAILURE_CLASS.OUT_OF_CONTEXT]: 'context window exhausted',
+          [FAILURE_CLASS.CONFIG_ERROR]: 'configuration error',
+          [FAILURE_CLASS.PERMISSION_BLOCKED]: 'permission or auth failure',
+          [FAILURE_CLASS.UNKNOWN]: 'unknown error',
+        };
+        const classLabel = failureClass ? (CLASS_LABELS[failureClass] || failureClass) : '';
+        const effectiveReason = reason || classLabel || 'Unknown error';
+        const classSuffix = failureClass ? ` [${failureClass.toUpperCase().replace(/-/g, '_')}]` : '';
         const finalReason = !retryableFailure
-          ? `Non-retryable failure: ${reason || 'Unknown error'}`
-          : (reason || `Failed after ${maxRetries} retries`);
+          ? `Non-retryable failure: ${effectiveReason}${classSuffix}`
+          : (reason || `Failed after ${maxRetries} retries${classSuffix}`);
         lifecycle().updateWorkItemStatus(item.meta, WI_STATUS.FAILED, finalReason);
         // Alert: find items blocked by this failure and write inbox note
         try {

package/engine.js

@@ -1141,7 +1141,12 @@ async function spawnAgent(dispatchItem, config) {
     // autoRecovered: agent failed (e.g. heartbeat timeout) but created PRs — treat as success
     const effectiveResult = (code === 0 || autoRecovered) ? DISPATCH_RESULT.SUCCESS : DISPATCH_RESULT.ERROR;
     const completeOpts = effectiveResult === DISPATCH_RESULT.ERROR && failureClass ? { failureClass } : {};
-    completeDispatch(id, effectiveResult, '', resultSummary, completeOpts);
+    // Extract last 5 non-empty stderr lines as error context when exit code is non-zero
+    let errorReason = '';
+    if (effectiveResult === DISPATCH_RESULT.ERROR) {
+      errorReason = stderr.split('\n').filter(l => l.trim()).slice(-5).join(' | ').trim().slice(0, 300);
+    }
+    completeDispatch(id, effectiveResult, errorReason, resultSummary, completeOpts);
 
     // Cleanup temp files (including PID file now that dispatch is complete)
     try { fs.unlinkSync(sysPromptPath); } catch { /* cleanup */ }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.921",
+  "version": "0.1.923",
   "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/prompts/cc-system.md

@@ -76,7 +76,7 @@ Additional actions (all take `id` or `file` as primary key):
 - Schedules: schedule (id, title, cron, workType, project, agent, description, priority, enabled), delete-schedule (id)
 - Pipelines: create-pipeline (id, title, stages[], trigger, stopWhen, monitoredResources), edit-pipeline (id, title, stages, trigger), delete-pipeline (id), trigger-pipeline (id), abort-pipeline (id), retrigger-pipeline (id)
 - Meetings: add-meeting-note (id, note), advance-meeting (id), end-meeting (id), archive-meeting (id), unarchive-meeting (id), delete-meeting (id)
-- Work item ops: delete-work-item (id, source), archive-work-item (id), work-item-feedback (id, rating: up/down, comment)
+- Work item ops: delete-work-item (id, source), archive-work-item (id), work-item-feedback (id, rating: up/down, comment), reopen-work-item (id, project[, description] — reopen a done/failed item back to pending)
 - PRD ops: edit-prd-item, remove-prd-item, reopen-prd-item (id, file — re-dispatches on existing branch)
 - KB/Inbox: promote-to-kb (file, category), kb-sweep, toggle-kb-pin (key)
 - Plan lifecycle: revise-plan (file, feedback — dispatches agent to revise)