@yemi33/minions 0.1.1758 → 0.1.1760

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.1.1760 (2026-05-07)
+
+### Fixes
+- reliable engine kill + visible restart output
+
 ## 0.1.1757 (2026-05-06)
 
 ### Other

package/bin/minions.js

@@ -46,6 +46,40 @@ function killByPort(port) {
   } catch {}
 }
 
+/**
+ * Read the engine's recorded PID from engine/control.json. Returns null if
+ * the file is missing/corrupt or the PID isn't a positive integer.
+ */
+function readEnginePid(minionsHome) {
+  try {
+    const data = JSON.parse(fs.readFileSync(path.join(minionsHome, 'engine', 'control.json'), 'utf8'));
+    const pid = Number(data && data.pid);
+    return Number.isInteger(pid) && pid > 0 ? pid : null;
+  } catch { return null; }
+}
+
+/**
+ * Force-kill a process and its descendants by PID. The /T flag on taskkill
+ * recurses into the process tree on Windows, which `process.kill()` does not.
+ * On POSIX, walk pgrep first so spawned children die before the parent.
+ */
+function killPidTree(pid) {
+  if (!pid || pid === process.pid) return;
+  try {
+    if (process.platform === 'win32') {
+      execSync(`taskkill /F /T /PID ${pid}`, { stdio: 'ignore', timeout: 5000, windowsHide: true });
+    } else {
+      try {
+        const out = execSync(`pgrep -P ${pid}`, { encoding: 'utf8', timeout: 3000 });
+        for (const c of out.split(/\r?\n/).map(s => Number(s.trim())).filter(n => Number.isInteger(n) && n > 0)) {
+          try { process.kill(c, 'SIGKILL'); } catch {}
+        }
+      } catch {}
+      try { process.kill(pid, 'SIGKILL'); } catch {}
+    }
+  } catch {}
+}
+
 /** Kill minions processes by command-line pattern matching (wmic on Windows, pkill on Unix). */
 function killMinionsProcesses(patterns) {
   try {
@@ -330,14 +364,12 @@ function init() {
     printPreflight(results, { label: 'Preflight checks' });
   } catch {}
 
-  if (isUpgrade && skipStart) {
-    console.log(`\n  Upgrade complete (${pkgVersion}). Restart skipped by caller.\n`);
-    return;
-  }
+  // Update flow passes --skip-start so it can perform a single visible restart afterwards.
+  if (isUpgrade && skipStart) return;
 
   // Auto-start on fresh install; direct force-upgrade restarts automatically.
   if (isUpgrade) {
-    try { execSync(`node "${path.join(MINIONS_HOME, 'engine.js')}" stop`, { stdio: 'ignore', cwd: MINIONS_HOME }); } catch {}
+    try { execSync(`node "${path.join(MINIONS_HOME, 'engine.js')}" stop`, { stdio: 'ignore', cwd: MINIONS_HOME, timeout: 10000, windowsHide: true }); } catch {}
   }
   console.log(isUpgrade
     ? `\n  Upgrade complete (${pkgVersion}). Restarting engine and dashboard...\n`
@@ -422,11 +454,6 @@ function showChangelog(fromVersion) {
   console.log(`    cat ${changelogPath}\n`);
 }
 
-function writeCommandOutput(stream, output) {
-  if (!output) return;
-  stream.write(Buffer.isBuffer(output) ? output.toString('utf8') : String(output));
-}
-
 function formatPackageCliCommand(args) {
   const initScript = path.join(PKG_ROOT, 'bin', 'minions.js');
   return `node "${initScript}" ${args.join(' ')}`;
@@ -434,17 +461,13 @@ function formatPackageCliCommand(args) {
 
 function runPackageCli(args, timeout) {
   const initScript = path.join(PKG_ROOT, 'bin', 'minions.js');
-  const result = spawnSync(process.execPath, [initScript, ...args], {
+  return spawnSync(process.execPath, [initScript, ...args], {
     cwd: process.cwd(),
     env: { ...process.env, MINIONS_HOME },
-    encoding: 'utf8',
+    stdio: 'inherit',
     timeout,
     windowsHide: true,
   });
-
-  writeCommandOutput(process.stdout, result.stdout);
-  writeCommandOutput(process.stderr, result.stderr);
-  return result;
 }
 
 function runPostUpdateInit() {
@@ -615,10 +638,17 @@ if (!cmd || cmd === 'help' || cmd === '--help' || cmd === '-h') {
   // `--cli` / `--model` flags forward to `engine.js start` so the runtime
   // fleet flips before the daemon spawns (P-6b3f9c2e AC: works on restart).
   ensureInstalled();
-  // Stop engine if running (graceful attempt)
-  try { execSync(`node "${path.join(MINIONS_HOME, 'engine.js')}" stop`, { stdio: 'ignore', cwd: MINIONS_HOME }); } catch {}
-  // Kill all existing engine/dashboard processes — handles crashed engines and orphan dashboards
+  // Layered kill — each step is best-effort, layered so the next still runs if
+  // one fails. Goal: the old engine is gone before we spawn a new one, even if
+  // PowerShell is unavailable, the engine is hung, or its cmdline doesn't match.
+  const oldEnginePid = readEnginePid(MINIONS_HOME);
+  // 1. Graceful stop — short timeout so a hung engine can't block what follows.
+  try { execSync(`node "${path.join(MINIONS_HOME, 'engine.js')}" stop`, { stdio: 'ignore', cwd: MINIONS_HOME, timeout: 10000, windowsHide: true }); } catch {}
+  // 2. Force-kill the recorded engine PID and its tree (most reliable — independent of cmdline matching).
+  killPidTree(oldEnginePid);
+  // 3. Free dashboard port (catches orphan dashboards with no recorded PID).
   killByPort(7331);
+  // 4. Belt-and-suspenders cmdline match for anything still alive.
   killMinionsProcesses(['engine.js', 'dashboard.js']);
   const engineProc = spawn(process.execPath, [path.join(MINIONS_HOME, 'engine.js'), 'start', ...rest], {
     cwd: MINIONS_HOME, stdio: 'ignore', detached: true, windowsHide: true

package/engine/copilot-models.json

@@ -1,5 +1,5 @@
 {
   "runtime": "copilot",
   "models": null,
-  "cachedAt": "2026-05-07T00:35:48.236Z"
+  "cachedAt": "2026-05-07T00:40:39.172Z"
 }

package/engine/lifecycle.js

@@ -542,6 +542,16 @@ function updateWorkItemStatus(meta, status, reason) {
         target.completedAt = ts();
         // Restore agent info from dispatch metadata (cleared on retry reset)
         if (meta._agentId && !target.dispatched_to) target.dispatched_to = meta._agentId;
+        // No-op marker (set by runPostCompletionHooks when the agent honored a
+        // verify-already-shipped / no-op-fix-review skill). Surfaces the
+        // rationale on the dashboard instead of marking the WI as failed.
+        if (meta._noopReason) {
+          target._noop = true;
+          target._noopReason = meta._noopReason;
+        } else {
+          delete target._noop;
+          delete target._noopReason;
+        }
       } else if (status === WI_STATUS.FAILED) {
         if (reason) target.failReason = reason;
         target.failedAt = ts();
@@ -2510,6 +2520,38 @@ function parseCompletionBoolean(value) {
   return undefined;
 }
 
+// Detect a deliberate no-op completion — the agent correctly declined to make
+// changes (work was already shipped, dispatch premise was wrong, self-authored
+// review with no actionable feedback, etc.) and should NOT be flagged as a
+// silent failure for missing a PR. Honored signals:
+//   - completion.noop === true (canonical, primary)
+//   - completion.result === 'noop'  OR  completion.result.type === 'noop'
+// Returns the no-op rationale string (for surfacing in WI metadata) when
+// detected, or null otherwise. The status must be a successful terminal state
+// — a failed/partial/in-progress completion that also claims `noop` is a
+// contradiction and falls through to the normal contract.
+function parseCompletionNoop(completion) {
+  if (!completion || typeof completion !== 'object') return null;
+  const explicit = parseCompletionBoolean(completion.noop);
+  let resultIsNoop = false;
+  if (typeof completion.result === 'string') {
+    resultIsNoop = completion.result.trim().toLowerCase() === 'noop';
+  } else if (completion.result && typeof completion.result === 'object') {
+    resultIsNoop = String(completion.result.type || '').trim().toLowerCase() === 'noop';
+  }
+  if (explicit !== true && !resultIsNoop) return null;
+  const status = normalizeCompletionStatus(completion.status);
+  if (status && status !== 'success' && status !== 'done' && status !== 'complete') return null;
+  const reason = String(
+    completion.noopReason
+      || completion.noop_reason
+      || completion.summary
+      || completion.reason
+      || ''
+  ).trim();
+  return reason || 'no-op completion';
+}
+
 function normalizeReviewVerdict(verdict) {
   const value = String(verdict || '').trim().toLowerCase().replace(/[\s-]+/g, '_');
   if (value === 'approve' || value === 'approved') return 'approved';
@@ -2867,7 +2909,17 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
     }
   }
 
-  if (effectiveSuccess && meta?.item?.id && !skipDoneStatus) {
+  // No-op signal: agent declared the work was correctly NOT done (already
+  // shipped, dispatch premise wrong, self-authored review, etc.). Skip the PR
+  // attachment contract — a missing PR is intentional, not a silent failure.
+  const noopRationale = (effectiveSuccess && meta?.item?.id && !skipDoneStatus)
+    ? parseCompletionNoop(structuredCompletion)
+    : null;
+  if (noopRationale) {
+    log('info', `No-op completion for ${meta.item.id}: ${noopRationale.slice(0, 200)}`);
+  }
+
+  if (effectiveSuccess && meta?.item?.id && !skipDoneStatus && !noopRationale) {
     completionContractFailure = await enforcePrAttachmentContract(type, meta, agentId, config, resultSummary, stdout);
     if (completionContractFailure?.severity === 'hard' || completionContractFailure?.nonTerminal) {
       skipDoneStatus = true;
@@ -2876,6 +2928,9 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
 
   if (effectiveSuccess && meta?.item?.id && !skipDoneStatus) {
     meta._agentId = agentId;
+    if (noopRationale) {
+      meta._noopReason = noopRationale.slice(0, 500);
+    }
     updateWorkItemStatus(meta, WI_STATUS.DONE, '');
   }
   // Failure retry is handled by completeDispatch in dispatch.js — not duplicated here.
@@ -3238,6 +3293,7 @@ module.exports = {
   isReviewBailout,
   parseStructuredCompletion,
   parseCompletionFieldSummary,
+  parseCompletionNoop,
   detectNonTerminalResultSummary,
   parseCompletionReportFile,
   persistCompletionReport,

package/package.json

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

package/playbooks/shared-rules.md

@@ -72,6 +72,8 @@ The engine provides a completion report path in the prompt and in `MINIONS_COMPL
 
 Use `status: "failed"` plus an accurate `failure_class`, `retryable`, and `needs_rerun` when the task could not be completed. For PR reviews, set `verdict` to `approved` or `changes-requested`. Include every durable artifact you created or updated in `artifacts` (PRs, notes, plans, PRDs, important files) so the dashboard can display them. Fenced `completion` blocks are still accepted as a fallback, but the JSON report is the primary signal.
 
+**No-op completions:** when you correctly decline to do the work — the change was already shipped on master, the dispatch premise is wrong, the flagged review comment is your own author-notes, etc. — write `status: "success"`, `pr: "N/A"`, AND add `"noop": true`. The engine treats `noop: true` as the canonical signal that no PR was expected, marks the work item done with the rationale surfaced in `_noopReason` for the dashboard, and skips the missing-PR-attachment failure. Without `noop: true`, an empty PR will still be flagged as a silent failure and auto-retried up to `maxRetries` times.
+
 ## Long-Running Commands
 
 Builds, dependency installs, tests, and local servers can be quiet for long periods. Run the repo's normal CLI commands and let them finish; do not add artificial progress output, heartbeat loops, or command-specific workarounds just to keep Minions active.