@yemi33/minions 0.1.850 → 0.1.852

package/CHANGELOG.md

@@ -1,8 +1,10 @@
 # Changelog
 
-## 0.1.850 (2026-04-11)
+## 0.1.852 (2026-04-11)
 
 ### Features
+-  execute CC actions server-side (dispatch, note, knowledge)
+- per-type heartbeat timeouts for read-heavy work types (#652)
 - Replace raw status strings with WI_STATUS constants in dashboard.js (#657)
 - fix dispatch.json race condition in CLI kill-all (#653)
 -  optimistic UI updates for all remaining dashboard pages

package/dashboard/js/command-center.js

@@ -579,6 +579,7 @@ async function _ccDoSend(message, skipUserMsg) {
               ccSaveState(); ccUpdateSessionIndicator();
             }
             if (evt.actions && evt.actions.length > 0) {
+              _tagServerExecuted(evt.actions, evt.actionResults);
               for (var ai = 0; ai < evt.actions.length; ai++) { await ccExecuteAction(evt.actions[ai], activeTabId); }
             }
           } else if (evt.type === 'error') {
@@ -609,6 +610,7 @@ async function _ccDoSend(message, skipUserMsg) {
               ccSaveState(); ccUpdateSessionIndicator();
             }
             if (revt.actions && revt.actions.length > 0) {
+              _tagServerExecuted(revt.actions, revt.actionResults);
               for (var ai2 = 0; ai2 < revt.actions.length; ai2++) { await ccExecuteAction(revt.actions[ai2], activeTabId); }
             }
           } else if (revt.type === 'chunk') {
@@ -688,10 +690,43 @@ async function _ccFetch(url, body) {
   return res;
 }
 
+// Tag actions that the server already executed so ccExecuteAction skips the API call
+function _tagServerExecuted(actions, actionResults) {
+  if (!actionResults || !Array.isArray(actionResults)) return;
+  for (var i = 0; i < actions.length && i < actionResults.length; i++) {
+    var r = actionResults[i];
+    if (r && r.ok) {
+      actions[i]._serverExecuted = true;
+      if (r.id) actions[i]._serverId = r.id;
+    } else if (r && r.error) {
+      actions[i]._serverExecuted = true;
+      actions[i]._serverError = r.error;
+    }
+    // clientExecuted: false means server didn't handle it — frontend must execute
+  }
+}
+
+
 async function ccExecuteAction(action, targetTabId) {
   var status = document.createElement('div');
   status.style.cssText = 'padding:4px 10px;border-radius:4px;font-size:10px;align-self:flex-start;border:1px dashed var(--border);color:var(--muted)';
 
+  // Server-executed actions: just show status, don't re-fire the API
+  if (action._serverExecuted) {
+    if (action._serverError) {
+      status.innerHTML = '&#10007; ' + escHtml(action.type) + ' failed: ' + escHtml(action._serverError);
+      status.style.color = 'var(--red)';
+    } else {
+      var label = action._serverId ? escHtml(action._serverId) : escHtml(action.title || action.type);
+      status.innerHTML = '&#10003; ' + escHtml(action.type) + ': <strong>' + label + '</strong>';
+      status.style.color = 'var(--green)';
+    }
+    ccAddMessage('assistant', status.outerHTML, false, targetTabId);
+    if (['dispatch','fix','implement','explore','review','test'].includes(action.type)) wakeEngine();
+    refresh();
+    return;
+  }
+
   try {
     switch (action.type) {
       case 'dispatch':

package/dashboard.js

@@ -572,6 +572,61 @@ function parseCCActions(text) {
   return { text: displayText, actions };
 }
 
+// ── Server-side CC action execution ──────────────────────────────────────────
+// Actions are executed server-side so all clients (frontend, curl, Teams) get the same behavior.
+// The frontend still shows status toasts but no longer needs to fire the API calls.
+
+async function executeCCActions(actions) {
+  const results = [];
+  for (const action of actions) {
+    try {
+      switch (action.type) {
+        case 'dispatch': case 'fix': case 'implement': case 'explore': case 'review': case 'test': {
+          const workType = action.workType || (action.type !== 'dispatch' ? action.type : 'implement');
+          const id = 'W-' + shared.uid();
+          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');
+          shared.mutateJsonFileLocked(wiPath, items => {
+            if (!Array.isArray(items)) items = [];
+            items.push({
+              id, title: action.title || 'Untitled', type: workType,
+              priority: action.priority || 'medium', description: action.description || '',
+              status: 'pending', created: new Date().toISOString(),
+              createdBy: 'command-center', project,
+              ...(action.agents?.length ? { preferred_agent: action.agents[0] } : {}),
+            });
+            return items;
+          }, { defaultValue: [] });
+          results.push({ type: action.type, id, ok: true });
+          break;
+        }
+        case 'note': {
+          shared.writeToInbox('command-center', shared.slugify(action.title || 'note'), `# ${action.title || 'Note'}\n\n${action.content || action.description || ''}`);
+          results.push({ type: 'note', ok: true });
+          break;
+        }
+        case 'knowledge': {
+          const category = action.category || 'project-notes';
+          const slug = shared.slugify(action.title || 'entry');
+          const kbDir = path.join(MINIONS_DIR, 'knowledge', category);
+          if (!fs.existsSync(kbDir)) fs.mkdirSync(kbDir, { recursive: true });
+          shared.safeWrite(path.join(kbDir, slug + '.md'), `# ${action.title}\n\n${action.content || action.description || ''}`);
+          results.push({ type: 'knowledge', ok: true });
+          break;
+        }
+        default:
+          // For action types that map 1:1 to API endpoints, flag as client-executed
+          results.push({ type: action.type, ok: true, clientExecuted: false });
+          break;
+      }
+    } catch (e) {
+      results.push({ type: action.type, error: e.message });
+    }
+  }
+  return results;
+}
+
 // ── Shared LLM call core — used by CC panel and doc modals ──────────────────
 
 // Session store for doc modals — keyed by filePath or title, persisted to disk
@@ -3424,7 +3479,11 @@ What would you like to discuss or change? When you're happy, say "approve" and I
           teams.teamsPostCCResponse(body.message, result.text).catch(() => {});
         }
 
-        const reply = { ...parseCCActions(result.text), sessionId: ccSession.sessionId, newSession: !wasResume };
+        const parsed = parseCCActions(result.text);
+        if (parsed.actions.length > 0) {
+          parsed.actionResults = await executeCCActions(parsed.actions);
+        }
+        const reply = { ...parsed, sessionId: ccSession.sessionId, newSession: !wasResume };
         if (sessionReset) reply.sessionReset = true;
         return jsonReply(res, 200, reply);
       } finally {
@@ -3534,9 +3593,13 @@ What would you like to discuss or change? When you're happy, say "approve" and I
           } catch { /* non-critical */ }
         }
 
-        // Send final result with actions
+        // Send final result with actions — execute server-side first
         const { text: displayText, actions } = parseCCActions(result.text);
-        const donePayload = { type: 'done', text: displayText, actions, sessionId: responseSessionId, newSession: !wasResume };
+        let actionResults;
+        if (actions.length > 0) {
+          actionResults = await executeCCActions(actions);
+        }
+        const donePayload = { type: 'done', text: displayText, actions, actionResults, sessionId: responseSessionId, newSession: !wasResume };
         if (sessionReset) donePayload.sessionReset = true;
         res.write('data: ' + JSON.stringify(donePayload) + '\n\n');
 

package/engine/shared.js

@@ -552,6 +552,7 @@ const ENGINE_DEFAULTS = {
   ignoredCommentAuthors: [], // comments from these authors are auto-closed and never trigger fixes
   ccModel: 'sonnet', // model for Command Center and doc-chat (sonnet, haiku, opus)
   ccEffort: null, // effort level for CC/doc-chat (null, 'low', 'medium', 'high')
+  heartbeatTimeouts: {}, // populated after WORK_TYPE is defined (below)
   ccMaxTurns: 50, // max tool-use turns for CC/doc-chat before CLI stops
   // Teams integration — config.teams shape: { enabled, appId, appPassword, notifyEvents, ccMirror, inboxPollInterval }
   teams: {
@@ -582,6 +583,15 @@ const WORK_TYPE = {
   VERIFY: 'verify', PLAN: 'plan', PLAN_TO_PRD: 'plan-to-prd', DECOMPOSE: 'decompose',
   MEETING: 'meeting', EXPLORE: 'explore', ASK: 'ask', TEST: 'test', DOCS: 'docs',
 };
+
+// Per-work-type heartbeat timeouts (ms) — read-heavy tasks need longer silence windows.
+// Keyed by WORK_TYPE constants; types not listed fall back to ENGINE_DEFAULTS.heartbeatTimeout.
+Object.assign(ENGINE_DEFAULTS.heartbeatTimeouts, {
+  [WORK_TYPE.EXPLORE]: 600000,   // 10 min — spends most time reading/analyzing, minimal stdout
+  [WORK_TYPE.ASK]:     600000,   // 10 min — research-heavy, long silent analysis periods
+  [WORK_TYPE.REVIEW]:  480000,   // 8 min — code review reads extensively before producing output
+});
+
 const PLAN_STATUS = {
   ACTIVE: 'active', AWAITING_APPROVAL: 'awaiting-approval', APPROVED: 'approved',
   PAUSED: 'paused', REJECTED: 'rejected', COMPLETED: 'completed',

package/engine/timeout.js

@@ -9,7 +9,7 @@ const shared = require('./shared');
 const queries = require('./queries');
 
 const { safeRead, safeWrite, safeJson, mutateJsonFileLocked, getProjects, projectWorkItemsPath, log, ts,
-  ENGINE_DEFAULTS: DEFAULTS, WI_STATUS, DISPATCH_RESULT, AGENT_STATUS } = shared;
+  ENGINE_DEFAULTS: DEFAULTS, WI_STATUS, WORK_TYPE, DISPATCH_RESULT, AGENT_STATUS } = shared;
 const { getDispatch, getAgentStatus } = queries;
 const AGENTS_DIR = queries.AGENTS_DIR;
 const MINIONS_DIR = shared.MINIONS_DIR;
@@ -130,7 +130,7 @@ function checkTimeouts(config) {
   const { runPostCompletionHooks } = require('./lifecycle');
 
   const timeout = config.engine?.agentTimeout || DEFAULTS.agentTimeout;
-  const heartbeatTimeout = config.engine?.heartbeatTimeout || DEFAULTS.heartbeatTimeout;
+  const defaultHeartbeatTimeout = config.engine?.heartbeatTimeout || DEFAULTS.heartbeatTimeout;
 
   // Per-type heartbeat timeouts: merge ENGINE_DEFAULTS ← config overrides
   const perTypeTimeouts = { ...DEFAULTS.heartbeatTimeouts, ...(config.engine?.heartbeatTimeouts || {}) };
@@ -155,6 +155,10 @@ function checkTimeouts(config) {
   for (const item of (dispatchData.active || [])) {
     if (!item.agent) continue;
 
+    // Per-type heartbeat: look up work type from dispatch item, fall back to default
+    const workType = item.workType || item.meta?.item?.type;
+    const heartbeatTimeout = (workType && perTypeTimeouts[workType]) || defaultHeartbeatTimeout;
+
     const hasProcess = activeProcesses.has(item.id);
     const liveLogPath = path.join(AGENTS_DIR, item.agent, 'live-output.log');
     let lastActivity = item.started_at ? new Date(item.started_at).getTime() : 0;

package/package.json

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