@yemi33/minions 0.1.1696 → 0.1.1698

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.1.1698 (2026-05-04)
+
+### Features
+- fix update restart and Copilot steering (#2025)
+
 ## 0.1.1696 (2026-05-04)
 
 ### Features

package/bin/minions.js

@@ -203,6 +203,7 @@ function resolveMinionsHome(forInit = false) {
 const [cmd, ...rest] = process.argv.slice(2);
 let force = rest.includes('--force');
 const skipScan = rest.includes('--skip-scan');
+const skipStart = rest.includes('--skip-start') || rest.includes('--no-start');
 const MINIONS_HOME = resolveMinionsHome(cmd === 'init');
 
 function isSubpath(parent, child) {
@@ -339,7 +340,12 @@ function init() {
     printPreflight(results, { label: 'Preflight checks' });
   } catch {}
 
-  // Auto-start on fresh install; force-upgrade restarts automatically.
+  if (isUpgrade && skipStart) {
+    console.log(`\n  Upgrade complete (${pkgVersion}). Restart skipped by caller.\n`);
+    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 {}
   }
@@ -436,7 +442,7 @@ function showVersion() {
   if (installed) {
     console.log(`  Installed version: ${installed}`);
     if (installed !== pkg) {
-      console.log('\n  Update available! Run: minions init --force');
+      console.log('\n  Update available! Run: minions update');
     } else {
       console.log('  Up to date.');
     }
@@ -449,7 +455,7 @@ function showVersion() {
     const latest = execSync('npm view @yemi33/minions version', { encoding: 'utf8', timeout: 5000, windowsHide: true }).trim();
     if (latest && latest !== pkg) {
       console.log(`\n  Latest on npm:     ${latest}`);
-      console.log('  To update: npm update -g @yemi33/minions && minions init --force');
+      console.log('  To update: minions update');
     }
   } catch {} // offline or npm not available — skip silently
 
@@ -489,7 +495,7 @@ if (!cmd || cmd === 'help' || cmd === '--help' || cmd === '-h') {
 
   Setup:
     minions init                     Bootstrap ~/.minions/ (first time)
-    minions update                   Update to latest version (npm update + init --force)
+    minions update                   Update to latest version (npm update + one restart)
     minions version                  Show installed vs package version
     minions doctor                   Check prerequisites and runtime health
     minions add <project-dir>        Link a project (interactive)
@@ -538,7 +544,7 @@ if (!cmd || cmd === 'help' || cmd === '--help' || cmd === '-h') {
       console.error('  npm update failed:', e.message);
       process.exit(1);
     }
-    execSync('minions init --force', { stdio: 'inherit', timeout: 120000 });
+    execSync('minions init --force --skip-start', { stdio: 'inherit', timeout: 120000 });
   }
   // Restart engine + dashboard so they pick up the new code
   console.log('\n  Restarting engine and dashboard...\n');
@@ -761,4 +767,3 @@ if (!cmd || cmd === 'help' || cmd === '--help' || cmd === '-h') {
   console.log('  Run "minions help" for usage.\n');
   process.exit(1);
 }
-

package/dashboard.js

@@ -226,6 +226,40 @@ function _agentSessionIsDraining(agentId) {
   return terminalIdx >= 0 && terminalIdx > lastSteer;
 }
 
+function _dispatchBranch(item) {
+  const branch = item?.meta?.branch || item?.branch || item?.meta?.item?.branch || item?.meta?.item?.featureBranch;
+  return branch ? String(branch).replace(/^refs\/heads\//, '') : null;
+}
+
+function _hasCachedResumeSession(agentId, activeDispatch, maxAgeMs = 2 * 60 * 60 * 1000) {
+  const sessionFile = safeJson(path.join(AGENTS_DIR, agentId, 'session.json'));
+  if (!sessionFile?.sessionId || !sessionFile.savedAt) return false;
+  const savedAtMs = new Date(sessionFile.savedAt).getTime();
+  if (!Number.isFinite(savedAtMs) || Date.now() - savedAtMs >= maxAgeMs) return false;
+  const dispatchBranch = _dispatchBranch(activeDispatch);
+  const sessionBranch = sessionFile.branch ? String(sessionFile.branch).replace(/^refs\/heads\//, '') : null;
+  return !!dispatchBranch && !!sessionBranch && dispatchBranch === sessionBranch;
+}
+
+function _steeringDeliveryState(agentId) {
+  const activeDispatch = (getDispatchQueue().active || []).find(d => d.agent === agentId);
+  if (!activeDispatch) return { deliveryStatus: 'queued', pendingDelivery: true };
+
+  const runtimeName = shared.resolveAgentCli(CONFIG.agents?.[agentId], CONFIG.engine);
+  try {
+    const runtime = require('./engine/runtimes').resolveRuntime(runtimeName);
+    if (runtime?.capabilities?.midRunSessionId === false && !_hasCachedResumeSession(agentId, activeDispatch)) {
+      return {
+        deliveryStatus: 'pending_checkpoint',
+        pendingDelivery: true,
+        detail: 'Runtime has not emitted a resumable session yet; delivery is pending until the next resumable checkpoint.',
+      };
+    }
+  } catch { /* unknown runtime: checkSteering will surface retry state */ }
+
+  return { deliveryStatus: 'queued', pendingDelivery: false };
+}
+
 const PLANS_DIR = path.join(MINIONS_DIR, 'plans');
 const TEAMS_INBOX_PATH = path.join(ENGINE_DIR, 'teams-inbox.json');
 
@@ -5778,7 +5812,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     const engine = getEngineState();
     const agents = getAgents();
     const health = {
-      status: engine.state === 'running' ? 'healthy' : engine.state === 'paused' ? 'degraded' : 'stopped',
+      status: engine.state === 'running' ? 'healthy' : (engine.state === 'paused' || engine.state === 'stopping') ? 'degraded' : 'stopped',
       engine: { state: engine.state, pid: engine.pid },
       agents: agents.map(a => ({ id: a.id, name: a.name, status: a.status })),
       projects: PROJECTS.map(p => ({ name: p.name, reachable: fs.existsSync(p.localPath) })),
@@ -6219,6 +6253,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       }
 
       const entry = steering.writeSteeringMessage(agentId, text);
+      const delivery = _steeringDeliveryState(agentId);
 
       // Also append to live-output.log so it shows in the chat view
       const liveLogPath = path.join(agentDir, 'live-output.log');
@@ -6226,7 +6261,8 @@ 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 queued',
+        message: delivery.pendingDelivery ? 'Steering message pending delivery' : 'Steering message queued',
+        ...delivery,
         file: entry?.file || null,
         inboxCount: steering.listUnreadSteeringMessages(agentId).length,
       });

package/engine/cli.js

@@ -52,6 +52,43 @@ function isEngineProcessAlive(control) {
   }
 }
 
+function createControlOwner(pid = process.pid) {
+  return { pid, ownerToken: `${pid}-${shared.uid()}` };
+}
+
+function controlBelongsToOwner(control, owner) {
+  return !!(
+    control &&
+    owner &&
+    owner.ownerToken &&
+    control.ownerToken === owner.ownerToken &&
+    control.pid === owner.pid
+  );
+}
+
+function mutateControlForOwner(owner, mutator) {
+  let changed = false;
+  const control = mutateControl(current => {
+    if (!controlBelongsToOwner(current, owner)) return current;
+    changed = true;
+    return mutator(current);
+  });
+  return { changed, control };
+}
+
+function markControlStoppingForOwner(owner, stoppingAt) {
+  return mutateControlForOwner(owner, current => ({
+    ...current,
+    state: 'stopping',
+    pid: owner.pid,
+    stopping_at: stoppingAt,
+  }));
+}
+
+function markControlStoppedForOwner(owner, stoppedAt) {
+  return mutateControlForOwner(owner, () => ({ state: 'stopped', stopped_at: stoppedAt }));
+}
+
 function handleCommand(cmd, args) {
   if (!cmd) {
     return commands.start();
@@ -320,7 +357,15 @@ const commands = {
     }
     let codeCommit = null;
     try { codeCommit = require('child_process').execSync('git rev-parse --short HEAD', { cwd: path.resolve(__dirname, '..'), encoding: 'utf8', timeout: 5000, windowsHide: true }).trim(); } catch {}
-    mutateControl(() => ({ state: 'running', pid: process.pid, started_at: e.ts(), codeVersion, codeCommit }));
+    const controlOwner = createControlOwner();
+    mutateControl(() => ({
+      state: 'running',
+      pid: controlOwner.pid,
+      ownerToken: controlOwner.ownerToken,
+      started_at: e.ts(),
+      codeVersion,
+      codeCommit
+    }));
     // Keep .minions-version in sync so `minions version` stays accurate after git pulls
     if (codeVersion) {
       try { fs.writeFileSync(path.join(shared.MINIONS_DIR, '.minions-version'), codeVersion); } catch {}
@@ -688,11 +733,18 @@ const commands = {
       clearInterval(fastPollTimer);
       if (teamsInboxTimer) clearInterval(teamsInboxTimer);
       for (const f of _watchedFiles) { try { fs.unwatchFile(f); } catch { /* cleanup */ } }
-      mutateControl(() => ({ state: 'stopping', pid: process.pid, stopping_at: e.ts() }));
+      const stoppingAt = e.ts();
+      const stoppingWrite = markControlStoppingForOwner(controlOwner, stoppingAt);
+      if (!stoppingWrite.changed) {
+        e.log('warn', 'Graceful shutdown skipped control.json stopping transition; control file is owned by a different engine process');
+      }
       e.log('info', `Graceful shutdown initiated (${signal})`);
 
       if (e.activeProcesses.size === 0) {
-        mutateControl(() => ({ state: 'stopped', stopped_at: e.ts() }));
+        const stoppedWrite = markControlStoppedForOwner(controlOwner, e.ts());
+        if (!stoppedWrite.changed) {
+          e.log('warn', 'Graceful shutdown skipped control.json stopped transition; control file is owned by a different engine process');
+        }
         e.log('info', 'Graceful shutdown complete (no active agents)');
         shared.flushLogs(); // drain buffered log entries before exit
         console.log('No active agents — stopped.');
@@ -706,7 +758,10 @@ const commands = {
       const poll = setInterval(() => {
         if (e.activeProcesses.size === 0) {
           clearInterval(poll);
-          mutateControl(() => ({ state: 'stopped', stopped_at: e.ts() }));
+          const stoppedWrite = markControlStoppedForOwner(controlOwner, e.ts());
+          if (!stoppedWrite.changed) {
+            e.log('warn', 'Graceful shutdown skipped control.json stopped transition; control file is owned by a different engine process');
+          }
           e.log('info', 'Graceful shutdown complete (all agents finished)');
           shared.flushLogs(); // drain buffered log entries before exit
           console.log('All agents finished — stopped.');
@@ -714,7 +769,10 @@ const commands = {
         }
         if (Date.now() >= deadline) {
           clearInterval(poll);
-          mutateControl(() => ({ state: 'stopped', stopped_at: e.ts() }));
+          const stoppedWrite = markControlStoppedForOwner(controlOwner, e.ts());
+          if (!stoppedWrite.changed) {
+            e.log('warn', 'Graceful shutdown skipped control.json stopped transition; control file is owned by a different engine process');
+          }
           e.log('warn', `Graceful shutdown timed out after ${timeout / 1000}s with ${e.activeProcesses.size} agent(s) still active`);
           shared.flushLogs(); // drain buffered log entries before exit
           console.log(`Shutdown timeout (${timeout / 1000}s) — force exiting with ${e.activeProcesses.size} agent(s) still running.`);
@@ -1374,4 +1432,8 @@ module.exports = {
   _parseRuntimeFlags,
   _modelLooksIncompatible,
   _applyRuntimeFlags,
+  _createControlOwner: createControlOwner,
+  _controlBelongsToOwner: controlBelongsToOwner,
+  _markControlStoppingForOwner: markControlStoppingForOwner,
+  _markControlStoppedForOwner: markControlStoppedForOwner,
 };

package/engine/copilot-models.json

@@ -1,5 +1,5 @@
 {
   "runtime": "copilot",
   "models": null,
-  "cachedAt": "2026-05-04T06:12:43.776Z"
+  "cachedAt": "2026-05-04T06:31:58.762Z"
 }

package/engine.js

@@ -1129,14 +1129,35 @@ async function spawnAgent(dispatchItem, config) {
     const procInfo = activeProcesses.get(id);
     ackPendingSteeringFiles(agentId, procInfo, stdout);
 
+    if (procInfo?._deferredSteeringFiles?.length && procInfo.sessionId) {
+      const deferredPaths = new Set(procInfo._deferredSteeringFiles);
+      const pendingDeferred = steering.listUnreadSteeringMessages(agentId)
+        .filter(entry => deferredPaths.has(entry.path) && entry.message.trim());
+      if (pendingDeferred.length > 0) {
+        log('info', `Steering: delivering ${pendingDeferred.length} deferred message(s) for ${agentId} at resumable checkpoint`);
+        procInfo._steeringMessage = pendingDeferred.map(entry => entry.message.trim()).join('\n\n');
+        procInfo._steeringSessionId = procInfo.sessionId;
+        procInfo._steeringEntry = pendingDeferred;
+        procInfo._steeringDeferredCheckpoint = true;
+        delete procInfo._deferredSteeringFiles;
+      } else {
+        delete procInfo._deferredSteeringFiles;
+      }
+    } else if (procInfo?._deferredSteeringFiles?.length) {
+      log('warn', `Steering: ${agentId} exited before a resumable sessionId was available — message remains pending`);
+      try { fs.appendFileSync(liveOutputPath, `\n[steering-pending] Agent exited before a resumable session was available. Your message remains unread and will be retried on the next dispatch.\n`); } catch {}
+    }
+
     // Check if this was a steering kill — re-spawn with resume
     if (procInfo?._steeringMessage) {
       const steerMsg = procInfo._steeringMessage;
       const steerSessionId = procInfo._steeringSessionId;
       const steerEntry = procInfo._steeringEntry;
+      const steeringDeferredCheckpoint = procInfo._steeringDeferredCheckpoint === true;
       delete procInfo._steeringMessage;
       delete procInfo._steeringSessionId;
       delete procInfo._steeringEntry;
+      delete procInfo._steeringDeferredCheckpoint;
 
       // Guard: can't resume without a session
       if (!steerSessionId) {
@@ -1247,9 +1268,13 @@ async function spawnAgent(dispatchItem, config) {
         ),
       });
 
-      // Reset output buffers so post-completion parsing only sees the resumed session
-      stdout = '';
-      stderr = '';
+      // Live steering kills discard partial old output. Deferred checkpoint
+      // steering keeps the completed turn output so completion parsing still
+      // sees the original work if the follow-up only acknowledges steering.
+      if (!steeringDeferredCheckpoint) {
+        stdout = '';
+        stderr = '';
+      }
       sessionCaptureState.sessionLineBuffer = '';
       // Re-wire stdout/stderr handlers (same as original)
       resumeProc.stdout.on('data', (data) => {

package/package.json

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