@yemi33/minions 0.1.57 → 0.1.59

package/engine/cli.js

@@ -56,7 +56,7 @@ const commands = {
         printPreflight(results, { label: 'Preflight checks' });
         console.log('  Some checks failed — agents may not work. Run `minions doctor` for details.\n');
       }
-    } catch {}
+    } catch (e) { console.error('preflight:', e.message); }
 
     const e = engine();
     const control = getControl();
@@ -74,7 +74,7 @@ const commands = {
             process.kill(control.pid, 0);
             alive = true;
           }
-        } catch {}
+        } catch { /* process may be dead */ }
       }
       if (alive) {
         console.log(`Engine is already running (PID ${control.pid}).`);
@@ -119,7 +119,7 @@ const commands = {
         try {
           const pidStr = fs.readFileSync(pidFile, 'utf8').trim();
           if (pidStr) agentPid = parseInt(pidStr);
-        } catch {}
+        } catch { /* optional */ }
 
         if (!agentPid) {
           const status = getAgentStatus(agentId);
@@ -131,7 +131,7 @@ const commands = {
               if (ageMs < 300000) {
                 agentPid = -1;
               }
-            } catch {}
+            } catch { /* optional */ }
           }
         }
 
@@ -213,7 +213,7 @@ const commands = {
           let prsCreated = 0;
           try {
             prsCreated = lifecycle.syncPrsFromOutput(output, agentId, item.meta, config);
-          } catch {}
+          } catch (err) { e.log('warn', `Orphan PR sync: ${err.message}`); }
 
           // Update work item status
           if (item.meta?.item?.id) {
@@ -235,7 +235,7 @@ const commands = {
                     safeWrite(wiPath, items);
                   }
                 }
-              } catch {}
+              } catch (err) { e.log('warn', `Orphan WI fallback: ${err.message}`); }
             }
           }
 
@@ -248,16 +248,16 @@ const commands = {
               '',
               { processWorkItemFailure: false }
             );
-          } catch {}
+          } catch (err) { e.log('warn', `Orphan dispatch complete: ${err.message}`); }
 
           // Check plan completion
           if (isSuccess && item.meta?.item?.sourcePlan) {
-            try { lifecycle.checkPlanCompletion(item.meta, config); } catch {}
+            try { lifecycle.checkPlanCompletion(item.meta, config); } catch (err) { e.log('warn', `Orphan plan completion: ${err.message}`); }
           }
 
           recovered++;
           console.log(`    ✓ Recovered ${agentId}: ${(item.task || '').slice(0, 60)} → ${result}${prsCreated ? ' (' + prsCreated + ' PR)' : ''}`);
-        } catch {}
+        } catch (err) { e.log('warn', `Orphan recovery: ${err.message}`); }
       }
       if (recovered > 0) {
         e.log('info', `Orphan recovery: processed ${recovered} completion(s) from previous session`);
@@ -291,7 +291,7 @@ const commands = {
             }
           }
           if (changed) safeWrite(wiPath, items);
-        } catch {}
+        } catch (err) { e.log('warn', `Recovery WI reset: ${err.message}`); }
       }
 
       // Plan chain recovery removed — plans require explicit user execution via dashboard
@@ -338,7 +338,7 @@ const commands = {
         for (const f of fs.readdirSync(prdDir).filter(f => f.endsWith('.json'))) {
           filesToWatch.push(path.join(prdDir, f));
         }
-      } catch {}
+      } catch { /* optional */ }
 
       for (const filePath of filesToWatch) {
         if (_watchedFiles.has(filePath)) continue;
@@ -354,7 +354,7 @@ const commands = {
               e.tick();
             }, 1000);
           });
-        } catch {}
+        } catch { /* optional */ }
       }
     }
     watchForWorkChanges();
