@yemi33/minions 0.1.1627 → 0.1.1629

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.1.1629 (2026-04-29)
+
+### Other
+- test(cli): add unit tests for runtime-flag helpers
+
 ## 0.1.1627 (2026-04-29)
 
 ### Fixes

package/engine/cli.js

@@ -23,9 +23,9 @@ function dispatchModule() { if (!_dispatchModule) _dispatchModule = require('./d
 
 function handleCommand(cmd, args) {
   if (!cmd) {
-    commands.start();
+    return commands.start();
   } else if (commands[cmd]) {
-    commands[cmd](...args);
+    return commands[cmd](...args);
   } else {
     console.log(`Unknown command: ${cmd}`);
     console.log('Commands:');
@@ -50,7 +50,7 @@ function handleCommand(cmd, args) {
   }
 }
 
-// ─── Runtime fleet flags (--cli / --model) ───────────────────────────────────
+// ─── Runtime fleet flags (--cli / --model / --effort) ────────────────────────
 //
 // Shared by `start`, `restart`, and `config set-cli`. Single source of truth
 // for: flag parsing, runtime validation, incompatibility heuristics, and the
@@ -58,27 +58,52 @@ function handleCommand(cmd, args) {
 // config.json" — the helper below is the only caller that mutates fleet keys.
 
 /**
- * Strip `--cli <name>` / `--model <value>` from `args` (in-place). Returns
- * `{ cli, model, modelExplicit, errors }`. `modelExplicit` distinguishes
+ * Strip `--cli <name>` / `--model <value>` / `--effort <level>` from `args`
+ * (in-place), including `--flag=value` forms. Returns
+ * `{ cli, model, effort, modelExplicit, errors }`. `modelExplicit` distinguishes
  * "user passed --model with empty string" (clear) from "no flag" (no-op).
  *
  * Errors (e.g. `--cli` with no follow-up token) are collected for the caller
  * to print + exit-non-zero, instead of throwing — matches existing CLI flow.
  */
 function _parseRuntimeFlags(args) {
-  const out = { cli: undefined, model: undefined, modelExplicit: false, errors: [] };
+  const out = { cli: undefined, model: undefined, effort: undefined, modelExplicit: false, errors: [] };
   let i = 0;
   while (i < args.length) {
     const a = args[i];
-    if (a === '--cli') {
-      if (i + 1 >= args.length) { out.errors.push('--cli requires a value'); args.splice(i, 1); break; }
-      out.cli = String(args[i + 1]);
+    const eq = typeof a === 'string' ? a.indexOf('=') : -1;
+    const flag = eq > 0 ? a.slice(0, eq) : a;
+    const inlineValue = eq > 0 ? a.slice(eq + 1) : undefined;
+    const readValue = (name, { allowEmpty = false, hint = '' } = {}) => {
+      if (inlineValue !== undefined) {
+        if (!allowEmpty && inlineValue === '') {
+          out.errors.push(`${name} requires a value${hint}`);
+          args.splice(i, 1);
+          return { ok: false };
+        }
+        args.splice(i, 1);
+        return { ok: true, value: inlineValue };
+      }
+      if (i + 1 >= args.length || String(args[i + 1]).startsWith('--')) {
+        out.errors.push(`${name} requires a value${hint}`);
+        args.splice(i, 1);
+        return { ok: false };
+      }
+      const value = String(args[i + 1]);
       args.splice(i, 2);
-    } else if (a === '--model') {
-      if (i + 1 >= args.length) { out.errors.push('--model requires a value (use --model "" to clear)'); args.splice(i, 1); break; }
-      out.model = String(args[i + 1]);
+      return { ok: true, value };
+    };
+    if (flag === '--cli') {
+      const parsed = readValue('--cli');
+      if (parsed.ok) out.cli = parsed.value;
+    } else if (flag === '--model') {
+      const parsed = readValue('--model', { allowEmpty: true, hint: ' (use --model "" to clear)' });
+      if (!parsed.ok) continue;
+      out.model = parsed.value;
       out.modelExplicit = true;
-      args.splice(i, 2);
+    } else if (flag === '--effort') {
+      const parsed = readValue('--effort');
+      if (parsed.ok) out.effort = parsed.value;
     } else {
       i++;
     }
@@ -1222,7 +1247,7 @@ const commands = {
 
   doctor() {
     const { doctor } = require('./preflight');
-    doctor(MINIONS_DIR).then(ok => {
+    return doctor(MINIONS_DIR).then(ok => {
       if (!ok) process.exit(1);
     });
   },
@@ -1298,5 +1323,10 @@ const commands = {
   }
 };
 
-module.exports = { handleCommand };
-
+module.exports = {
+  handleCommand,
+  // exported for testing
+  _parseRuntimeFlags,
+  _modelLooksIncompatible,
+  _applyRuntimeFlags,
+};

package/engine/copilot-models.json

@@ -1,5 +1,5 @@
 {
   "runtime": "copilot",
   "models": null,
-  "cachedAt": "2026-04-29T18:05:40.260Z"
+  "cachedAt": "2026-04-29T18:09:36.782Z"
 }

package/engine/dispatch.js

@@ -12,7 +12,7 @@ const { setCooldownFailure } = require('./cooldown');
 const { safeJson, safeWrite, safeReadDir, mutateJsonFileLocked, mutateWorkItems,
   mutatePullRequests, getProjects, projectWorkItemsPath, projectPrPath, log, ts, dateStamp,
   sidecarDispatchPrompt, deleteDispatchPromptSidecar,
-  WI_STATUS, DISPATCH_RESULT, ENGINE_DEFAULTS, AGENT_STATUS, FAILURE_CLASS } = shared;
+  WI_STATUS, DISPATCH_RESULT, ENGINE_DEFAULTS, AGENT_STATUS, FAILURE_CLASS, PR_STATUS } = shared;
 const { getConfig, getDispatch, DISPATCH_PATH, INBOX_DIR } = queries;
 
 const MINIONS_DIR = shared.MINIONS_DIR;
@@ -91,6 +91,64 @@ function addToDispatch(item) {
   return item.id;
 }
 
+function _resolveDispatchProject(projectRef, config) {
+  if (!projectRef) return null;
+  const projects = getProjects(config);
+  if (projectRef.name) {
+    const byName = projects.find(p => p.name === projectRef.name);
+    if (byName) return byName;
+  }
+  if (projectRef.localPath) {
+    const refPath = path.resolve(projectRef.localPath);
+    const byPath = projects.find(p => p.localPath && path.resolve(p.localPath) === refPath);
+    if (byPath) return byPath;
+  }
+  return projectRef;
+}
+
+function _isPrBackedDispatch(entry) {
+  return !!(entry?.meta?.pr && entry.meta?.project);
+}
+
+function getStalePrDispatchReason(entry, config) {
+  if (!_isPrBackedDispatch(entry)) return '';
+  const project = _resolveDispatchProject(entry.meta.project, config);
+  if (!project) return 'missing project metadata';
+
+  const tracked = shared.findPrRecord(queries.getPrs(project), entry.meta.pr, project);
+  const prLabel = entry.meta.pr?.id || entry.meta.pr?.url || entry.id;
+  if (!tracked) return `PR ${prLabel} is no longer tracked`;
+  if (tracked.status !== PR_STATUS.ACTIVE) return `PR ${tracked.id || prLabel} is ${tracked.status || 'missing status'}`;
+  if (tracked._contextOnly) return `PR ${tracked.id || prLabel} is context-only`;
+
+  const queuedBranch = entry.meta.branch || entry.meta.pr?.branch || '';
+  const trackedBranch = tracked.branch || '';
+  if (queuedBranch && trackedBranch && shared.sanitizeBranch(queuedBranch) !== shared.sanitizeBranch(trackedBranch)) {
+    return `PR ${tracked.id || prLabel} branch changed from ${queuedBranch} to ${trackedBranch}`;
+  }
+
+  return '';
+}
+
+function pruneStalePrDispatches(config = queries.getConfig()) {
+  const removed = [];
+  mutateDispatch((dispatch) => {
+    dispatch.pending = (dispatch.pending || []).filter(entry => {
+      const reason = getStalePrDispatchReason(entry, config);
+      if (!reason) return true;
+      removed.push({ entry, reason });
+      return false;
+    });
+    return dispatch;
+  });
+
+  for (const { entry, reason } of removed) {
+    try { deleteDispatchPromptSidecar(entry); } catch { /* cleanup best-effort */ }
+    log('info', `Dropped stale PR dispatch ${entry.id}: ${reason}`);
+  }
+  return removed.length;
+}
+
 // ─── Retryable Failure Classification ────────────────────────────────────────
 
 function isRetryableFailureReason(reason = '', failureClass = '') {
@@ -253,11 +311,16 @@ function completeDispatch(id, result = DISPATCH_RESULT.SUCCESS, reason = '', res
       if (prId && project) {
         try {
           const prsPath = projectPrPath(project);
+          let restored = false;
           mutatePullRequests(prsPath, prs => {
             const target = shared.findPrRecord(prs, { id: prId }, project);
-            if (target?.humanFeedback) target.humanFeedback.pendingFix = true;
+            if (target?.humanFeedback) {
+              target.humanFeedback.pendingFix = true;
+              restored = true;
+            }
           });
-          log('info', `Restored pendingFix=true on ${prId} after failed human-feedback fix`);
+          if (restored) log('info', `Restored pendingFix=true on ${prId} after failed human-feedback fix`);
+          else log('info', `Skipped pendingFix restore for ${prId} — PR is no longer tracked`);
         } catch (e) { log('warn', `restore pendingFix: ${e.message}`); }
       }
       // Clear completed dispatch entry so dedup doesn't block re-dispatch
@@ -424,6 +487,8 @@ module.exports = {
   completeDispatch,
   writeInboxAlert,
   updateAgentStatus,
+  getStalePrDispatchReason,
+  pruneStalePrDispatches,
   cancelPendingDispatchesForPr,
   cleanDispatchEntries,
   cancelPendingWorkItems,

package/engine.js

@@ -102,7 +102,7 @@ const withFileLock = shared.withFileLock;
 // ─── Dispatch Management (extracted to engine/dispatch.js) ───────────────────
 
 const { mutateDispatch, addToDispatch, isRetryableFailureReason, completeDispatch,
-  writeInboxAlert, updateAgentStatus } = require('./engine/dispatch');
+  writeInboxAlert, updateAgentStatus, pruneStalePrDispatches } = require('./engine/dispatch');
 
 // ─── Timeout / Steering / Idle (extracted to engine/timeout.js) ──────────────
 
@@ -3639,6 +3639,7 @@ async function tickInner() {
     const maxC = config.engine?.maxConcurrent ?? ENGINE_DEFAULTS.maxConcurrent;
     setTempBudget(Math.max(0, maxC - activeCountPre));
   }
+  try { pruneStalePrDispatches(config); } catch (e) { log('warn', 'prune stale PR dispatches: ' + e.message); }
   let discoveryOk = true;
   try { await discoverWork(config); } catch (e) { log('warn', 'discoverWork: ' + e.message); discoveryOk = false; }
 
@@ -3915,7 +3916,7 @@ module.exports = {
   validateConfig,
 
   // Dispatch management (re-exported from engine/dispatch.js)
-  mutateDispatch, addToDispatch, isRetryableFailureReason, completeDispatch, writeInboxAlert, updateAgentStatus,
+  mutateDispatch, addToDispatch, isRetryableFailureReason, completeDispatch, writeInboxAlert, updateAgentStatus, pruneStalePrDispatches,
   activeProcesses, realActivityMap, engineRestartGraceExempt,
   get engineRestartGraceUntil() { return engineRestartGraceUntil; },
   set engineRestartGraceUntil(v) { engineRestartGraceUntil = v; },

package/package.json

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