@yemi33/minions 0.1.763 → 0.1.765

package/CHANGELOG.md

@@ -1,11 +1,17 @@
 # Changelog
 
-## 0.1.763 (2026-04-10)
+## 0.1.765 (2026-04-10)
+
+### Features
+- id/kill endpoint
+
+## 0.1.764 (2026-04-10)
 
 ### Features
 -  pulsing blue dot on CC tabs with active requests
 
 ### Fixes
+-  prevent stale dispatched work items from showing agent as working indefinitely
 -  only trigger verify when all PRD items succeed, not on partial failure
 -  clean handoff between restore and original stream intervals
 -  prevent competing thinking intervals on tab switch

package/dashboard.js

@@ -1459,6 +1459,70 @@ const server = http.createServer(async (req, res) => {
     } catch (e) { return jsonReply(res, 400, { error: e.message }); }
   }
 
+  async function handleAgentKill(req, res, match) {
+    try {
+      const agentId = match[1].replace(/[^a-zA-Z0-9_-]/g, '');
+      if (!agentId) return jsonReply(res, 400, { error: 'agent id required' });
+
+      const agentDir = path.join(MINIONS_DIR, 'agents', agentId);
+      if (!fs.existsSync(agentDir)) return jsonReply(res, 404, { error: 'Agent not found' });
+
+      // 1. Kill process via pid file
+      const pidPath = path.join(agentDir, 'pid');
+      try {
+        const pid = parseInt(shared.safeRead(pidPath) || '', 10);
+        if (pid) {
+          const safePid = shared.validatePid(pid);
+          if (process.platform === 'win32') {
+            require('child_process').execFileSync('taskkill', ['/PID', String(safePid), '/F', '/T'], { stdio: 'pipe', timeout: 5000, windowsHide: true });
+          } else {
+            process.kill(safePid, 'SIGTERM');
+          }
+        }
+      } catch { /* process already dead or no pid file */ }
+      try { fs.unlinkSync(pidPath); } catch { /* optional */ }
+
+      // 2. Clear session.json so retry starts fresh
+      try { fs.unlinkSync(path.join(agentDir, 'session.json')); } catch { /* optional */ }
+
+      // 3. Remove all active dispatch entries for this agent
+      const dispatchPath = path.join(MINIONS_DIR, 'engine', 'dispatch.json');
+      const removedIds = [];
+      mutateJsonFileLocked(dispatchPath, (dp) => {
+        const before = (dp.active || []).length;
+        const removed = (dp.active || []).filter(d => d.agent === agentId);
+        removed.forEach(d => removedIds.push(d.id));
+        dp.active = (dp.active || []).filter(d => d.agent !== agentId);
+        return dp;
+      }, { defaultValue: { pending: [], active: [], completed: [] } });
+
+      // 4. Reset work items from dispatched → pending so they can be retried
+      const allWiPaths = [];
+      for (const proj of PROJECTS) allWiPaths.push(shared.projectWorkItemsPath(proj));
+      let resetCount = 0;
+      for (const wiPath of allWiPaths) {
+        try {
+          mutateWorkItems(wiPath, items => {
+            for (const item of items) {
+              if (item.dispatched_to === agentId && item.status === WI_STATUS.DISPATCHED) {
+                item.status = WI_STATUS.PENDING;
+                item._retryCount = (item._retryCount || 0) + 1;
+                delete item.dispatched_at;
+                delete item.dispatched_to;
+                delete item._pendingReason;
+                resetCount++;
+              }
+            }
+            return items;
+          });
+        } catch { /* optional */ }
+      }
+
+      invalidateStatusCache();
+      return jsonReply(res, 200, { ok: true, agent: agentId, dispatchCleared: removedIds.length, workItemsReset: resetCount });
+    } catch (e) { return jsonReply(res, 400, { error: e.message }); }
+  }
+
   async function handleAgentsCancel(req, res) {
     try {
       const body = await readBody(req);
@@ -4027,6 +4091,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       return jsonReply(res, 200, { ok: true, message: 'Steering message sent' });
     }},
     { method: 'POST', path: '/api/agents/cancel', desc: 'Cancel an active agent by ID or task substring', params: 'agent?, task?', handler: handleAgentsCancel },
+    { method: 'POST', path: /^\/api\/agent\/([\w-]+)\/kill$/, desc: 'Kill a running agent: stop process, clear dispatch, reset work items to pending', handler: handleAgentKill },
     { method: 'GET', path: /^\/api\/agent\/([\w-]+)\/live-stream(?:\?.*)?$/, desc: 'SSE real-time live output streaming', handler: handleAgentLiveStream },
     { method: 'GET', path: /^\/api\/agent\/([\w-]+)\/live(?:\?.*)?$/, desc: 'Tail live output for a working agent', params: 'tail? (bytes, default 8192)', handler: handleAgentLive },
     { method: 'GET', path: /^\/api\/agent\/([\w-]+)\/output(?:\?.*)?$/, desc: 'Fetch final output.log for an agent', handler: handleAgentOutput },

package/engine/queries.js

@@ -11,7 +11,7 @@ const shared = require('./shared');
 
 const { safeRead, safeReadDir, safeJson, safeWrite, getProjects,
   projectWorkItemsPath, projectPrPath, parseSkillFrontmatter, KB_CATEGORIES,
-  WI_STATUS } = shared;
+  WI_STATUS, ENGINE_DEFAULTS } = shared;
 
 /**
  * Read the first `bytes` and last `bytes` of a file efficiently using byte offsets.
@@ -265,14 +265,21 @@ function getAgentStatus(agentId) {
 
   // Fallback: derive active state from work-item markers.
   // This protects UI status when dispatch.json briefly desyncs from work-item files.
+  // Guard: only trust dispatched state within 2x heartbeatTimeout to prevent stale
+  // dispatched items from permanently showing an agent as working after a dead process.
   try {
     const config = getConfig();
+    const heartbeatTimeout = config.engine?.heartbeatTimeout || ENGINE_DEFAULTS.heartbeatTimeout;
+    const staleThresholdMs = heartbeatTimeout * 2;
+    const now = Date.now();
     const allItems = getWorkItems(config);
     const latestInFlight = allItems
-      .filter(w =>
-        (w.dispatched_to || '').toLowerCase() === String(agentId).toLowerCase() &&
-        w.status === WI_STATUS.DISPATCHED
-      )
+      .filter(w => {
+        if ((w.dispatched_to || '').toLowerCase() !== String(agentId).toLowerCase()) return false;
+        if (w.status !== WI_STATUS.DISPATCHED) return false;
+        const ageMs = w.dispatched_at ? now - new Date(w.dispatched_at).getTime() : Infinity;
+        return ageMs < staleThresholdMs;
+      })
       .sort((a, b) => (b.dispatched_at || '').localeCompare(a.dispatched_at || ''))[0];
     if (latestInFlight) {
       return {

package/package.json

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