@yemi33/minions 0.1.1769 → 0.1.1771

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.1.1771 (2026-05-07)
+
+### Features
+- clean merged pr local branches (#2165)
+
+## 0.1.1770 (2026-05-07)
+
+### Fixes
+- open dashboard on update cold start
+- silence generated Claude defaults warning
+- drop TTL and turn-count cap so users can resume any time
+
 ## 0.1.1769 (2026-05-07)
 
 ### Fixes

package/bin/minions.js

@@ -29,6 +29,7 @@ const { spawn, spawnSync, execSync } = require('child_process');
 
 const PKG_ROOT = path.resolve(__dirname, '..');
 const DASH_PORT = 7331;
+const DASHBOARD_BROWSER_PRESENCE_MAX_AGE_MS = 45000;
 
 /** Returns PIDs (as strings) of processes LISTENING on `port`. Empty on no match
  *  or when the platform tool (netstat/findstr/lsof) is unavailable. */
@@ -60,6 +61,18 @@ function killByPort(port) {
 
 const isPortListening = (port) => getListeningPids(port).length > 0;
 
+function hasRecentDashboardBrowserTab(minionsHome, now = Date.now()) {
+  try {
+    const fp = path.join(minionsHome, 'engine', 'dashboard-browser.json');
+    const state = JSON.parse(fs.readFileSync(fp, 'utf8'));
+    const tabs = state && state.tabs && typeof state.tabs === 'object' ? state.tabs : {};
+    return Object.values(tabs).some(tab => {
+      const lastSeen = Number(tab && tab.lastSeen);
+      return Number.isFinite(lastSeen) && now - lastSeen <= DASHBOARD_BROWSER_PRESENCE_MAX_AGE_MS;
+    });
+  } catch { return false; }
+}
+
 /**
  * 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.
@@ -118,7 +131,7 @@ function killMinionsProcesses(patterns) {
 }
 
 /** Spawn a detached dashboard. When `suppressOpen` is true, the new dashboard
- *  skips its auto-open of the browser — the existing tab will SSE-reconnect. */
+ *  skips its auto-open of the browser — the existing tab will 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')], {
@@ -397,9 +410,11 @@ 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).
+  // Probe before kill so we suppress browser auto-open only when a browser tab
+  // was recently polling the dashboard. A bare/orphan dashboard process on the
+  // port is not enough; cold starts should still open the UI.
   const dashWasUp = isPortListening(DASH_PORT);
+  const suppressDashboardOpen = dashWasUp && hasRecentDashboardBrowserTab(MINIONS_HOME);
   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
@@ -415,7 +430,7 @@ function init() {
   engineProc.unref();
   console.log(`  Engine started (PID: ${engineProc.pid})`);
 
-  const dashProc = spawnDashboard(dashWasUp);
+  const dashProc = spawnDashboard(suppressDashboardOpen);
   console.log(`  Dashboard started (PID: ${dashProc.pid})`);
   console.log(`  Dashboard: http://localhost:${DASH_PORT}`);
 
@@ -670,9 +685,11 @@ 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).
+  // Probe before kill so we suppress browser auto-open only when a browser tab
+  // was recently polling the dashboard. A bare/orphan dashboard process on the
+  // port is not enough; cold starts should still open the UI.
   const dashWasUp = isPortListening(DASH_PORT);
+  const suppressDashboardOpen = dashWasUp && hasRecentDashboardBrowserTab(MINIONS_HOME);
   // 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.
@@ -691,7 +708,7 @@ if (!cmd || cmd === 'help' || cmd === '--help' || cmd === '-h') {
   });
   engineProc.unref();
   console.log(`\n  Engine started (PID: ${engineProc.pid})`);