@@ -366,7 +366,7 @@ const commands = {
       shuttingDown = true;
       console.log(`\n${signal} received — initiating graceful shutdown...`);
       clearInterval(tickTimer);
-      for (const f of _watchedFiles) { try { fs.unwatchFile(f); } catch {} }
+      for (const f of _watchedFiles) { try { fs.unwatchFile(f); } catch { /* cleanup */ } }
       safeWrite(CONTROL_PATH, { state: 'stopping', pid: process.pid, stopping_at: e.ts() });
       e.log('info', `Graceful shutdown initiated (${signal})`);
 
@@ -418,7 +418,7 @@ const commands = {
     }
     const control = getControl();
     if (control.pid && control.pid !== process.pid) {
-      try { process.kill(control.pid); } catch {}
+      try { process.kill(control.pid); } catch { /* process may be dead */ }
     }
     safeWrite(CONTROL_PATH, { state: 'stopped', stopped_at: e.ts() });
     e.log('info', 'Engine stopped');
@@ -459,7 +459,7 @@ const commands = {
     try {
       const vFile = path.join(MINIONS_DIR, '.minions-version');
       version = fs.readFileSync(vFile, 'utf8').trim();
-    } catch {}
+    } catch { /* optional */ }
 
     console.log('\n=== Minions Engine ===\n');
     console.log(`Version: ${version}`);
@@ -476,7 +476,7 @@ const commands = {
           process.kill(control.pid, 0);
           engineAlive = true;
         }
-      } catch {}
+      } catch { /* process may be dead */ }
     }
     if (control.state === 'running' && !engineAlive) {
       console.log(`Engine: stale (PID ${control.pid} is dead) — run: minions start`);

package/engine/consolidation.js

@@ -167,10 +167,10 @@ function consolidateWithLLM(items, existingNotes, files, config) {
 
   const timeout = setTimeout(() => {
     e.log('warn', 'LLM consolidation timed out after 3m — killing and falling back to regex');
-    try { proc.kill('SIGTERM'); } catch {}
+    try { proc.kill('SIGTERM'); } catch { /* process may be dead */ }
     // Escalate to SIGKILL after 10s if process doesn't exit
     setTimeout(() => {
-      try { proc.kill('SIGKILL'); } catch {}
+      try { proc.kill('SIGKILL'); } catch { /* process may be dead */ }
       if (_consolidationInFlight) {
         _consolidationInFlight = false;
         _processingFiles.clear();
@@ -399,14 +399,14 @@ function classifyToKnowledgeBase(items) {
       if (fs.existsSync(dir)) count += fs.readdirSync(dir).length;
     }
     safeWrite(path.join(ENGINE_DIR, 'kb-checkpoint.json'), JSON.stringify({ count, updatedAt: new Date().toISOString() }));
-  } catch {}
+  } catch (err) { engine().log('warn', `KB checkpoint: ${err.message}`); }
 }
 
 function archiveInboxFiles(files) {
   const e = engine();
   if (!fs.existsSync(ARCHIVE_DIR)) fs.mkdirSync(ARCHIVE_DIR, { recursive: true });
   for (const f of files) {
-    try { fs.renameSync(path.join(INBOX_DIR, f), shared.uniquePath(path.join(ARCHIVE_DIR, `${e.dateStamp()}-${f}`))); } catch {}
+    try { fs.renameSync(path.join(INBOX_DIR, f), shared.uniquePath(path.join(ARCHIVE_DIR, `${e.dateStamp()}-${f}`))); } catch (err) { e.log('warn', `Inbox archive: ${err.message}`); }
   }
 }
 

package/engine/github.js

@@ -66,7 +66,7 @@ async function forEachActiveGhPr(config, callback) {
         const updated = await callback(project, pr, prNum, slug);
         if (updated) projectUpdated++;
       } catch (err) {
-        try { engine().log('warn', `GitHub: failed to poll PR ${pr.id}: ${err.message}`); } catch {}
+        try { engine().log('warn', `GitHub: failed to poll PR ${pr.id}: ${err.message}`); } catch { /* engine not available */ }
       }
     }
 
@@ -101,7 +101,7 @@ async function forEachActiveGhPr(config, callback) {
         centralUpdated++;
       }
     } catch (err) {
-      try { engine().log('warn', `GitHub: failed to poll central PR ${pr.id}: ${err.message}`); } catch {}
+      try { engine().log('warn', `GitHub: failed to poll central PR ${pr.id}: ${err.message}`); } catch { /* engine not available */ }
     }
   }
   if (centralUpdated > 0) {
@@ -171,7 +171,7 @@ async function pollPrStatus(config) {
               if (newReviewStatus === 'approved') metrics[authorId].prsApproved = (metrics[authorId].prsApproved || 0) + 1;
               else metrics[authorId].prsRejected = (metrics[authorId].prsRejected || 0) + 1;
               shared.safeWrite(metricsPath, metrics);
-            } catch {}
+            } catch (err) { try { engine().log('warn', `Metrics update: ${err.message}`); } catch { /* engine not available */ } }
           }
         }
       }

