@yemi33/minions 0.1.1764 → 0.1.1766

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.1.1766 (2026-05-07)
+
+### Features
+- suppress duplicate browser tabs on restart/update
+-  pre-flight model compat check for ccCall/ccCallStreaming + Copilot resolveModel
+- probe every registered runtime adapter, not just claude
+
+### Fixes
+- silence 'couldn't find remote ref' warnings on worktree reuse for never-pushed branches (#2155)
+- close remaining test isolation leaks + add end-of-run regression guard (#2152)
+- surface legacy .minions dir removal in logs
+- clear session.json when conversation jsonl missing (W-mouugzow00068741) (#2153)
+- stop archived PRDs from resurrecting via safeJson .backup restore (#2144)
+
 ## 0.1.1764 (2026-05-07)
 
 ### Other

package/bin/minions.js

@@ -28,9 +28,11 @@ const os = require('os');
 const { spawn, spawnSync, execSync } = require('child_process');
 
 const PKG_ROOT = path.resolve(__dirname, '..');
+const DASH_PORT = 7331;
 
-/** Kill process(es) listening on a given port. Works cross-platform. */
-function killByPort(port) {
+/** Returns PIDs (as strings) of processes LISTENING on `port`. Empty on no match
+ *  or when the platform tool (netstat/findstr/lsof) is unavailable. */
+function getListeningPids(port) {
   try {
     if (process.platform === 'win32') {
       const out = execSync(`netstat -ano | findstr ":${port} " | findstr LISTENING`, { encoding: 'utf8', timeout: 5000, windowsHide: true });
@@ -39,13 +41,25 @@ function killByPort(port) {
         const pid = line.trim().split(/\s+/).pop();
         if (pid && /^\d+$/.test(pid) && pid !== '0' && pid !== String(process.pid)) pids.add(pid);
       }
-      for (const pid of pids) try { execSync(`taskkill /F /PID ${pid}`, { stdio: 'ignore', timeout: 5000, windowsHide: true }); } catch {}
-    } else {
-      execSync(`lsof -ti:${port} | xargs kill -9 2>/dev/null`, { timeout: 5000 });
+      return [...pids];
     }
-  } catch {}
+    const out = execSync(`lsof -ti:${port}`, { encoding: 'utf8', timeout: 5000 });
+    return out.split('\n').map(s => s.trim()).filter(Boolean);
+  } catch { return []; }
+}
+
+/** Kill process(es) listening on a given port. Works cross-platform. */
+function killByPort(port) {
+  const pids = getListeningPids(port);
+  if (process.platform === 'win32') {
+    for (const pid of pids) try { execSync(`taskkill /F /PID ${pid}`, { stdio: 'ignore', timeout: 5000, windowsHide: true }); } catch {}
+  } else {
+    for (const pid of pids) try { process.kill(Number(pid), 'SIGKILL'); } catch {}
+  }
 }
 
+const isPortListening = (port) => getListeningPids(port).length > 0;
+
 /**
  * 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.
@@ -102,6 +116,18 @@ function killMinionsProcesses(patterns) {
     }
   } catch {}
 }
+
+/** Spawn a detached dashboard. When `suppressOpen` is true, the new dashboard
+ *  skips its auto-open of the browser — the existing tab will SSE-reconnect. */
+function spawnDashboard(suppressOpen) {
+  const env = suppressOpen ? { ...process.env, MINIONS_NO_AUTO_OPEN: '1' } : process.env;
+  const proc = spawn(process.execPath, [path.join(MINIONS_HOME, 'dashboard.js')], {
+    cwd: MINIONS_HOME, stdio: 'ignore', detached: true, windowsHide: true, env
+  });
+  proc.unref();
+  return proc;
+}
+
 const DEFAULT_MINIONS_HOME = path.join(os.homedir(), '.minions');
 const ROOT_POINTER_PATH = path.join(os.homedir(), '.minions-root');
 const LEGACY_DEFAULT_SQUAD_HOME = path.join(os.homedir(), '.squad');
@@ -353,10 +379,17 @@ function init() {
     showChangelog(installedVersion);
   }
 
-  // Run preflight checks (warn only — don't block init)
+  // Run preflight checks (warn only — don't block init).
+  // includeAllRegistered: probe every registered runtime adapter (claude AND
+  // copilot today) so the user sees availability of both, even if their
+  // current config only references one. Missing optional runtimes surface as
+  // warns, not failures.
   try {
     const { runPreflight, printPreflight } = require(path.join(MINIONS_HOME, 'engine', 'preflight'));
-    const { results } = runPreflight();
+    let preflightConfig = null;
+    try { preflightConfig = JSON.parse(fs.readFileSync(path.join(MINIONS_HOME, 'config.json'), 'utf8')); }
+    catch { /* config may not exist on first init — fine, preflight handles null */ }
+    const { results } = runPreflight({ config: preflightConfig, includeAllRegistered: true });
     printPreflight(results, { label: 'Preflight checks' });
   } catch {}
 
@@ -364,8 +397,14 @@ function init() {
   if (isUpgrade && skipStart) return;
 
   // Auto-start on fresh install; direct force-upgrade restarts automatically.
+  // Probe before kill so we can suppress the new dashboard's auto-open when an
+  // existing tab is already live (it'll SSE-reconnect to the new dashboard).
+  const dashWasUp = isPortListening(DASH_PORT);
   if (isUpgrade) {
     try { execSync(`node "${path.join(MINIONS_HOME, 'engine.js')}" stop`, { stdio: 'ignore', cwd: MINIONS_HOME, timeout: 10000, windowsHide: true }); } catch {}
+    // Free the dashboard port too — without this the new dashboard EADDRINUSE-dies
+    // silently and the user keeps running stale code from the old dashboard process.
+    killByPort(DASH_PORT);
   }
   console.log(isUpgrade
     ? `\n  Upgrade complete (${pkgVersion}). Restarting engine and dashboard...\n`
@@ -376,12 +415,9 @@ function init() {
   engineProc.unref();
   console.log(`  Engine started (PID: ${engineProc.pid})`);
 
-  const dashProc = spawn(process.execPath, [path.join(MINIONS_HOME, 'dashboard.js')], {
-    cwd: MINIONS_HOME, stdio: 'ignore', detached: true, windowsHide: true
-  });
-  dashProc.unref();
+  const dashProc = spawnDashboard(dashWasUp);
   console.log(`  Dashboard started (PID: ${dashProc.pid})`);
-  console.log('  Dashboard: http://localhost:7331');
+  console.log(`  Dashboard: http://localhost:${DASH_PORT}`);
 
   // Next steps guidance
   console.log(`
@@ -634,6 +670,9 @@ 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();
+  // Probe before kill so we can suppress the new dashboard's auto-open when an
+  // existing tab is already live (it'll SSE-reconnect to the new dashboard).
+  const dashWasUp = isPortListening(DASH_PORT);
   // 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.
@@ -644,7 +683,7 @@ if (!cmd || cmd === 'help' || cmd === '--help' || cmd === '-h') {
   //    survive so the new engine can re-attach them via PID files).
   killPidOnly(oldEnginePid);
   // 3. Free dashboard port (catches orphan dashboards with no recorded PID).
-  killByPort(7331);
+  killByPort(DASH_PORT);
   // 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], {
@@ -652,12 +691,9 @@ if (!cmd || cmd === 'help' || cmd === '--help' || cmd === '-h') {
   });
   engineProc.unref();
   console.log(`\n  Engine started (PID: ${engineProc.pid})`);
-  const dashProc = spawn(process.execPath, [path.join(MINIONS_HOME, 'dashboard.js')], {
-    cwd: MINIONS_HOME, stdio: 'ignore', detached: true, windowsHide: true
-  });
-  dashProc.unref();
+  const dashProc = spawnDashboard(dashWasUp);
   console.log(`  Dashboard started (PID: ${dashProc.pid})`);
-  console.log('  Dashboard: http://localhost:7331\n');
+  console.log(`  Dashboard: http://localhost:${DASH_PORT}\n`);
 } else if (cmd === 'nuke') {
   ensureInstalled();
   if (!rest.includes('--confirm')) {
@@ -688,7 +724,7 @@ if (!cmd || cmd === 'help' || cmd === '--help' || cmd === '-h') {
 
   // 1. Kill all processes
   try { execSync(`node "${path.join(MINIONS_HOME, 'engine.js')}" stop`, { stdio: 'ignore', cwd: MINIONS_HOME }); } catch {}
-  killByPort(7331);
+  killByPort(DASH_PORT);
   killMinionsProcesses(['engine.js', 'dashboard.js', 'spawn-agent.js']);
   console.log('  Killed all processes');
 
@@ -774,7 +810,7 @@ if (!cmd || cmd === 'help' || cmd === '--help' || cmd === '-h') {
 
   // 1. Kill all processes
   try { execSync(`node "${path.join(MINIONS_HOME, 'engine.js')}" stop`, { stdio: 'ignore', cwd: MINIONS_HOME, timeout: 10000 }); } catch {}
-  killByPort(7331);
+  killByPort(DASH_PORT);
   killMinionsProcesses(['engine.js', 'dashboard.js', 'spawn-agent.js']);
   console.log('  Killed all processes');
 
@@ -816,7 +852,6 @@ if (!cmd || cmd === 'help' || cmd === '--help' || cmd === '-h') {
   ensureInstalled();
   // If dashboard is already running, just open the browser
   const net = require('net');
-  const dashPort = 7331;
   const sock = new net.Socket();
   let handled = false;
   sock.setTimeout(1000);
@@ -824,7 +859,7 @@ if (!cmd || cmd === 'help' || cmd === '--help' || cmd === '-h') {
     sock.destroy();
     if (handled) return;
     handled = true;
-    const url = `http://localhost:${dashPort}`;
+    const url = `http://localhost:${DASH_PORT}`;
     console.log(`\n  Dashboard already running: ${url}\n`);
     try {
       const openCmd = process.platform === 'win32' ? `start ${url}` : process.platform === 'darwin' ? `open ${url}` : `xdg-open ${url}`;
@@ -843,7 +878,7 @@ if (!cmd || cmd === 'help' || cmd === '--help' || cmd === '-h') {
     handled = true;
     delegate('dashboard.js', rest);
   });
-  sock.connect(dashPort, '127.0.0.1');
+  sock.connect(DASH_PORT, '127.0.0.1');
 } else if (engineCmds.has(cmd)) {
   delegate('engine.js', [cmd, ...rest]);
 } else {

package/dashboard.js

@@ -33,7 +33,7 @@ const projectDiscovery = require('./engine/project-discovery');
 const features = require('./engine/features');
 const os = require('os');
 
-const { safeRead, safeReadDir, safeWrite, safeJson, safeJsonObj, safeJsonArr, safeUnlink, mutateJsonFileLocked, mutateControl, mutateCooldowns, mutateWorkItems, getProjects: _getProjects, DONE_STATUSES, WI_STATUS, WORK_TYPE, reopenWorkItem } = shared;
+const { safeRead, safeReadDir, safeWrite, safeJson, safeJsonObj, safeJsonArr, safeJsonNoRestore, safeUnlink, mutateJsonFileLocked, mutateControl, mutateCooldowns, mutateWorkItems, getProjects: _getProjects, DONE_STATUSES, WI_STATUS, WORK_TYPE, reopenWorkItem } = shared;
 const { getAgents, getAgentDetail, getPrdInfo, getWorkItems, getDispatchQueue,
   getSkills, getInbox, getNotesWithMeta, getPullRequests,
   getEngineLog, getMetrics, getKnowledgeBaseEntries, timeSince,
@@ -66,7 +66,17 @@ function ensureConfiguredProjectStateFiles() {
     const root = p.localPath ? path.resolve(p.localPath) : null;
     if (!root || !fs.existsSync(root)) continue;
     try {
-      shared.ensureProjectStateFiles(p, { migrateLegacy: true, removeLegacy: true });
+      const state = shared.ensureProjectStateFiles(p, { migrateLegacy: true, removeLegacy: true });
+      if (state.migrated.length > 0 || state.removedLegacy.length > 0 || state.legacyDirRemoved) {
+        const parts = [];
+        if (state.migrated.length > 0) parts.push(`merged ${state.migrated.join(', ')}`);
+        if (state.removedLegacy.length > 0) parts.push(`removed ${state.removedLegacy.join(', ')}`);
+        if (state.legacyDirRemoved) parts.push(`removed legacy .minions dir`);
+        console.log(`[dashboard] migrated project state for "${p.name}" → projects/${p.name} (${parts.join('; ')})`);
+      }
+      if (state.legacyDirRemoveError) {
+        console.warn(`[dashboard] failed to remove legacy .minions dir for "${p.name}": ${state.legacyDirRemoveError}`);
+      }
     } catch (e) {
       console.warn(`[dashboard] project state migration failed for "${p.name}": ${e.message}`);
     }
@@ -2300,6 +2310,50 @@ function updateSession(store, key, sessionId, existing) {
   }
 }
 
+// Pre-flight check: when the resolved runtime publishes a model catalog, reject
+// configs whose model isn't in it BEFORE spawning. Without this guard, Copilot
+// crashes mid-call ("Copilot rejected the requested model"), which empties the
+// stream, drops the doc-chat session, and surfaces as a confusing
+// "agent exited unexpectedly" banner with no actionable cause. We pull the
+// adapter via llm._resolveRuntimeFor + llm._resolveModelForRuntime so the same
+// resolution path llm.callLLM uses produces the same final model string.
+// Returns a structured error result ({code, errorClass, errorMessage}) on
+// rejection, or null when the call should proceed. Catalog-less runtimes
+// (Claude) always proceed — no opinion.
+async function _preflightModelCheck({ runtime: cliOverride, model: modelOverride, engineConfig }) {
+  let adapter;
+  try {
+    adapter = llm._resolveRuntimeFor({ cli: cliOverride, engineConfig });
+  } catch { return null; }
+  if (!adapter) return null;
+  const resolvedModel = llm._resolveModelForRuntime(adapter, { model: modelOverride, engineConfig });
+  if (!resolvedModel) return null;
+  if (!adapter.capabilities || adapter.capabilities.modelDiscovery !== true) return null;
+
+  let list;
+  try {
+    const md = require('./engine/model-discovery');
+    list = await md.getRuntimeModels(adapter.name, { config: { engine: engineConfig || {} } });
+  } catch { return null; }
+  if (!list || !Array.isArray(list.models) || list.models.length === 0) return null;
+
+  const known = new Set(list.models.map(m => m && (m.id || m.name)).filter(Boolean));
+  if (known.has(resolvedModel)) return null;
+
+  const sample = [...known].slice(0, 4).join(', ') + (known.size > 4 ? '…' : '');
+  return {
+    text: null,
+    code: 1,
+    errorClass: 'unknown-model',
+    errorMessage: `Configured model "${resolvedModel}" is not valid for runtime "${adapter.name}" (known: ${sample}). Update engine.ccModel or engine.defaultModel.`,
+    runtime: adapter.name,
+    sessionId: null,
+    usage: null,
+    stderr: '',
+    toolUses: [],
+  };
+}
+
 /**
  * Core LLM call — shared by CC panel and doc modals.
  * @param {string} message - User message
@@ -2316,6 +2370,13 @@ async function ccCall(message, { store = 'cc', sessionKey, extraContext, label =
   if (!maxTurns) maxTurns = CONFIG.engine?.ccMaxTurns || shared.ENGINE_DEFAULTS.ccMaxTurns;
   if (!model) model = CONFIG.engine?.ccModel || shared.ENGINE_DEFAULTS.ccModel;
   const ccEffort = CONFIG.engine?.ccEffort || shared.ENGINE_DEFAULTS.ccEffort;
+
+  const preflight = await _preflightModelCheck({ model, engineConfig: CONFIG.engine });
+  if (preflight) {
+    console.warn(`[${label}] Pre-flight rejected: ${preflight.errorMessage}`);
+    return preflight;
+  }
+
   const existing = resolveSession(store, sessionKey);
   let sessionId = existing ? existing.sessionId : null;
 
@@ -2405,6 +2466,13 @@ async function ccCallStreaming(message, { store = 'cc', sessionKey, extraContext
   if (!maxTurns) maxTurns = CONFIG.engine?.ccMaxTurns || shared.ENGINE_DEFAULTS.ccMaxTurns;
   if (!model) model = CONFIG.engine?.ccModel || shared.ENGINE_DEFAULTS.ccModel;
   const ccEffort = CONFIG.engine?.ccEffort || shared.ENGINE_DEFAULTS.ccEffort;
+
+  const preflight = await _preflightModelCheck({ model, engineConfig: CONFIG.engine });
+  if (preflight) {
+    console.warn(`[${label}] Pre-flight rejected: ${preflight.errorMessage}`);
+    return preflight;
+  }
+
   const existing = resolveSession(store, sessionKey);
   let sessionId = existing ? existing.sessionId : null;
 
@@ -2574,6 +2642,7 @@ function _docChatErrorMessage(errorClass, sessionPreserved = false, toolUses = [
   if (errorClass === 'context-limit') return 'Session context is too long. Click "Clear" to start a fresh conversation.' + toolHint;
   if (errorClass === 'budget-exceeded') return (errorMessage || 'Runtime budget exceeded — check your account or quota.') + toolHint;
   if (errorClass === 'crash') return (errorMessage || 'Runtime crashed unexpectedly. Try again.') + toolHint;
+  if (errorClass === 'unknown-model') return (errorMessage || 'Configured model is not valid for the active runtime. Update engine.ccModel or engine.defaultModel.') + toolHint;
   if (sessionPreserved) return 'Temporary connection issue — your conversation is intact, send your message again.' + toolHint;
   if (tools.length > 0) return 'The agent stopped responding before producing a final answer.' + toolHint;
   return 'Failed to process request. Try again.';
@@ -3161,7 +3230,11 @@ const server = http.createServer(async (req, res) => {
 
       const config = queries.getConfig();
       const project = PROJECTS.find(p => {
-        const plan = safeJson(activePath) || safeJson(prdPath);
+        // safeJsonNoRestore — never resurrect an archived PRD's .backup
+        // sidecar during project resolution (W-mouptdh1000h9f39). The
+        // active-from-archive write above (mutateJsonFileLocked) already
+        // created activePath when needed.
+        const plan = safeJsonNoRestore(activePath) || safeJsonNoRestore(prdPath);
         return plan && p.name?.toLowerCase() === (plan.project || '').toLowerCase();
       }) || PROJECTS[0] || null;
 
@@ -3241,9 +3314,13 @@ const server = http.createServer(async (req, res) => {
         const prdFile = body.prdFile;
         if (!prdFile) return jsonReply(res, 404, { error: 'work item not found in any source' });
 
-        // Look up PRD item to create a new work item on-demand
+        // Look up PRD item to create a new work item on-demand.
+        // safeJsonNoRestore — PRDs are terminal artifacts; a stale .backup
+        // sidecar from an archived PRD must not resurrect the active PRD
+        // just because a user clicked retry on a stray work item
+        // (W-mouptdh1000h9f39).
         const prdPath = path.join(PRD_DIR, prdFile);
-        const plan = shared.safeJson(prdPath);
+        const plan = shared.safeJsonNoRestore(prdPath);
         if (!plan?.missing_features) return jsonReply(res, 404, { error: 'PRD file not found or invalid' });
         const prdItem = plan.missing_features.find(f => f.id === id);
         if (!prdItem) return jsonReply(res, 404, { error: 'PRD item not found in ' + prdFile });
@@ -7571,18 +7648,24 @@ if (require.main === module) {
     console.log(`  Projects:   ${PROJECTS.map(p => `${p.name} (${p.localPath})`).join(', ')}`);
     console.log(`\n  Auto-refreshes every 4s. Ctrl+C to stop.\n`);
 
-    const { exec } = require('child_process');
-    try {
-      if (process.platform === 'win32') {
-        exec(`start "" "http://localhost:${PORT}"`);
-      } else if (process.platform === 'darwin') {
-        exec(`open http://localhost:${PORT}`);
-      } else {
-        exec(`xdg-open http://localhost:${PORT}`);
+    // Auto-open the browser unless suppressed. `minions restart` and the
+    // upgrade path set MINIONS_NO_AUTO_OPEN=1 when the previous dashboard was
+    // already listening — the existing tab will SSE-reconnect, so a new tab
+    // would just be a duplicate.
+    if (!process.env.MINIONS_NO_AUTO_OPEN) {
+      const { exec } = require('child_process');
+      try {
+        if (process.platform === 'win32') {
+          exec(`start "" "http://localhost:${PORT}"`);
+        } else if (process.platform === 'darwin') {
+          exec(`open http://localhost:${PORT}`);
+        } else {
+          exec(`xdg-open http://localhost:${PORT}`);
+        }
+      } catch (e) {
+        console.log(`  Could not auto-open browser: ${e.message}`);
+        console.log(`  Please open http://localhost:${PORT} manually.`);
       }
-    } catch (e) {
-      console.log(`  Could not auto-open browser: ${e.message}`);
-      console.log(`  Please open http://localhost:${PORT} manually.`);
     }
 
     // ─── Engine Watchdog ─────────────────────────────────────────────────────

package/engine/cleanup.js

@@ -9,7 +9,7 @@ const shared = require('./shared');
 const queries = require('./queries');
 
 const { exec, execAsync, execSilent, log, ts, ENGINE_DEFAULTS } = shared;
-const { safeJson, safeWrite, safeReadDir, mutateCooldowns, mutateWorkItems, mutateJsonFileLocked, getProjects, projectWorkItemsPath, projectPrPath,
+const { safeJson, safeJsonNoRestore, safeWrite, safeReadDir, mutateCooldowns, mutateWorkItems, mutateJsonFileLocked, getProjects, projectWorkItemsPath, projectPrPath,
   sanitizeBranch, KB_CATEGORIES } = shared;
 const { getDispatch, getAgentStatus } = queries;
 
@@ -688,7 +688,10 @@ async function runCleanup(config, verbose = false) {
       const prdPath = path.join(PRD_DIR, pf);
       let migrated = 0;
       shared.withFileLock(`${prdPath}.lock`, () => {
-        const prd = safeJson(prdPath);
+        // safeJsonNoRestore: PRDs are terminal artifacts. If the active PRD
+        // was archived but a stale .backup sidecar remains, never resurrect
+        // it during a routine migration sweep (W-mouptdh1000h9f39).
+        const prd = safeJsonNoRestore(prdPath);
         if (!prd?.missing_features) return;
         for (const feat of prd.missing_features) {
           if (LEGACY_DONE_ALIASES.has(feat.status)) {
@@ -725,7 +728,9 @@ async function runCleanup(config, verbose = false) {
     catch { orphanPrdEntries = []; }
     for (const pf of orphanPrdEntries) {
       const prdPath = path.join(PRD_DIR, pf);
-      const peek = safeJson(prdPath);
+      // safeJsonNoRestore — peek must not auto-restore archived PRDs
+      // from a stale .backup sidecar (W-mouptdh1000h9f39).
+      const peek = safeJsonNoRestore(prdPath);
       if (!peek?.missing_features) continue;
       let reset = 0;
       mutateJsonFileLocked(prdPath, (prd) => {

package/engine/cli.js

@@ -431,8 +431,16 @@ const commands = {
       } else {
         try {
           const state = shared.ensureProjectStateFiles(p, { migrateLegacy: true, removeLegacy: true });
-          if (state.migrated.length > 0 || state.removedLegacy.length > 0) {
-            e.log('info', `Migrated project state for "${p.name}" to projects/${p.name}`);
+          if (state.migrated.length > 0 || state.removedLegacy.length > 0 || state.legacyDirRemoved) {
+            const parts = [];
+            if (state.migrated.length > 0) parts.push(`merged ${state.migrated.join(', ')}`);
+            if (state.removedLegacy.length > 0) parts.push(`removed ${state.removedLegacy.join(', ')}`);
+            if (state.legacyDirRemoved) parts.push(`removed legacy .minions dir`);
+            e.log('info', `Migrated project state for "${p.name}" → projects/${p.name} (${parts.join('; ')})`);
+          }
+          if (state.legacyDirRemoveError) {
+            e.log('warn', `Failed to remove legacy .minions dir for "${p.name}": ${state.legacyDirRemoveError}`);
+            console.log(`  WARNING: legacy .minions dir for "${p.name}" could not be removed: ${state.legacyDirRemoveError}`);
           }
         } catch (err) {
           e.log('warn', `Project state migration failed for "${p.name}": ${err.message}`);

package/engine/copilot-models.json

@@ -1,5 +1,5 @@
 {
   "runtime": "copilot",
   "models": null,
-  "cachedAt": "2026-05-07T01:23:41.823Z"
+  "cachedAt": "2026-05-07T03:30:56.716Z"
 }

package/engine/lifecycle.js

@@ -7,7 +7,7 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const shared = require('./shared');
-const { safeRead, safeJson, safeWrite, mutateJsonFileLocked, mutateWorkItems, execSilent, execAsync, projectPrPath, getPrLinks,
+const { safeRead, safeJson, safeJsonNoRestore, safeWrite, mutateJsonFileLocked, mutateWorkItems, execSilent, execAsync, projectPrPath, getPrLinks,
   log, ts, dateStamp, WI_STATUS, DONE_STATUSES, PLAN_TERMINAL_STATUSES, WORK_TYPE, PLAN_STATUS, PRD_ITEM_STATUS, PR_STATUS, DISPATCH_RESULT,
   ENGINE_DEFAULTS, DEFAULT_AGENT_METRICS, FAILURE_CLASS } = shared;
 const { trackEngineUsage } = require('./llm');
@@ -24,7 +24,11 @@ function checkPlanCompletion(meta, config) {
   const planFile = meta.item?.sourcePlan;
   if (!planFile) return;
   const planPath = path.join(PRD_DIR, planFile);
-  const plan = safeJson(planPath);
+  // Use safeJsonNoRestore — if the active PRD has been archived, the .backup
+  // sidecar may still be sitting in prd/. safeJson would auto-restore it and
+  // resurrect the archived PRD as active (W-mouptdh1000h9f39). PRDs are
+  // terminal artifacts; missing primary means "gone", not "needs recovery".
+  const plan = safeJsonNoRestore(planPath);
   if (!plan?.missing_features) return;
   if (plan.status === PLAN_STATUS.COMPLETED) {
     if (plan._completionNotified) return;
@@ -580,7 +584,9 @@ function syncPrdItemStatus(itemId, status, sourcePlan) {
     for (const pf of files) {
       const fpath = path.join(prdDir, pf);
       // Lock-free peek: most PRDs won't contain the ID, so skip the lock cost.
-      const plan = safeJson(fpath);
+      // safeJsonNoRestore so an archived PRD's .backup sidecar can't resurrect
+      // the active PRD just because a done WI still references it.
+      const plan = safeJsonNoRestore(fpath);
       const feature = plan?.missing_features?.find(f => f.id === itemId);
       if (!feature || feature.status === status) continue;
       let updated = false;

package/engine/pipeline.js

@@ -8,7 +8,7 @@ const fs = require('fs');
 const path = require('path');
 const shared = require('./shared');
 const queries = require('./queries');
-const { safeJson, safeWrite, safeRead, safeReadDir, uid, log, ts, dateStamp, mutateJsonFileLocked, mutateWorkItems, slugify, formatTranscriptEntry, WI_STATUS, WORK_TYPE, PLAN_STATUS, PR_STATUS, PIPELINE_STATUS, STAGE_TYPE, MEETING_STATUS, ENGINE_DEFAULTS, MINIONS_DIR } = shared;
+const { safeJson, safeJsonNoRestore, safeWrite, safeRead, safeReadDir, uid, log, ts, dateStamp, mutateJsonFileLocked, mutateWorkItems, slugify, formatTranscriptEntry, WI_STATUS, WORK_TYPE, PLAN_STATUS, PR_STATUS, PIPELINE_STATUS, STAGE_TYPE, MEETING_STATUS, ENGINE_DEFAULTS, MINIONS_DIR } = shared;
 const routing = require('./routing');
 const http = require('http');
 const { parseCronExpr, shouldRunNow } = require('./scheduler');
@@ -388,7 +388,9 @@ function _findExistingPrdForPlan(planFile, prdDir) {
   if (!fs.existsSync(prdDir)) return null;
   const prdFiles = safeReadDir(prdDir).filter(f => f.endsWith('.json'));
   for (const pf of prdFiles) {
-    const prd = safeJson(path.join(prdDir, pf));
+    // safeJsonNoRestore: PRDs are terminal artifacts — never restore archived
+    // PRDs from a stale .backup sidecar (W-mouptdh1000h9f39).
+    const prd = safeJsonNoRestore(path.join(prdDir, pf));
     if (prd?.source_plan === planFile) return pf;
   }
   return null;
@@ -709,7 +711,8 @@ function isStageComplete(stage, stageState, run, config) {
       const prdFiles = fs.existsSync(prdDir) ? safeReadDir(prdDir).filter(f => f.endsWith('.json')) : [];
       for (const planFile of plans) {
         for (const pf of prdFiles) {
-          const prd = safeJson(path.join(prdDir, pf));
+          // safeJsonNoRestore — see _findExistingPrdForPlan above (W-mouptdh1000h9f39).
+          const prd = safeJsonNoRestore(path.join(prdDir, pf));
           if (prd?.source_plan === planFile && !(artifacts.prds || []).includes(pf) && !discoveredPrds.includes(pf)) {
             discoveredPrds.push(pf);
           }

package/engine/preflight.js

@@ -109,8 +109,13 @@ function _distinctRuntimes(config) {
  * Try to resolve a runtime's binary via the registry. Returns a preflight
  * result entry — never throws. Unknown-runtime errors collapse to a single
  * warn entry so the rest of the loop keeps running.
+ *
+ * When `optional` is true, a missing binary surfaces as `ok: 'warn'` instead
+ * of `ok: false`. Used for runtimes the user hasn't configured but that are
+ * registered in the adapter registry — surfacing availability without making
+ * the check itself fail when the user only uses one runtime.
  */
-function _checkRuntimeBinary(runtimeName) {
+function _checkRuntimeBinary(runtimeName, { optional = false } = {}) {
   let adapter;
   try {
     adapter = require('./runtimes').resolveRuntime(runtimeName);
@@ -139,8 +144,10 @@ function _checkRuntimeBinary(runtimeName) {
     : `${runtimeName} CLI binary not found on PATH`;
   return {
     name: `Runtime: ${runtimeName}`,
-    ok: false,
-    message: `not found — ${hint}`,
+    ok: optional ? 'warn' : false,
+    message: optional
+      ? `not installed (optional) — ${hint}`
+      : `not found — ${hint}`,
   };
 }
 
@@ -172,6 +179,11 @@ function _warmModelCache(runtimeName, config) {
  *   - warnOnly: if true, missing items don't cause passed=false (for init)
  *   - verbose: include extra detail in messages
  *   - config:  fleet config for runtime checks + runtime-config warnings
+ *   - includeAllRegistered: when true, every adapter registered in the runtime
+ *                           registry is probed even if the user hasn't
+ *                           configured it. Configured runtimes still fail
+ *                           critically when missing; non-configured ones
+ *                           surface as warn-level "not installed (optional)".
  */
 function runPreflight(opts = {}) {
   const results = [];
@@ -198,10 +210,20 @@ function runPreflight(opts = {}) {
 
   // 3. Per-runtime binary check (P-9e8a3f1d). Legacy single-runtime callers
   //    (no config passed) still get exactly one entry — for `claude` — so the
-  //    historical "3 results" shape is preserved.
-  const runtimes = _distinctRuntimes(opts.config);
+  //    historical "3 results" shape is preserved. With includeAllRegistered,
+  //    add every registered adapter (e.g. copilot) as an optional probe so the
+  //    CLI surfaces availability without forcing the user to configure it.
+  const configuredRuntimes = _distinctRuntimes(opts.config);
+  let runtimes = configuredRuntimes;
+  if (opts.includeAllRegistered) {
+    let registered = [];
+    try { registered = require('./runtimes').listRuntimes(); }
+    catch { /* registry may be missing during partial installs */ }
+    runtimes = Array.from(new Set([...configuredRuntimes, ...registered])).sort();
+  }
+  const configuredSet = new Set(configuredRuntimes);
   for (const runtimeName of runtimes) {
-    const r = _checkRuntimeBinary(runtimeName);
+    const r = _checkRuntimeBinary(runtimeName, { optional: !configuredSet.has(runtimeName) });
     if (r.ok === false) allOk = false;
     results.push(r);
     // Warm the model cache in the background — silent no-op when the

package/engine/runtimes/claude.js

@@ -294,7 +294,40 @@ function getSkillWriteTargets({ homeDir = os.homedir(), project = null } = {}) {
 // engine.js:1195 fires. See W-mot9fwya000d09cb.
 const RUNTIME_NAME = 'claude';
 
-function getResumeSessionId({ agentId, branchName, agentsDir, maxAgeMs = 2 * 60 * 60 * 1000, logger = console } = {}) {
+/**
+ * Compute the directory Claude CLI uses to persist a project's conversation
+ * jsonl files: `~/.claude/projects/<dashed-cwd>/`. The hash algorithm replaces
+ * any character outside `[a-zA-Z0-9-]` with `-` (verified empirically against
+ * existing project dirs on multiple platforms — preserves dashes, dashes out
+ * separators, drive letters, dots, and spaces).
+ */
+function _claudeProjectHashDir(cwd, homeDir) {
+  if (!cwd || !homeDir) return null;
+  const dashed = String(cwd).replace(/[^a-zA-Z0-9-]/g, '-');
+  return path.join(homeDir, '.claude', 'projects', dashed);
+}
+
+/**
+ * Pre-spawn resume lookup. Returns the session ID to pass to `--resume`, or
+ * null when the cached session is unusable (stale by age, runtime mismatch,
+ * or — see W-mouugzow00068741 — references a UUID Claude never persisted to
+ * its on-disk conversation log).
+ *
+ * Stale-resume-target case (the W-mouugzow00068741 bug): the engine writes
+ * `session.json` as soon as Claude emits its first session_id, but Claude only
+ * persists the conversation to `~/.claude/projects/<hash>/<uuid>.jsonl` on a
+ * stable checkpoint. If the agent dies before checkpoint, session.json holds
+ * a UUID that no jsonl file backs. On retry, `--resume <uuid>` fails with
+ * "No conversation found", the retry burns instantly, and (because the failed
+ * retry never reaches saveSession) session.json never gets overwritten — so
+ * every subsequent retry hits the same dead UUID until the 2h TTL kicks in.
+ *
+ * Fix: when `cwd` is provided, probe for the jsonl. If it's absent, treat the
+ * session as never-persisted, clear session.json, and return null so the
+ * caller spawns fresh. The probe is opt-in (cwd-gated) — older callers that
+ * don't pass cwd keep the pre-fix behavior unchanged.
+ */
+function getResumeSessionId({ agentId, branchName, agentsDir, cwd = null, homeDir = os.homedir(), maxAgeMs = 2 * 60 * 60 * 1000, logger = console } = {}) {
   if (!agentId || agentId.startsWith('temp-') || !agentsDir) return null;
   const sessionPath = path.join(agentsDir, agentId, 'session.json');
   try {
@@ -314,6 +347,23 @@ function getResumeSessionId({ agentId, branchName, agentsDir, maxAgeMs = 2 * 60
       return null;
     }
 
+    // Stale-resume-target invalidation (W-mouugzow00068741). Claude only writes
+    // the jsonl on stable checkpoint; a session ID stamped before checkpoint
+    // dies with the agent. Probe for the jsonl and clear session.json when
+    // it's missing so the next dispatch spawns fresh instead of looping
+    // through `--resume <dead-uuid>` failures.
+    if (cwd) {
+      const projectDir = _claudeProjectHashDir(cwd, homeDir);
+      const jsonlPath = projectDir ? path.join(projectDir, `${sessionFile.sessionId}.jsonl`) : null;
+      if (jsonlPath && !fs.existsSync(jsonlPath)) {
+        if (logger && typeof logger.info === 'function') {
+          logger.info(`Skipping resume for ${agentId}: no conversation jsonl at ${jsonlPath} (stale resume target — agent died before checkpoint) — clearing session.json`);
+        }
+        try { fs.unlinkSync(sessionPath); } catch {}
+        return null;
+      }
+    }
+
     const sessionAge = Date.now() - new Date(sessionFile.savedAt).getTime();
     const sameBranch = branchName && sessionFile.branch && sessionFile.branch === branchName;
     if (sessionAge < maxAgeMs && sameBranch) {

package/engine/runtimes/copilot.js

@@ -158,6 +158,15 @@ function resolveBinary({ env = process.env } = {}) {
 // adapter maps those aliases to Copilot model IDs while passing all other input
 // through verbatim. The capability remains false: Copilot CLI does not accept
 // these aliases directly.
+//
+// `resolveModel` ALSO normalizes Anthropic-style hyphenated IDs that callers may
+// have inherited from a Claude-runtime config. `claude-opus-4-7` and
+// `claude-opus-4-7-1m` are passed through verbatim by Claude (which has no
+// catalog), so when a user runs `minions config set-cli copilot` without
+// updating `defaultModel` the hyphenated ID lands in Copilot's --model arg and
+// the CLI rejects it. We translate the inter-version hyphen to a dot and fall
+// through to catalog matching when one is cached, which is the common case for
+// installs that have run model discovery at least once.
 
 const _MINIONS_MODEL_ALIASES = {
   haiku: 'claude-haiku-4.5',
@@ -165,12 +174,76 @@ const _MINIONS_MODEL_ALIASES = {
   opus: 'claude-opus-4.5',
 };
 
+// Read the cached catalog (engine/copilot-models.json) and return a Set of IDs.
+// Returns null when the cache is missing/empty so callers can fall through to
+// passthrough behavior — never throws, never reaches the network.
+function _readCatalogIds() {
+  const cached = _safeJson(MODELS_CACHE);
+  const list = cached && Array.isArray(cached.models) ? cached.models : null;
+  if (!list || list.length === 0) return null;
+  const ids = new Set();
+  for (const m of list) {
+    const id = m && (m.id || m.name);
+    if (id) ids.add(String(id));
+  }
+  return ids.size > 0 ? ids : null;
+}
+
+// Translate Anthropic-style hyphenated `claude-(family)-X-Y[-suffix]` to
+// Copilot's dot form `claude-(family)-X.Y[-suffix]`. Returns the transformed
+// string (or the original when the pattern doesn't match) — a separate catalog
+// match check then decides whether the result is usable.
+function _hyphenToDotVersion(s) {
+  return s.replace(/^(claude-(?:opus|sonnet|haiku))-(\d+)-(\d+)(.*)$/i, '$1-$2.$3$4');
+}
+
 function resolveModel(input) {
   if (input == null || input === '') return undefined;
   const s = String(input);
   const mapped = _MINIONS_MODEL_ALIASES[s.toLowerCase()];
   if (mapped) return mapped;
-  return s;
+
+  // Call through module.exports so tests can monkey-patch _readCatalogIds
+  // without writing to the live engine/copilot-models.json cache. Same
+  // runtime behavior as a direct call when the export hasn't been replaced.
+  const catalog = module.exports._readCatalogIds();
+  if (catalog && catalog.has(s)) return s;
+
+  const dotted = _hyphenToDotVersion(s);
+  if (dotted !== s && catalog) {
+    if (catalog.has(dotted)) return dotted;
+    // `-1m` Anthropic suffix maps to Copilot's `-1m-internal` variant when
+    // present in the catalog. Other suffixes pass through unchanged.
+    if (/-1m$/i.test(dotted) && catalog.has(`${dotted}-internal`)) {
+      return `${dotted}-internal`;
+    }
+  }
+  // No catalog (test env, no token) OR no match — passthrough so the original
+  // input still reaches the CLI for an authoritative reject. Hyphen→dot is
+  // applied even without a catalog, since the dot form is universally what
+  // Copilot expects and the alternative is a guaranteed reject.
+  return dotted !== s && !catalog ? dotted : s;
+}
+
+// Heuristic: does `model` look like a Copilot-namespace identifier? Mirrors
+// engine/runtimes/claude.js#modelLooksFamiliar so engine/cli.js#_modelLooksIncompatible
+// can warn when a fleet/CC switch strands an incompatible model. Accepts the
+// three Minions short aliases (`sonnet`/`opus`/`haiku`) since the adapter
+// translates them to valid Copilot IDs at argv-build time. Returning false
+// means "this looks wrong for Copilot" — anything outside Anthropic / OpenAI /
+// catalog membership is flagged.
+function modelLooksFamiliar(model) {
+  if (!model) return true;
+  const m = String(model).toLowerCase();
+  if (m === 'sonnet' || m === 'opus' || m === 'haiku') return true;
+  if (m.startsWith('claude-')) return true;
+  if (m.startsWith('gpt-')) return true;
+  if (m.startsWith('o3') || m.startsWith('o4')) return true;
+  // Mirror resolveModel: route through module.exports so test monkey-patching
+  // of _readCatalogIds reaches this call site too.
+  const catalog = module.exports._readCatalogIds();
+  if (catalog && catalog.has(m)) return true;
+  return false;
 }
 
 /**
@@ -872,6 +945,7 @@ module.exports = {
   usesSystemPromptFile,
   classifyFailure,
   resolveModel,
+  modelLooksFamiliar,
   parseOutput,
   parseStreamChunk,
   parseError,
@@ -881,5 +955,7 @@ module.exports = {
   _MINIONS_MODEL_ALIASES,
   _mapEffort,
   _copilotAssistantMessageHasTools,
+  _readCatalogIds,
+  _hyphenToDotVersion,
   KNOWN_EVENT_TYPES,
 };

package/engine/shared.js

@@ -283,6 +283,40 @@ function safeJsonObj(p) { return safeJson(p) || {}; }
 /** Null-safe safeJson wrapper — returns [] when file is missing/corrupt. */
 function safeJsonArr(p) { return safeJson(p) || []; }
 
+/**
+ * Sibling of safeJson for terminal-artifact reads (PRDs in `prd/`, archived
+ * plans, anything where a missing primary should NOT auto-restore from a
+ * stale `.backup` sidecar). Returns the parsed JSON on success, or null when
+ * the primary is missing or unparseable.
+ *
+ * Why a separate primitive: safeJson's restore-on-miss is correct for live
+ * state files (work-items.json, dispatch.json, pull-requests.json, etc.) but
+ * actively harmful for terminal artifacts. Archived PRDs leave a `.backup`
+ * sidecar in `prd/`; if any caller reads the active path with safeJson, the
+ * .backup is silently restored and the dashboard sees a phantom "active" PRD
+ * (W-mouptdh1000h9f39). PRDs are end-state — no automatic resurrection.
+ *
+ * Parse errors are logged so silent corruption still surfaces (mirrors
+ * safeJson's contract). Read errors other than ENOENT are also logged.
+ */
+function safeJsonNoRestore(p) {
+  let raw;
+  try {
+    raw = fs.readFileSync(p, 'utf8');
+  } catch (e) {
+    if (e && e.code !== 'ENOENT') {
+      console.warn(`[safeJsonNoRestore] read failed for ${path.basename(p)}: ${e.message}`);
+    }
+    return null;
+  }
+  try {
+    return JSON.parse(raw);
+  } catch (parseErr) {
+    console.error(`[safeJsonNoRestore] parse failure for ${path.basename(p)}: ${parseErr.message}`);
+    return null;
+  }
+}
+
 /**
  * Monotonic counter for generating unique temp file names within this process.
  * Assumes single-thread execution (no worker_threads). If worker_threads are
@@ -1614,12 +1648,15 @@ function sameResolvedPath(a, b) {
 
 function removeLegacyProjectStateDir(project) {
   const dir = legacyProjectStateDir(project);
-  if (!dir) return false;
-  if (sameResolvedPath(dir, MINIONS_DIR)) return false;
+  if (!dir) return { removed: false, error: null };
+  if (sameResolvedPath(dir, MINIONS_DIR)) return { removed: false, error: null };
+  if (!fs.existsSync(dir)) return { removed: false, error: null };
   try {
     fs.rmSync(dir, { recursive: true, force: true });
-    return true;
-  } catch { return false; }
+    return { removed: true, error: null };
+  } catch (err) {
+    return { removed: false, error: err && err.message ? err.message : String(err) };
+  }
 }
 
 function ensureProjectStateFiles(project, options = {}) {
@@ -1629,7 +1666,7 @@ function ensureProjectStateFiles(project, options = {}) {
     { name: 'pull-requests.json', centralPath: projectPrPath(project) },
     { name: 'work-items.json', centralPath: projectWorkItemsPath(project) },
   ];
-  const result = { created: [], migrated: [], removedLegacy: [], legacyDirRemoved: false };
+  const result = { created: [], migrated: [], removedLegacy: [], legacyDirRemoved: false, legacyDirRemoveError: null };
 
   projectStateDirEnsure(project);
   for (const file of files) {
@@ -1662,7 +1699,11 @@ function ensureProjectStateFiles(project, options = {}) {
     }
   }
 
-  if (removeLegacy) result.legacyDirRemoved = removeLegacyProjectStateDir(project);
+  if (removeLegacy) {
+    const res = removeLegacyProjectStateDir(project);
+    result.legacyDirRemoved = res.removed;
+    result.legacyDirRemoveError = res.error;
+  }
   return result;
 }
 
@@ -2963,7 +3004,7 @@ module.exports = {
   log,
   safeRead,
   safeReadDir,
-  safeJson, safeJsonObj, safeJsonArr,
+  safeJson, safeJsonObj, safeJsonArr, safeJsonNoRestore,
   safeWrite,
   safeUnlink,
   neutralizeJsonBackupSidecar,

package/engine.js

@@ -91,6 +91,7 @@ const { getProjects, projectRoot, projectStateDir, projectWorkItemsPath, project
 // ─── Utilities ──────────────────────────────────────────────────────────────
 
 const safeJson = shared.safeJson;
+const safeJsonNoRestore = shared.safeJsonNoRestore;
 const safeRead = shared.safeRead;
 const safeWrite = shared.safeWrite;
 const safeUnlink = shared.safeUnlink;
@@ -430,6 +431,45 @@ function resolveDependencyBranches(depIds, sourcePlan, project, config) {
   return results;
 }
 
+/**
+ * Sync an existing worktree from origin on reuse: probe with
+ * `git ls-remote --exit-code --heads origin <branch>` first so that locally
+ * created branches whose first attempt died before push (agent timeout / orphan
+ * retry) skip fetch+pull silently instead of emitting a warn-level
+ * "couldn't find remote ref" pair on every reuse.
+ *
+ * Genuine fetch/pull failures (network, auth, conflict) still surface as warn.
+ * Never throws — the dispatch must continue regardless of sync outcome.
+ *
+ * Exported for testing; production callers ignore the return value.
+ *
+ * @returns {Promise<{skipped: boolean, reason?: string}>}
+ */
+async function syncReusedWorktree(rootDir, worktreePath, branchName, gitOpts = {}) {
+  // ls-remote --exit-code returns 2 when no matching refs are found on the
+  // remote. The probe only lists refs (no object transfer), so it's cheap
+  // even on slow links.
+  let onOrigin = true;
+  try {
+    await execAsync(
+      `git ls-remote --exit-code --heads origin "${branchName}"`,
+      { ...gitOpts, cwd: rootDir, timeout: 5000 },
+    );
+  } catch (e) {
+    // Exit code 2 = ref not on remote (the noisy case we want to silence).
+    // Any other failure (network, auth, timeout) we let pass through so the
+    // subsequent fetch surfaces a real warn with its native error message.
+    if (e && e.code === 2) onOrigin = false;
+  }
+  if (!onOrigin) {
+    log('info', `Branch ${branchName} not on origin yet — first push pending; skipping fetch/pull`);
+    return { skipped: true, reason: 'no-upstream' };
+  }
+  try { await execAsync(`git fetch origin "${branchName}"`, { ...gitOpts, cwd: rootDir }); } catch (e) { log('warn', 'git: ' + e.message); }
+  try { await execAsync(`git pull origin "${branchName}"`, { ...gitOpts, cwd: worktreePath }); } catch (e) { log('warn', 'git: ' + e.message); }
+  return { skipped: false };
+}
+
 // Find an existing worktree already checked out on a given branch
 async function findExistingWorktree(repoDir, branchName) {
   try {
@@ -591,8 +631,10 @@ async function spawnAgent(dispatchItem, config) {
     if (existingWt) {
       worktreePath = existingWt;
       log('info', `Reusing existing worktree for ${branchName}: ${existingWt}`);
-      try { await execAsync(`git fetch origin "${branchName}"`, { ..._gitOpts, cwd: rootDir }); } catch (e) { log('warn', 'git: ' + e.message); }
-      try { await execAsync(`git pull origin "${branchName}"`, { ..._gitOpts, cwd: existingWt }); } catch (e) { log('warn', 'git: ' + e.message); }
+      // Probe origin first — locally-created branches that were never pushed
+      // (orphan/timeout retry before first push) would otherwise emit a
+      // "couldn't find remote ref" warn pair on every reuse.
+      await syncReusedWorktree(rootDir, existingWt, branchName, _gitOpts);
     } else if (['meeting', 'ask', 'explore', 'plan-to-prd', 'plan'].includes(type)) {
       // Read-only tasks — no worktree needed, run in rootDir
       log('info', `${type}: read-only task, no worktree needed — running in rootDir`);
@@ -1015,6 +1057,10 @@ async function spawnAgent(dispatchItem, config) {
       agentId,
       branchName,
       agentsDir: AGENTS_DIR,
+      // Pass the working directory so the Claude adapter can probe for the
+      // conversation jsonl and avoid `--resume <dead-uuid>` retry loops when
+      // the agent died before checkpoint (W-mouugzow00068741).
+      cwd,
       logger: _runtimeLogger(),
     });
   }
@@ -1697,9 +1743,12 @@ function areDependenciesMet(item, config) {
   for (const depId of deps) {
     const depItem = allWorkItems.find(w => w.id === depId);
     if (!depItem) {
-      // Fallback: check PRD JSON — plan-to-prd agents may pre-set items to done
+      // Fallback: check PRD JSON — plan-to-prd agents may pre-set items to done.
+      // safeJsonNoRestore — if the PRD has been archived, treat the dep as
+      // unmet rather than resurrecting the active PRD from .backup
+      // (W-mouptdh1000h9f39).
       try {
-        const plan = safeJson(path.join(PRD_DIR, sourcePlan));
+        const plan = safeJsonNoRestore(path.join(PRD_DIR, sourcePlan));
         const prdItem = (plan?.missing_features || []).find(f => f.id === depId);
         if (prdItem && PRD_MET_STATUSES.has(prdItem.status)) continue; // PRD says done — treat as met
       } catch (e) { log('warn', 'check PRD dep status: ' + e.message); }
@@ -1951,7 +2000,10 @@ function materializePlansAsWorkItems(config) {
   const SEQUENTIAL_ID_RE = /^P-?\d+$/;
 
   for (const file of planFiles) {
-    let plan = safeJson(path.join(PRD_DIR, file));
+    // safeJsonNoRestore — if a PRD was archived between readdir and this
+    // read, do not auto-resurrect it from a stale .backup sidecar
+    // (W-mouptdh1000h9f39).
+    let plan = safeJsonNoRestore(path.join(PRD_DIR, file));
     if (!plan?.missing_features) continue;
 
     // ID collision prevention: remap sequential IDs (P-001, P-002) to globally unique P-<uid> IDs.
@@ -3771,6 +3823,39 @@ function discoverCentralWorkItems(config) {
 }
 
 
+/**
+ * Sweep stale `.backup` sidecars in `prd/` whose archived counterpart already
+ * lives in `prd/archive/<name>.json` and the active `prd/<name>.json` is
+ * absent. Pre-neutralize-era archives left these sidecars behind; without this
+ * sweep, any caller that touched `prd/<name>.json` with the restore-enabled
+ * `safeJson` would resurrect the archived PRD as active (W-mouptdh1000h9f39).
+ *
+ * Idempotent and best-effort: readdir / existsSync / unlink failures are
+ * swallowed so a single weird filesystem state never blocks the discovery
+ * tick. Returns the number of sidecars purged (for tests / logging).
+ */
+function sweepStaleArchivedPrdBackups(prdDir, prdArchiveDir) {
+  let purged = 0;
+  if (!fs.existsSync(prdArchiveDir)) return purged;
+  let archivedNames;
+  try { archivedNames = fs.readdirSync(prdArchiveDir).filter(f => f.endsWith('.json')); }
+  catch { return purged; }
+  for (const f of archivedNames) {
+    const activePath = path.join(prdDir, f);
+    const backupPath = activePath + '.backup';
+    // Active PRD wins — the dedicated ghost-PRD purge in discoverWork handles
+    // the case where both active.json and active.json.backup are present.
+    if (fs.existsSync(activePath)) continue;
+    if (!fs.existsSync(backupPath)) continue;
+    try {
+      fs.unlinkSync(backupPath);
+      purged++;
+      log('info', `Purged stale .backup sidecar for archived PRD: ${f}`);
+    } catch { /* best-effort */ }
+  }
+  return purged;
+}
+
 /**
  * Run all work discovery sources and queue new items
  * Priority: fix (0) > ask (1) > review (1) > implement (2) > work-items (3) > central (4)
@@ -3865,17 +3950,29 @@ async function discoverWork(config) {
     try {
       const lifecycle = require('./engine/lifecycle');
       const prdDir = path.join(MINIONS_DIR, 'prd');
+      const prdArchiveDir = path.join(prdDir, 'archive');
       if (fs.existsSync(prdDir)) {
+        // Pass 1 — Burn the landmine: stale .backup sidecars whose archived
+        // counterpart already lives in prd/archive/ but no active prd/<f>.json.
+        // Without this, any future safeJson(prd/<f>.json) (or stray legacy
+        // call) would auto-restore the .backup and resurrect the archived PRD
+        // (W-mouptdh1000h9f39). Idempotent and fast — readdir + existsSync.
+        sweepStaleArchivedPrdBackups(prdDir, prdArchiveDir);
+
+        // Pass 2 — Existing orphan ghost-PRD purge + completion sweep.
         for (const f of fs.readdirSync(prdDir).filter(f => f.endsWith('.json'))) {
           if (completedPlanCache.has(f)) continue;
-          if (fs.existsSync(path.join(prdDir, 'archive', f))) {
+          if (fs.existsSync(path.join(prdArchiveDir, f))) {
             // Orphaned backup restore — plan is already archived. Purge the ghost copy.
             try { fs.unlinkSync(path.join(prdDir, f)); } catch { }
             try { fs.unlinkSync(path.join(prdDir, f + '.backup')); } catch { }
             completedPlanCache.add(f);
             continue;
           }
-          const plan = safeJson(path.join(prdDir, f));
+          // safeJsonNoRestore — defense in depth: if the file vanished between
+          // readdir and read (e.g. concurrent archive), do not resurrect it
+          // from a stale .backup sidecar (W-mouptdh1000h9f39).
+          const plan = safeJsonNoRestore(path.join(prdDir, f));
           if (!plan?.missing_features || plan.status === 'completed') {
             if (plan?.status === 'completed') completedPlanCache.add(f);
             continue;
@@ -4605,11 +4702,12 @@ module.exports = {
   // Discovery
   discoverWork, discoverFromPrs, discoverFromWorkItems, discoverCentralWorkItems,
   materializePlansAsWorkItems,
+  sweepStaleArchivedPrdBackups, // exported for testing
 
   // Shared helpers (used by lifecycle.js and tests)
   reconcileItemsWithPrs, detectDependencyCycles,
   parseConflictFiles, pruneAncestorDeps, preflightMergeSimulation, // exported for testing
-  isWorktreeRetryableError, removeStaleIndexLock, // exported for testing
+  isWorktreeRetryableError, removeStaleIndexLock, syncReusedWorktree, // exported for testing
   _maxTurnsForType, buildProjectContext, normalizeAc, _buildAgentSpawnFlags, _classifyAgentFailure, // exported for testing
 
   // Playbooks

package/minions.js

@@ -435,7 +435,7 @@ async function initMinions({ skipScan = false, scanRoot, scanDepth } = {}) {
   }
 
   if (skipScan) {
-    console.log('  Run "minions scan" or "minions add <dir>" to link projects.\n');
+    console.log('  Run "minions scan" or "minions add <dir>" to link projects.');
     rl.close();
   } else {
     // Offer to scan for repos (optional)

package/package.json

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