-  const dashProc = spawnDashboard(dashWasUp);
+  const dashProc = spawnDashboard(suppressDashboardOpen);
   console.log(`  Dashboard started (PID: ${dashProc.pid})`);
   console.log(`  Dashboard: http://localhost:${DASH_PORT}\n`);
 } else if (cmd === 'nuke') {

package/dashboard/js/state.js

@@ -4,6 +4,17 @@ let inboxData = [];
 let agentData = [];
 let currentAgentId = null;
 let currentTab = 'thought-process';
+const DASHBOARD_TAB_ID = (function() {
+  try {
+    var existing = sessionStorage.getItem('minions-dashboard-tab-id');
+    if (existing) return existing;
+    var id = 'tab-' + Date.now().toString(36) + '-' + Math.random().toString(36).slice(2, 10);
+    sessionStorage.setItem('minions-dashboard-tab-id', id);
+    return id;
+  } catch {
+    return 'tab-' + Date.now().toString(36) + '-' + Math.random().toString(36).slice(2, 10);
+  }
+})();
 
 // Sidebar page navigation — URL-routed
 function getPageFromUrl() {
@@ -87,6 +98,37 @@ function prunePrdRequeueState(workItems) {
   }
 }
 
+function _dashboardPresencePayload(closed) {
+  return JSON.stringify({
+    tabId: DASHBOARD_TAB_ID,
+    closed: !!closed,
+    url: location.pathname + location.search + location.hash,
+    visibility: document.visibilityState || '',
+  });
+}
+
+function _sendDashboardPresence(closed) {
+  var payload = _dashboardPresencePayload(closed);
+  try {
+    if (navigator.sendBeacon) {
+      var blob = new Blob([payload], { type: 'application/json' });
+      if (navigator.sendBeacon('/api/browser-presence', blob)) return;
+    }
+  } catch {}
+  try {
+    fetch('/api/browser-presence', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: payload,
+      keepalive: true,
+    }).catch(function() {});
+  } catch {}
+}
+
+window.addEventListener('pagehide', function() { _sendDashboardPresence(true); });
+window.addEventListener('beforeunload', function() { _sendDashboardPresence(true); });
+document.addEventListener('visibilitychange', function() { _sendDashboardPresence(false); });
+
 function rerenderPrdFromCache() {
   if (!window._lastStatus || !window._lastStatus.prdProgress) return;
   renderPrdProgress(window._lastStatus.prdProgress);
@@ -100,6 +142,13 @@ function safeFetch(url, opts) {
   var controller = new AbortController();
   var timer = setTimeout(function() { controller.abort(); }, timeout);
   var fetchOpts = Object.assign({}, opts, { signal: controller.signal });
+  if (typeof url === 'string' && url.indexOf('/api/') === 0) {
+    var headers = Object.assign({}, fetchOpts.headers || {});
+    headers['X-Minions-Dashboard-Tab'] = DASHBOARD_TAB_ID;
+    headers['X-Minions-Dashboard-Url'] = location.pathname + location.search + location.hash;
+    headers['X-Minions-Dashboard-Visibility'] = document.visibilityState || '';
+    fetchOpts.headers = headers;
+  }
   delete fetchOpts.timeout;
   return fetch(url, fetchOpts).finally(function() { clearTimeout(timer); });
 }

package/dashboard.js

@@ -60,6 +60,8 @@ const { getAgents, getAgentDetail, getPrdInfo, getWorkItems, getDispatchQueue,
 const PORT = parseInt(process.env.PORT || process.argv[2]) || 7331;
 let CONFIG = queries.getConfig();
 let PROJECTS = _getProjects(CONFIG);
+const DASHBOARD_BROWSER_PRESENCE_PATH = path.join(ENGINE_DIR, 'dashboard-browser.json');
+const DASHBOARD_BROWSER_PRESENCE_MAX_AGE_MS = 45000;
 
 function ensureConfiguredProjectStateFiles() {
   for (const p of PROJECTS) {
@@ -571,6 +573,66 @@ function _trackSseClient(clientSet, req, res, { heartbeatMs = SSE_CLIENT_HEARTBE
   return cleanup;
 }
 
+function _normalizeDashboardTabId(value) {
+  const id = typeof value === 'string' ? value.trim() : '';
+  return /^[A-Za-z0-9._:-]{1,96}$/.test(id) ? id : null;
+}
+
+function _pruneDashboardBrowserTabs(tabs, now = Date.now()) {
+  for (const [id, tab] of Object.entries(tabs || {})) {
+    const lastSeen = Number(tab && tab.lastSeen);
+    if (!Number.isFinite(lastSeen) || now - lastSeen > DASHBOARD_BROWSER_PRESENCE_MAX_AGE_MS) delete tabs[id];
+  }
+}
+
+function _recordDashboardBrowserPresence(tabId, { closed = false, url = '', visibility = '' } = {}) {
+  const id = _normalizeDashboardTabId(tabId);
+  if (!id) return false;
+  const now = Date.now();
+  mutateJsonFileLocked(DASHBOARD_BROWSER_PRESENCE_PATH, (state) => {
+    if (!state || typeof state !== 'object' || Array.isArray(state)) state = {};
+    if (!state.tabs || typeof state.tabs !== 'object' || Array.isArray(state.tabs)) state.tabs = {};
+    _pruneDashboardBrowserTabs(state.tabs, now);
+    if (closed) {
+      delete state.tabs[id];
+    } else {
+      state.tabs[id] = {
+        id,
+        lastSeen: now,
+        lastSeenAt: new Date(now).toISOString(),
+        url: typeof url === 'string' ? url.slice(0, 512) : '',
+        visibility: typeof visibility === 'string' ? visibility.slice(0, 32) : '',
+      };
+    }
+    state.updatedAt = new Date(now).toISOString();
+    return state;
+  }, { defaultValue: { tabs: {} } });
+  return true;
+}
+
+function _recordDashboardBrowserPresenceFromRequest(req) {
+  const tabId = req && req.headers && req.headers['x-minions-dashboard-tab'];
+  if (!tabId) return;
+  try {
+    _recordDashboardBrowserPresence(tabId, {
+      url: req.headers['x-minions-dashboard-url'] || '',
+      visibility: req.headers['x-minions-dashboard-visibility'] || '',
+    });
+  } catch (e) {
+    shared.log('warn', `Dashboard browser presence update failed: ${e.message}`);
+  }
+}
+
+function _getDashboardBrowserPresence(now = Date.now()) {
+  const state = safeJsonObj(DASHBOARD_BROWSER_PRESENCE_PATH);
+  const tabs = state.tabs && typeof state.tabs === 'object' && !Array.isArray(state.tabs) ? state.tabs : {};
+  const activeTabs = Object.values(tabs).filter(tab => {
+    const lastSeen = Number(tab && tab.lastSeen);
+    return Number.isFinite(lastSeen) && now - lastSeen <= DASHBOARD_BROWSER_PRESENCE_MAX_AGE_MS;
+  });
+  return { active: activeTabs.length > 0, activeTabs: activeTabs.length, maxAgeMs: DASHBOARD_BROWSER_PRESENCE_MAX_AGE_MS };
+}
+
 // Hot-reload: watch dashboard/ directory for changes, rebuild, and push reload to browsers
 const _hotReloadClients = new Set();
 
@@ -989,12 +1051,7 @@ setInterval(() => {
 
 // CC chat sessions do NOT auto-expire. A tab is removed only via explicit user
 // deletion (DELETE /api/cc-sessions/:id, wired from ccCloseTab). Doc-chat
-// sessions keep their own TTL (DOC_SESSION_TTL_MS) — that's a separate store.
-//
-// CC_SESSION_MAX_TURNS is reused by the doc-chat session pruner to cap
-// per-session turn growth there; CC chat sessions are not capped because
-// users are expected to keep long-running tabs alive indefinitely.
-const CC_SESSION_MAX_TURNS = shared.ENGINE_DEFAULTS.ccMaxTurns;
+// sessions follow the same policy — see DOC_SESSIONS section below.
 let ccSession = { sessionId: null, createdAt: null, lastActiveAt: null, turnCount: 0 };
 const ccInFlightTabs = new Map(); // tabId → timestamp — per-tab in-flight tracking for parallel CC requests
 const ccInFlightAborts = new Map(); // tabId → abortFn — lets a new request kill the stale LLM
@@ -2177,11 +2234,14 @@ async function executeDocChatActions(actions) {
 
 // ── Shared LLM call core — used by CC panel and doc modals ──────────────────
 
-// Session store for doc modals — keyed by filePath or title, persisted to disk
+// Session store for doc modals — keyed by filePath or title, persisted to disk.
+// Doc-chat sessions do NOT auto-expire (parity with CC tabs). The only
+// invalidation paths are prompt-hash mismatch (correctness — a stale system
+// prompt would carry the old persona/rules into resume turns) and the
+// LRU cap below (storage hygiene). Users can resume a doc-chat any time.
 const CC_SESSIONS_PATH = path.join(ENGINE_DIR, 'cc-sessions.json');
 const DOC_SESSIONS_PATH = path.join(ENGINE_DIR, 'doc-sessions.json');
 const CC_SESSION_PATH = path.join(ENGINE_DIR, 'cc-session.json');
-const DOC_SESSION_TTL_MS = shared.ENGINE_DEFAULTS.docSessionTtlMs;
 const DOC_SESSION_MAX_ENTRIES = shared.ENGINE_DEFAULTS.docSessionMaxEntries;
 const docSessions = new Map(); // key → { sessionId, lastActiveAt, turnCount }
 
@@ -2193,9 +2253,7 @@ function _docSessionLastActiveMs(session) {
 function pruneDocSessions() {
   let changed = false;
   for (const [key, s] of docSessions.entries()) {
-    if (!s || (s.turnCount || 0) >= CC_SESSION_MAX_TURNS ||
-        _sessionExpired(s.lastActiveAt || s.createdAt, DOC_SESSION_TTL_MS) ||
-        s._promptHash !== _docChatPromptHash) {
+    if (!s || s._promptHash !== _docChatPromptHash) {
       docSessions.delete(key);
       changed = true;
     }
@@ -2212,13 +2270,12 @@ function pruneDocSessions() {
   return changed;
 }
 
-// Load persisted doc sessions on startup
+// Load persisted doc sessions on startup — no TTL/turn filtering, sessions
+// are non-expiring. Stale prompt-hash entries are dropped by pruneDocSessions.
 try {
   const saved = safeJson(DOC_SESSIONS_PATH);
   if (saved && typeof saved === 'object') {
     for (const [key, s] of Object.entries(saved)) {
-      if (s.turnCount >= CC_SESSION_MAX_TURNS) continue;
-      if (_sessionExpired(s.lastActiveAt || s.createdAt, DOC_SESSION_TTL_MS)) continue;
       docSessions.set(key, s);
     }
     pruneDocSessions();
@@ -2233,9 +2290,11 @@ function persistDocSessions() {
   mutateJsonFileLocked(DOC_SESSIONS_PATH, () => obj, { defaultValue: {} });
 }
 
+// Hourly hygiene sweep — drops prompt-hash mismatches and trims the LRU cap.
+// No TTL involved; sessions live until explicitly evicted by these two policies.
 const _docSessionPruneTimer = setInterval(() => {
   if (pruneDocSessions()) persistDocSessions();
-}, Math.min(DOC_SESSION_TTL_MS, 60 * 60 * 1000));
+}, 60 * 60 * 1000);
 if (_docSessionPruneTimer.unref) _docSessionPruneTimer.unref();
 
 // Debounced variant — coalesces rapid writes (e.g. back-to-back doc-chat turns)
@@ -2270,16 +2329,6 @@ function resolveSession(store, key) {
     persistDocSessions();
     return null;
   }
-  if (s.turnCount >= CC_SESSION_MAX_TURNS) {
-    docSessions.delete(key);
-    persistDocSessions();
-    return null;
-  }
-  if (_sessionExpired(s.lastActiveAt || s.createdAt, DOC_SESSION_TTL_MS)) {
-    docSessions.delete(key);
-    persistDocSessions();
-    return null;
-  }
   return s;
 }
 
@@ -6348,9 +6397,8 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       const configPath = path.join(MINIONS_DIR, 'config.json');
       const config = safeJson(configPath) || {};
       if (!config.engine) config.engine = {};
-      if (!config.claude) config.claude = {};
       if (!config.agents) config.agents = {};
-      delete config.claude.permissionMode;
+      shared.pruneDefaultClaudeConfig(config);
 
       const _clamped = [];
       const _engineModelDiscovery = require('./engine/model-discovery');
@@ -6518,9 +6566,11 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       }
 
       if (body.claude) {
+        if (!config.claude) config.claude = {};
         for (const key of ['allowedTools', 'outputFormat']) {
           if (body.claude[key] !== undefined) config.claude[key] = String(body.claude[key]);
         }
+        shared.pruneDefaultClaudeConfig(config);
       }
 
       if (body.agents) {
@@ -6647,6 +6697,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
         }
       }
 
+      shared.pruneDefaultClaudeConfig(config);
       safeWrite(configPath, config);
       // Refresh in-memory CONFIG so subsequent reads see the update
       reloadConfig();
@@ -6672,7 +6723,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     try {
       const config = queries.getConfig();
       config.engine = { ...shared.ENGINE_DEFAULTS };
-      config.claude = { ...shared.DEFAULT_CLAUDE };
+      delete config.claude;
       config.agents = { ...shared.DEFAULT_AGENTS };
       safeWrite(path.join(MINIONS_DIR, 'config.json'), config);
       reloadConfig();
@@ -6737,6 +6788,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
 
   async function handleStatus(req, res) {
     try {
+      _recordDashboardBrowserPresenceFromRequest(req);
       // Use pre-serialized JSON and pre-computed gzip buffer — zero per-request compression
       const json = getStatusJson();
       res.setHeader('Content-Type', 'application/json');
@@ -6876,6 +6928,20 @@ What would you like to discuss or change? When you're happy, say "approve" and I
 
     // Status & health
     { method: 'GET', path: '/api/status', desc: 'Full dashboard status snapshot (agents, PRDs, work items, dispatch, etc.)', handler: handleStatus },
+    { method: 'GET', path: '/api/browser-presence', desc: 'Whether a dashboard browser tab was recently active', handler: (req, res) => {
+      return jsonReply(res, 200, _getDashboardBrowserPresence(), req);
+    }},
+    { method: 'POST', path: '/api/browser-presence', desc: 'Record dashboard browser tab heartbeat or close', params: 'tabId, closed?, url?, visibility?', handler: async (req, res) => {
+      const body = await readBody(req);
+      const tabId = _normalizeDashboardTabId(body.tabId);
+      if (!tabId) return jsonReply(res, 400, { error: 'valid tabId required' }, req);
+      _recordDashboardBrowserPresence(tabId, {
+        closed: !!body.closed,
+        url: body.url || '',
+        visibility: body.visibility || '',
+      });
+      return jsonReply(res, 200, { ok: true }, req);
+    }},
     { method: 'GET', path: '/api/status-stream', desc: 'SSE stream of real-time status updates', handler: (req, res) => {
       res.writeHead(200, { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', 'Connection': 'keep-alive' });
       res.write('data: ' + getStatusJson() + '\n\n');
@@ -7517,14 +7583,14 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       if (route.path === '/api/skill') {
         if (!req.url.startsWith('/api/skill?') && req.url !== '/api/skill') continue;
         const _result = await route.handler(req, res, {});
-        if (pathname.startsWith('/api/') && !pathname.includes('/status') && !pathname.includes('/hot-reload') && !pathname.includes('/status-stream')) {
+        if (pathname.startsWith('/api/') && !pathname.includes('/status') && !pathname.includes('/hot-reload') && !pathname.includes('/status-stream') && !pathname.includes('/browser-presence')) {
           console.log(`  ${req.method} ${pathname} ${Date.now() - _reqStart}ms`);
         }
         return _result;
       }
       if (pathname !== route.path) continue;
       const _result = await route.handler(req, res, {});
-      if (pathname.startsWith('/api/') && !pathname.includes('/status') && !pathname.includes('/hot-reload') && !pathname.includes('/status-stream')) {
+      if (pathname.startsWith('/api/') && !pathname.includes('/status') && !pathname.includes('/hot-reload') && !pathname.includes('/status-stream') && !pathname.includes('/browser-presence')) {
         console.log(`  ${req.method} ${pathname} ${Date.now() - _reqStart}ms`);
       }
       return _result;
@@ -7532,7 +7598,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     const m = pathname.match(route.path);
     if (m) {
       const _result = await route.handler(req, res, m);
-      if (pathname.startsWith('/api/') && !pathname.includes('/status') && !pathname.includes('/hot-reload') && !pathname.includes('/status-stream')) {
+      if (pathname.startsWith('/api/') && !pathname.includes('/status') && !pathname.includes('/hot-reload') && !pathname.includes('/status-stream') && !pathname.includes('/browser-presence')) {
         console.log(`  ${req.method} ${pathname} ${Date.now() - _reqStart}ms`);
       }
       return _result;
@@ -7654,9 +7720,8 @@ if (require.main === module) {
     console.log(`\n  Auto-refreshes every 4s. Ctrl+C to stop.\n`);
 
     // 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.
+    // upgrade path set MINIONS_NO_AUTO_OPEN=1 only when a browser tab was
+    // recently polling the old dashboard, so a new tab would just be a duplicate.
     if (!process.env.MINIONS_NO_AUTO_OPEN) {
       const { exec } = require('child_process');
       try {

package/engine/cleanup.js

@@ -48,6 +48,105 @@ function worktreeMatchesBranch(dirLower, branch, actualBranch = '') {
   return worktreeBranchMatches(actualBranch, branch) || worktreeDirMatchesBranch(dirLower, branch);
 }
 
+function normalizeLocalBranchName(branch) {
+  return String(branch || '').trim().replace(/^refs\/heads\//i, '');
+}
+
+function isSafeLocalBranchName(branch) {
+  if (!branch || branch !== sanitizeBranch(branch)) return false;
+  if (branch.startsWith('-') || branch.includes('..') || branch.includes('@{')) return false;
+  if (branch.endsWith('/') || branch.endsWith('.lock')) return false;
+  return branch.split('/').every(part => part && part !== '.' && part !== '..' && !part.endsWith('.lock'));
+}
+
+function isProtectedLocalBranch(branch, project = {}) {
+  const protectedBranches = new Set(['main', 'master', 'trunk', 'develop', 'development', 'head']);
+  const configuredMain = normalizeLocalBranchName(project.mainBranch);
+  if (configuredMain) protectedBranches.add(configuredMain.toLowerCase());
+  return protectedBranches.has(branch.toLowerCase());
+}
+
+function localBranchWorktreeInUse(root, branch) {
+  try {
+    const out = String(shared.execSilent('git worktree list --porcelain', {
+      cwd: root, encoding: 'utf8', stdio: 'pipe', timeout: 10000, windowsHide: true,
+    }) || '');
+    return out.split(/\r?\n/).some(line => line.trim() === `branch refs/heads/${branch}`);
+  } catch {
+    return true;
+  }
+}
+
+function cleanupMergedPrLocalBranch(root, project, pr) {
+  const branch = normalizeLocalBranchName(pr?.branch);
+  const result = { deleted: false, forced: false, skipped: null };
+  if (pr?.status !== shared.PR_STATUS.MERGED) { result.skipped = 'not-merged'; return result; }
+  if (!root || !branch) { result.skipped = 'missing-branch'; return result; }
+  if (!isSafeLocalBranchName(branch)) { result.skipped = 'unsafe-branch-name'; return result; }
+  if (isProtectedLocalBranch(branch, project)) { result.skipped = 'protected-branch'; return result; }
+
+  try {
+    const current = String(shared.execSilent('git branch --show-current', {
+      cwd: root, encoding: 'utf8', stdio: 'pipe', timeout: 10000, windowsHide: true,
+    }) || '').trim();
+    if (current === branch) { result.skipped = 'current-branch'; return result; }
+  } catch {
+    result.skipped = 'current-branch-unknown';
+    return result;
+  }
+
+  if (localBranchWorktreeInUse(root, branch)) { result.skipped = 'branch-in-worktree'; return result; }
+
+  let localHead = '';
+  try {
+    localHead = String(shared.execSilent(`git rev-parse --verify "refs/heads/${branch}"`, {
+      cwd: root, encoding: 'utf8', stdio: 'pipe', timeout: 10000, windowsHide: true,
+    }) || '').trim();
+  } catch {
+    result.skipped = 'missing-local-branch';
+    return result;
+  }
+
+  try {
+    shared.execSilent(`git branch -d -- "${branch}"`, {
+      cwd: root, encoding: 'utf8', stdio: 'pipe', timeout: 15000, windowsHide: true,
+    });
+    log('info', `Post-merge cleanup: deleted local branch ${branch}`);
+    return { deleted: true, forced: false, skipped: null };
+  } catch (deleteErr) {
+    const localHeadLower = localHead.toLowerCase();
+    // Only use -D when the local tip still matches the merged PR head (or its remote-tracking ref);
+    // otherwise a reused local branch could lose unrelated work after the PR merged.
+    const proofHeads = [pr.headSha, pr._adoSourceCommit, pr.sourceCommit]
+      .map(v => String(v || '').trim().toLowerCase())
+      .filter(Boolean);
+    let safeToForce = proofHeads.includes(localHeadLower);
+    if (!safeToForce) {
+      try {
+        const remoteHead = String(shared.execSilent(`git rev-parse --verify "refs/remotes/origin/${branch}"`, {
+          cwd: root, encoding: 'utf8', stdio: 'pipe', timeout: 10000, windowsHide: true,
+        }) || '').trim().toLowerCase();
+        safeToForce = !!remoteHead && remoteHead === localHeadLower;
+      } catch { /* no matching remote-tracking branch */ }
+    }
+    if (!safeToForce) {
+      result.skipped = 'unproven-force-delete';
+      return result;
+    }
+    try {
+      shared.execSilent(`git branch -D -- "${branch}"`, {
+        cwd: root, encoding: 'utf8', stdio: 'pipe', timeout: 15000, windowsHide: true,
+      });
+      log('info', `Post-merge cleanup: force-deleted local branch ${branch} after merged PR confirmation`);
+      return { deleted: true, forced: true, skipped: null };
+    } catch (forceErr) {
+      log('warn', `Post-merge cleanup: failed to delete local branch ${branch}: ${forceErr.message || deleteErr.message}`);
+      result.skipped = 'delete-failed';
+      return result;
+    }
+  }
+}
+
 /**
  * Sweep leaked test-fixture meetings from a `meetings/` directory.
  *
@@ -342,9 +441,11 @@ async function runCleanup(config, verbose = false) {
         // Check if this worktree's branch is merged/abandoned
         // Prefer actual git branch metadata; compact Windows dirs intentionally omit branch names.
         const dirLower = dir.toLowerCase();
+        let matchedMergedBranch = '';
         for (const branch of mergedBranches) {
           if (worktreeMatchesBranch(dirLower, branch, actualBranch)) {
             shouldClean = true;
+            matchedMergedBranch = branch;
             break;
           }
         }
@@ -392,7 +493,7 @@ async function runCleanup(config, verbose = false) {
           } catch (e) { log('warn', 'check shared-branch protection: ' + e.message); }
         }
 
-        wtEntries.push({ dir, wtPath, mtime, shouldClean, isProtected, actualBranch });
+        wtEntries.push({ dir, wtPath, mtime, shouldClean, isProtected, actualBranch, matchedMergedBranch });
       }
 
       // Enforce max worktree cap — if over limit, mark oldest unprotected for cleanup
@@ -412,10 +513,14 @@ async function runCleanup(config, verbose = false) {
       // the initial status check and the actual deletion (Bug #15: TOCTOU race)
       const freshPrs = safeJson(projectPrPath(project)) || [];
       const freshMergedBranches = new Set();
+      const freshMergedPrByBranch = new Map();
       for (const pr of freshPrs) {
         if (pr.status === shared.PR_STATUS.MERGED || pr.status === shared.PR_STATUS.ABANDONED || pr.status === shared.PLAN_STATUS.COMPLETED) {
           if (pr.branch) freshMergedBranches.add(pr.branch);
         }
+        if (pr.status === shared.PR_STATUS.MERGED && pr.branch) {
+          freshMergedPrByBranch.set(sanitizeBranch(normalizeLocalBranchName(pr.branch)).toLowerCase(), pr);
+        }
       }
 
       for (const entry of wtEntries) {
@@ -446,6 +551,10 @@ async function runCleanup(config, verbose = false) {
           _killProcessInWorktree(entry.dir, activeProcesses, activeDispatchIds);
           if (shared.removeWorktree(entry.wtPath, root, worktreeRoot)) {
             cleaned.worktrees++;
+            const mergedPr = entry.matchedMergedBranch
+              ? freshMergedPrByBranch.get(sanitizeBranch(normalizeLocalBranchName(entry.matchedMergedBranch)).toLowerCase())
+              : null;
+            if (mergedPr) cleanupMergedPrLocalBranch(root, project, mergedPr);
             if (verbose) console.log(`  Removed worktree: ${entry.wtPath}`);
           } else {
             if (verbose) console.log(`  Failed to remove worktree ${entry.wtPath}`);
@@ -935,4 +1044,5 @@ module.exports = {
   worktreeDirMatchesBranch,  // exported for testing
   worktreeMatchesBranch,     // exported for testing
   getWorktreeBranch,         // exported for lifecycle cleanup
+  cleanupMergedPrLocalBranch, // exported for lifecycle cleanup and testing
 };

package/engine/copilot-models.json

@@ -1,5 +1,5 @@
 {
   "runtime": "copilot",
   "models": null,
-  "cachedAt": "2026-05-07T15:45:25.869Z"
+  "cachedAt": "2026-05-07T16:58:12.762Z"
 }

package/engine/lifecycle.js

@@ -7,14 +7,14 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const shared = require('./shared');
-const { safeRead, safeJson, safeJsonNoRestore, safeWrite, mutateJsonFileLocked, mutateWorkItems, execSilent, execAsync, projectPrPath, getPrLinks,
+const { safeRead, safeJson, safeJsonNoRestore, safeWrite, mutateJsonFileLocked, mutateWorkItems, 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');
 const { resolveRuntime } = require('./runtimes');
 const queries = require('./queries');
 const { isBranchActive } = require('./cooldown');
-const { worktreeMatchesBranch, getWorktreeBranch } = require('./cleanup');
+const { worktreeMatchesBranch, getWorktreeBranch, cleanupMergedPrLocalBranch } = require('./cleanup');
 const { getConfig, getInboxFiles, getNotes, getPrs, getDispatch,
   MINIONS_DIR, ENGINE_DIR, PLANS_DIR, PRD_DIR, INBOX_DIR, AGENTS_DIR } = queries;
 
@@ -1838,6 +1838,7 @@ async function handlePostMerge(pr, project, config, newStatus) {
   if (pr.branch && project) {
     const root = path.resolve(project.localPath);
     const wtRoot = path.resolve(root, config.engine?.worktreeRoot || '../worktrees');
+    let removedBranchWorktree = false;
     // Find worktrees matching this branch; compact Windows dirs require branch metadata.
     try {
       const dirs = require('fs').readdirSync(wtRoot);
@@ -1847,11 +1848,16 @@ async function handlePostMerge(pr, project, config, newStatus) {
         if (worktreeMatchesBranch(dirLower, pr.branch, getWorktreeBranch(wtPath)) || dir === pr.branch || dir === `bt-${prNum}`) {
           try {
             if (!require('fs').statSync(wtPath).isDirectory()) continue;
-            execSilent(`git worktree remove "${wtPath}" --force`, { cwd: root, stdio: 'pipe', timeout: 15000 });
-            log('info', `Post-merge cleanup: removed worktree ${dir}`);
+            if (shared.removeWorktree(wtPath, root, wtRoot)) {
+              removedBranchWorktree = true;
+              log('info', `Post-merge cleanup: removed worktree ${dir}`);
+            }
           } catch (err) { log('warn', `Failed to remove worktree ${dir}: ${err.message}`); }
         }
       }
+      if (removedBranchWorktree && newStatus === PR_STATUS.MERGED) {
+        cleanupMergedPrLocalBranch(root, project, pr);
+      }
     } catch (err) { log('warn', `Post-merge worktree cleanup: ${err.message}`); }
   }
 

package/engine/shared.js

@@ -1029,9 +1029,8 @@ const ENGINE_DEFAULTS = {
   mainBranchCacheMaxEntries: 100, // bound repo/branch detection cache in long-lived dashboard/engine processes
   removeWorktreeFailureTtlMs: 24 * 60 * 60 * 1000, // stale failed paths are forgotten after a day
   removeWorktreeFailureMaxEntries: 1000, // bound failed-worktree retry suppression cache
-  ccMaxTurns: 50, // max tool-use turns for CC/doc-chat before CLI stops
-  docSessionTtlMs: 7 * 24 * 60 * 60 * 1000, // 7d — longer-lived doc sessions, still bounded
-  docSessionMaxEntries: 200, // cap doc-chat session map/disk store by least-recent activity
+  ccMaxTurns: 50, // max tool-use turns per CC/doc-chat call before CLI stops (per response, not per session)
+  docSessionMaxEntries: 200, // cap doc-chat session map/disk store by least-recent activity (LRU; sessions are non-expiring otherwise)
   ccLiveStreamMaxAgeMs: 30 * 60 * 1000, // hard cap reconnect buffers if abort/cleanup stalls
   metricsFlushIntervalMs: 10000, // batch trackEngineUsage writes to metrics.json — flushed every 10s instead of per-call to cut lock contention and dashboard mtime churn
   maxLlmRawBytes: 256 * 1024, // keep only a bounded stdout tail from direct Claude calls
@@ -1244,7 +1243,7 @@ function _resetLegacyCcModelMigrationFlag() {
  * Warnings emitted:
  *   - Unknown CLI: any `cli` value (per-agent, ccCli, defaultCli) not in
  *     `registeredRuntimes`. Each unknown value produces one entry.
- *   - Deprecated `config.claude.*` fields: presence of any field in
+ *   - Deprecated `config.claude.*` overrides: non-default fields listed in
  *     `ENGINE_DEFAULTS._deprecatedConfigClaudeFields` under `config.claude`.
  *   - Bare-mode misconfig: `engine.claudeBareMode === true` paired with
  *     CC running on the Claude runtime (resolved via `resolveCcCli`) and no
@@ -1283,11 +1282,15 @@ function runtimeConfigWarnings(config, registeredRuntimes) {
     if (agent && typeof agent === 'object') checkCli(`agents.${agentId}.cli`, agent.cli);
   }
 
-  // 2. Deprecated `config.claude.*` fields.
+  // 2. Deprecated `config.claude.*` overrides. Generated defaults from older
+  // init versions are ignored here and pruned the next time config is saved.
   const claude = config.claude;
   if (claude && typeof claude === 'object') {
     const deprecatedKeys = ENGINE_DEFAULTS._deprecatedConfigClaudeFields || [];
-    const present = deprecatedKeys.filter(k => Object.prototype.hasOwnProperty.call(claude, k));
+    const present = deprecatedKeys.filter(k => {
+      if (!Object.prototype.hasOwnProperty.call(claude, k)) return false;
+      return !(Object.prototype.hasOwnProperty.call(DEFAULT_CLAUDE, k) && claude[k] === DEFAULT_CLAUDE[k]);
+    });
     if (present.length > 0) {
       warnings.push({
         id: 'deprecated-config-claude',
@@ -1573,6 +1576,37 @@ const DEFAULT_CLAUDE = {
   allowedTools: 'Edit,Write,Read,Bash,Glob,Grep,Agent,WebFetch,WebSearch',
 };
 
+function pruneDefaultClaudeConfig(config) {
+  if (!config || typeof config !== 'object') return false;
+  const claude = config.claude;
+  if (claude === undefined || claude === null) return false;
+  if (typeof claude !== 'object' || Array.isArray(claude)) {
+    delete config.claude;
+    return true;
+  }
+
+  let changed = false;
+  const removeKey = (key) => {
+    if (Object.prototype.hasOwnProperty.call(claude, key)) {
+      delete claude[key];
+      changed = true;
+    }
+  };
+
+  removeKey('permissionMode');
+  for (const key of ['binary', 'outputFormat', 'allowedTools']) {
+    if (Object.prototype.hasOwnProperty.call(claude, key) && claude[key] === DEFAULT_CLAUDE[key]) {
+      removeKey(key);
+    }
+  }
+
+  if (Object.keys(claude).length === 0) {
+    delete config.claude;
+    changed = true;
+  }
+  return changed;
+}
+
 // ── Project Helpers ──────────────────────────────────────────────────────────
 
 function getProjects(config) {
@@ -3068,6 +3102,7 @@ module.exports = {
   DEFAULT_AGENT_METRICS,
   DEFAULT_AGENTS,
   DEFAULT_CLAUDE,
+  pruneDefaultClaudeConfig,
   getProjects,
   projectRoot,
   projectStateDir,

package/minions.js

@@ -17,7 +17,7 @@ const path = require('path');
 const readline = require('readline');
 const { execSync } = require('child_process');
 const shared = require('./engine/shared');
-const { ENGINE_DEFAULTS, DEFAULT_AGENTS, DEFAULT_CLAUDE } = shared;
+const { ENGINE_DEFAULTS, DEFAULT_AGENTS } = shared;
 const projectDiscovery = require('./engine/project-discovery');
 
 const MINIONS_HOME = process.env.MINIONS_HOME ? path.resolve(process.env.MINIONS_HOME) : __dirname;
@@ -385,11 +385,7 @@ async function initMinions({ skipScan = false, scanRoot, scanDepth } = {}) {
     if (k === 'defaultCli') continue;
     if (config.engine[k] === undefined) config.engine[k] = v;
   }
-  if (!config.claude) config.claude = {};
-  delete config.claude.permissionMode;
-  for (const [k, v] of Object.entries(DEFAULT_CLAUDE)) {
-    if (config.claude[k] === undefined) config.claude[k] = v;
-  }
+  shared.pruneDefaultClaudeConfig(config);
   if (!config.agents || Object.keys(config.agents).length === 0) {
     config.agents = { ...DEFAULT_AGENTS };
   }

package/package.json

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