package/engine/lifecycle.js

@@ -37,7 +37,7 @@ function checkPlanCompletion(meta, config) {
     try {
       const wi = safeJson(shared.projectWorkItemsPath(p)) || [];
       allWorkItems = allWorkItems.concat(wi);
-    } catch {}
+    } catch { /* optional */ }
   }
   const planItems = allWorkItems.filter(w => w.sourcePlan === planFile && w.itemType !== 'pr' && w.itemType !== 'verify');
   if (planItems.length === 0) return;
@@ -107,7 +107,7 @@ function checkPlanCompletion(meta, config) {
           prsCreated.push(pr);
         }
       }
-    } catch {}
+    } catch { /* optional */ }
   }
   const uniquePrs = [...new Map(prsCreated.map(pr => [pr.id || pr.url, pr])).values()];
 
@@ -281,11 +281,11 @@ function checkPlanCompletion(meta, config) {
         try {
           fs.renameSync(path.join(PLANS_DIR, md), path.join(planArchiveDir, md));
           e.log('info', `Archived source plan: plans/archive/${md}`);
-        } catch {}
+        } catch (err) { e.log('warn', `Failed to archive plan ${md}: ${err.message}`); }
         break;
       }
     }
-  } catch {}
+  } catch (err) { e.log('warn', `Plan archive scan: ${err.message}`); }
 
   // 6. Clean up ALL worktrees created for this plan's work items (shared-branch + per-item)
   try {
@@ -319,7 +319,7 @@ function checkPlanCompletion(meta, config) {
       }
     }
     if (cleanedWt > 0) e.log('info', `Plan completion: cleaned ${cleanedWt} worktree(s)`);
-  } catch {}
+  } catch (err) { e.log('warn', `Worktree cleanup: ${err.message}`); }
 
   e.log('info', `PRD ${planFile} completed: ${doneItems.length} done, ${failedItems.length} failed, runtime ${runtimeMin}m`);
 }
@@ -366,7 +366,7 @@ function chainPlanToPrd(dispatchItem, meta, config) {
         if (fs.existsSync(jsonPath)) fs.renameSync(jsonPath, path.join(planDir, mdName));
         planFileName = mdName;
         e.log('info', `Plan chaining: renamed to .md (not valid JSON)`);
-      } catch {}
+      } catch (err) { e.log('warn', `Plan rename fallback: ${err.message}`); }
     }
   }
 
@@ -489,7 +489,7 @@ function syncPrdItemStatus(itemId, status, sourcePlan) {
         return;
       }
     }
-  } catch {}
+  } catch (err) { engine().log('warn', `PRD status sync: ${err.message}`); }
 }
 
 // ─── PR Sync from Output ─────────────────────────────────────────────────────
@@ -689,7 +689,7 @@ async function handlePostMerge(pr, project, config, newStatus) {
           } catch (err) { e.log('warn', `Failed to remove worktree ${dir}: ${err.message}`); }
         }
       }
-    } catch {}
+    } catch (err) { e.log('warn', `Post-merge worktree cleanup: ${err.message}`); }
   }
 
   if (newStatus !== 'merged') return;
@@ -711,7 +711,7 @@ async function handlePostMerge(pr, project, config, newStatus) {
         }
       }
       if (updated > 0) e.log('info', `Post-merge: marked ${mergedItemId} as implemented for ${pr.id}`);
