@yemi33/minions 0.1.851 → 0.1.852

package/CHANGELOG.md

@@ -1,8 +1,9 @@
 # Changelog
 
-## 0.1.851 (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)

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/package.json

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