-    } catch {}
+    } catch (err) { e.log('warn', `Post-merge PRD update: ${err.message}`); }
   }
 
   const agentId = (pr.agent || '').toLowerCase();
@@ -1014,7 +1014,7 @@ function runPostCompletionHooks(dispatchItem, agentId, code, stdout, config) {
         sessionId, dispatchId: dispatchItem.id, savedAt: new Date().toISOString(),
         branch: dispatchItem.meta?.branch || null,
       });
-    } catch {}
+    } catch (err) { engine().log('warn', `Session save: ${err.message}`); }
   }
 
   // Handle decomposition results — create sub-items from decompose agent output
@@ -1038,7 +1038,7 @@ function runPostCompletionHooks(dispatchItem, agentId, code, stdout, config) {
         const wi = items.find(i => i.id === meta.item.id);
         if (wi) retries = (wi._retryCount || 0); // Use fresh value from file
       }
-    } catch {}
+    } catch { /* optional */ }
 
     if (retries < 3) {
       e.log('info', `Agent failed for ${meta.item.id} — auto-retry ${retries + 1}/3`);
@@ -1056,7 +1056,7 @@ function runPostCompletionHooks(dispatchItem, agentId, code, stdout, config) {
             shared.safeWrite(wiPath, items);
           }
         }
-      } catch {}
+      } catch (err) { e.log('warn', `Retry update: ${err.message}`); }
     } else {
       updateWorkItemStatus(meta, 'failed', 'Agent failed (3 retries exhausted)');
     }
@@ -1071,7 +1071,7 @@ function runPostCompletionHooks(dispatchItem, agentId, code, stdout, config) {
           const wi = items.find(i => i.id === meta.item.id);
           if (wi) { delete wi._decomposing; shared.safeWrite(wiPath, items); }
         }
-      } catch {}
+      } catch (err) { e.log('warn', `Decompose cleanup: ${err.message}`); }
     }
   }
   // Plan chaining removed — user must explicitly execute plan-to-prd after reviewing the plan
@@ -1188,7 +1188,7 @@ function syncPrdFromPrs(config) {
     }
   } catch (err) {
     // Non-fatal — log and continue
-    try { engine().log('warn', `syncPrdFromPrs error: ${err?.message || err}`); } catch {}
+    try { engine().log('warn', `syncPrdFromPrs error: ${err?.message || err}`); } catch { /* engine not available */ }
   }
 }
 

package/engine/llm.js

@@ -39,7 +39,7 @@ function trackEngineUsage(category, usage) {
     daily.cacheRead += usage.cacheRead || 0;
 
     safeWrite(metricsPath, metrics);
-  } catch {}
+  } catch (e) { console.error('metrics update:', e.message); }
 }
 
 // ── Core LLM Call ───────────────────────────────────────────────────────────
@@ -72,7 +72,7 @@ function callLLM(promptText, sysPromptText, { timeout = 120000, label = 'llm', m
     proc.stdout.on('data', d => { stdout += d.toString(); });
     proc.stderr.on('data', d => { stderr += d.toString(); });
 
-    const timer = setTimeout(() => { try { proc.kill('SIGTERM'); } catch {} }, timeout);
+    const timer = setTimeout(() => { try { proc.kill('SIGTERM'); } catch { /* process may be dead */ } }, timeout);
 
     proc.on('close', (code) => {
       clearTimeout(timer);

package/engine/preflight.js

@@ -32,7 +32,7 @@ function findClaudeBinary() {
       const resolved = path.join(basedir, 'node_modules', '@anthropic-ai', 'claude-code', 'cli.js');
       if (fs.existsSync(resolved)) return resolved;
     }
-  } catch {}
+  } catch { /* optional */ }
   return null;
 }
 
@@ -180,7 +180,7 @@ function doctor(minionsHome) {
           process.kill(control.pid, 0);
           alive = true;
         }
-      } catch {}
+      } catch { /* process may be dead */ }
       runtimeResults.push({ name: 'Engine', ok: alive, message: alive ? `running (PID ${control.pid})` : `stale PID ${control.pid} — run: minions start` });
     } else {
       runtimeResults.push({ name: 'Engine', ok: 'warn', message: `${control.state || 'stopped'} — run: minions start` });

package/engine/queries.js

@@ -168,7 +168,7 @@ function getAgentStatus(agentId) {
         started_at: latestInFlight.dispatched_at || latestInFlight.created || null,
       };
     }
-  } catch {}
+  } catch { /* optional */ }
 
   return { status: 'idle', task: null, started_at: null, completed_at: null };
 }
@@ -199,7 +199,7 @@ function getAgents(config) {
     else if (s.status === 'error') lastAction = `Error: ${s.task}`;
     else if (inboxFiles.length > 0) {
       const lastOutput = path.join(INBOX_DIR, inboxFiles[inboxFiles.length - 1]);
-      try { lastAction = `Output: ${path.basename(lastOutput)} (${timeSince(fs.statSync(lastOutput).mtimeMs)})`; } catch {}
+      try { lastAction = `Output: ${path.basename(lastOutput)} (${timeSince(fs.statSync(lastOutput).mtimeMs)})`; } catch { /* optional */ }
     }
 
     const chartered = fs.existsSync(path.join(AGENTS_DIR, a.id, 'charter.md'));
@@ -237,7 +237,7 @@ function getAgentDetail(id) {
         result: d.result || '', reason: d.reason || '',
         completed_at: d.completed_at || '',
       }));
-  } catch {}
+  } catch { /* optional */ }
 
   return { charter, history, statusData, outputLog, inboxContents, recentDispatches };
 }
@@ -302,7 +302,7 @@ function collectSkillFiles(config) {
         seen.add(d);
       }
     }
-  } catch {}
+  } catch { /* optional */ }
 
   // 1b. Installed plugin skills: ~/.claude/plugins/installed_plugins.json → cache/<marketplace>/<plugin>/<version>/commands/*.md
   try {
@@ -321,9 +321,9 @@ function collectSkillFiles(config) {
           skillFiles.push({ file: cmd, dir: commandsDir, scope: 'plugin', skillName: name });
           seen.add(name);
         }
-      } catch {}
+      } catch { /* optional */ }
     }
-  } catch {}
+  } catch { /* optional */ }
 
   // 2. Project-specific skills: <project>/.claude/skills/<name>.md or <name>/SKILL.md
   for (const project of getProjects(config)) {
@@ -343,7 +343,7 @@ function collectSkillFiles(config) {
           skillFiles.push({ file: entry, dir: projectSkillsDir, scope: 'project', projectName: project.name });
         }
       }
-    } catch {}
+    } catch { /* optional */ }
   }
   return skillFiles;
 }
@@ -363,7 +363,7 @@ function getSkills(config) {
         scope,
         autoGenerated: isAutoGenerated,
       });
-    } catch {}
+    } catch { /* optional */ }
   }
   return all;
 }
@@ -541,7 +541,7 @@ function getPrdInfo(config) {
               const sourceMtime = Math.floor(fs.statSync(path.join(PLANS_DIR, plan.source_plan)).mtimeMs);
               const recorded = plan.sourcePlanModifiedAt ? new Date(plan.sourcePlanModifiedAt).getTime() : null;
               if (recorded && sourceMtime > recorded) planStale = true;
-            } catch {}
+            } catch { /* optional */ }
           }
           for (const f of plan.missing_features) {
             allPrdItems.push({
@@ -552,9 +552,9 @@ function getPrdInfo(config) {
               _prdUpdatedAt: new Date(stat.mtimeMs).toISOString(),
             });
           }
-        } catch {}
+        } catch { /* optional */ }
       }
-    } catch {}
+    } catch { /* optional */ }
   }
 
   if (allPrdItems.length === 0) return { progress: null, status: null };
@@ -568,7 +568,7 @@ function getPrdInfo(config) {
     try {
       const workItems = safeJson(projectWorkItemsPath(project)) || [];
       for (const wi of workItems) { if (wi.sourcePlan) wiById[wi.id] = wi; }
-    } catch {}
+    } catch { /* optional */ }
   }
 
   // PR-to-PRD linking — primary source is pr-links.json (single-writer, never clobbered by polling)
@@ -629,7 +629,7 @@ function getPrdInfo(config) {
         if (wi.completedAt) { const c = new Date(wi.completedAt).getTime(); if (!t.lastCompleted || c > t.lastCompleted) t.lastCompleted = c; }
         if (wi.status !== 'done' && wi.status !== 'in-pr') t.allDone = false; // in-pr treated as done for backward compat
       }
-    } catch {}
+    } catch { /* optional */ }
   }
 
   const progress = {

package/engine/shared.js

@@ -38,24 +38,24 @@ function safeWrite(p, data) {
       } catch (e) {
         if (e.code === 'EPERM' && attempt < 4) {
           const delay = 50 * (attempt + 1); // 50, 100, 150, 200ms
-          try { const ab = new SharedArrayBuffer(4); Atomics.wait(new Int32Array(ab), 0, 0, delay); } catch { const start = Date.now(); while (Date.now() - start < delay) {} }
+          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
       }
     }
     // All rename attempts failed — direct write as fallback (not atomic but won't lose data)
-    try { fs.unlinkSync(tmp); } catch {}
+    try { fs.unlinkSync(tmp); } catch { /* cleanup */ }
     fs.writeFileSync(p, content);
   } catch (err) {
     // Even direct write failed — log and clean up tmp
     console.error(`[safeWrite] FAILED to write ${p}: ${err.message}`);
-    try { fs.unlinkSync(tmp); } catch {}
+    try { fs.unlinkSync(tmp); } catch { /* cleanup */ }
   }
 }
 
 function safeUnlink(p) {
-  try { fs.unlinkSync(p); } catch {}
+  try { fs.unlinkSync(p); } catch { /* cleanup */ }
 }
 
 function sleepMs(ms) {
@@ -90,8 +90,8 @@ function withFileLock(lockPath, fn, {
   try {
     return fn();
   } finally {
-    try { fs.closeSync(fd); } catch {}
-    try { fs.unlinkSync(lockPath); } catch {}
+    try { fs.closeSync(fd); } catch { /* cleanup */ }
+    try { fs.unlinkSync(lockPath); } catch { /* cleanup */ }
   }
 }
 

package/engine/spawn-agent.js

@@ -45,7 +45,7 @@ if (!claudeBin) {
       const basedir = path.dirname(which.replace(/^\/c\//, 'C:/').replace(/\//g, path.sep));
       claudeBin = path.join(basedir, 'node_modules', '@anthropic-ai', 'claude-code', 'cli.js');
     }
-  } catch {}
+  } catch { /* optional */ }
 }
 
 // Debug log
@@ -86,7 +86,7 @@ if (_sysPromptFileSupported === null) {
     const { spawnSync } = require('child_process');
     const testResult = spawnSync(process.execPath, [claudeBin, '--help'], { encoding: 'utf8', timeout: 10000, windowsHide: true });
     _sysPromptFileSupported = (testResult.stdout || '').includes('system-prompt-file');
-    try { fs.writeFileSync(capsCachePath, JSON.stringify({ claudeBin, sysPromptFile: _sysPromptFileSupported, checkedAt: new Date().toISOString() })); } catch {}
+    try { fs.writeFileSync(capsCachePath, JSON.stringify({ claudeBin, sysPromptFile: _sysPromptFileSupported, checkedAt: new Date().toISOString() })); } catch { /* optional */ }
   } catch { _sysPromptFileSupported = true; /* assume supported */ }
 }
 if (!isResume) try {
@@ -131,7 +131,7 @@ if (!isResume && Buffer.byteLength(sysPrompt) >= 30000) {
 proc.stdin.end();
 
 // Clean up temp file (only created for non-resume sessions)
-if (!isResume) setTimeout(() => { try { fs.unlinkSync(sysTmpPath); } catch {} }, 5000);
+if (!isResume) setTimeout(() => { try { fs.unlinkSync(sysTmpPath); } catch { /* cleanup */ } }, 5000);
 
 // Capture stderr separately for debugging
 let stderrBuf = '';