@yemi33/minions 0.1.1707 → 0.1.1709

package/CHANGELOG.md

@@ -1,14 +1,20 @@
 # Changelog
 
-## 0.1.1707 (2026-05-04)
+## 0.1.1709 (2026-05-04)
+
+### Fixes
+-  auto-heal projects with missing workSources at engine boot
+
+## 0.1.1708 (2026-05-04)
+
+### Fixes
+-  surface silent-discovery footgun when projects miss workSources
+
+## 0.1.1706 (2026-05-04)
 
 ### Features
 - preserve CC fan-out dedup scope (#2037)
 
-### Other
-- test(llm): add unit tests for resolution helper edge cases and bin cache reset (#2039)
-- test(ado): add unit tests for pure helpers (project label, GUID, metadata apply, stale flag) (#2038)
-
 ## 0.1.1705 (2026-05-04)
 
 ### Features

package/engine/cli.js

@@ -379,6 +379,28 @@ const commands = {
     // refactor. No disk write — the on-disk config still carries `ccModel`.
     try { shared.applyLegacyCcModelMigration(config, { logger: e.log }); }
     catch (err) { e.log('warn', `legacy ccModel migration failed: ${err.message}`); }
+
+    // Auto-heal projects missing workSources (cloned-repo / hand-rolled-config
+    // footgun): without this block, discoverFromWorkItems / discoverFromPrs
+    // bail silently and the engine looks healthy but never dispatches. The
+    // disk-side mutation re-derives heal state from the on-disk copy so we
+    // don't clobber a concurrent dashboard write between the in-memory check
+    // and the lock acquire. skipWriteIfUnchanged makes the write a no-op when
+    // nothing needed healing (e.g. dashboard already fixed it).
+    try {
+      const heal = shared.backfillProjectWorkSourceDefaults(config);
+      if (heal.changed) {
+        const configPath = path.join(shared.MINIONS_DIR, 'config.json');
+        shared.mutateJsonFileLocked(configPath, (onDisk) => {
+          shared.backfillProjectWorkSourceDefaults(onDisk);
+          return onDisk;
+        }, { defaultValue: {}, skipWriteIfUnchanged: true });
+        for (const h of heal.healed) {
+          e.log('info', `Auto-healed project "${h.project}" — backfilled missing workSources: ${h.sources.join(', ')}`);
+        }
+        console.log(`  Auto-healed ${heal.healed.length} project(s) with missing workSources defaults — engine will now dispatch their work.`);
+      }
+    } catch (err) { e.log('warn', `workSources auto-heal failed: ${err.message}`); }
     const interval = config.engine?.tickInterval || shared.ENGINE_DEFAULTS.tickInterval;
 
     const { getProjects } = require('./shared');

package/engine/copilot-models.json

@@ -1,5 +1,5 @@
 {
   "runtime": "copilot",
   "models": null,
-  "cachedAt": "2026-05-04T15:04:13.291Z"
+  "cachedAt": "2026-05-04T16:53:06.222Z"
 }

package/engine/preflight.js

@@ -226,6 +226,24 @@ function runPreflight(opts = {}) {
         results.push({ name: `Runtime config (${w.id})`, ok: 'warn', message: w.message });
       }
     } catch { /* defensive — preflight must never throw */ }
+
+    // Project workSources warnings — catches the silent-discovery footgun
+    // where a project (often added by a hand-rolled config or by cloning the
+    // repo without `minions init`) has no workSources block, so engine.js
+    // discoverFromWorkItems / discoverFromPrs return [] without logging.
+    try {
+      const projectWarns = shared.projectWorkSourceWarnings(opts.config, (project) => {
+        const wiPath = shared.projectWorkItemsPath(project);
+        const prPath = shared.projectPrPath(project);
+        const safeJson = shared.safeJson;
+        const wi = (() => { try { const a = safeJson(wiPath); return Array.isArray(a) ? a.length : 0; } catch { return 0; } })();
+        const pr = (() => { try { const a = safeJson(prPath); return Array.isArray(a) ? a.length : 0; } catch { return 0; } })();
+        return { workItems: wi, pullRequests: pr };
+      });
+      for (const w of projectWarns) {
+        results.push({ name: `Project config (${w.id})`, ok: 'warn', message: w.message });
+      }
+    } catch { /* defensive */ }
   }
 
   return { passed: allOk, results };

package/engine/shared.js

@@ -1120,6 +1120,109 @@ function runtimeConfigWarnings(config, registeredRuntimes) {
   return warnings;
 }
 
+/**
+ * Detect projects whose discovery would silently no-op because the
+ * `workSources` block is missing or its sub-flags are disabled. Catches the
+ * common "I cloned the repo and ran it without `minions init`" footgun where
+ * `engine.js` `discoverFromWorkItems` / `discoverFromPrs` bail on
+ * `if (!src?.enabled) return [];` with no log output.
+ *
+ * Pure helper — pass `getDataCounts(project) → { workItems: N, pullRequests: N }`
+ * so the caller controls disk reads (preflight reads files; tests inject counts).
+ * If `getDataCounts` is omitted, every project with a missing/disabled source
+ * is reported (caller decides whether to surface).
+ *
+ * Returns: `{ id, message, project }[]` — `id` is one of:
+ *   - `project-worksources-missing`     — no workSources block at all
+ *   - `project-worksources-disabled`    — block exists but a sub-source is disabled
+ */
+function projectWorkSourceWarnings(config, getDataCounts) {
+  const warnings = [];
+  if (!config || typeof config !== 'object') return warnings;
+  const projects = Array.isArray(config.projects) ? config.projects : [];
+  const topSources = config.workSources || null;
+  for (const project of projects) {
+    if (!project || typeof project !== 'object') continue;
+    const projSources = project.workSources || null;
+    const counts = (typeof getDataCounts === 'function')
+      ? (getDataCounts(project) || {})
+      : { workItems: Infinity, pullRequests: Infinity };
+    const wiCount = Number(counts.workItems) || 0;
+    const prCount = Number(counts.pullRequests) || 0;
+
+    // Case 1: project has no workSources AND no top-level fallback. Discovery
+    // will return [] for everything. This is the cloned-repo footgun.
+    if (!projSources && !topSources) {
+      if (wiCount > 0 || prCount > 0) {
+        warnings.push({
+          id: 'project-worksources-missing',
+          project: project.name,
+          message: `Project "${project.name}" has no workSources block — work-item and PR discovery are silently disabled (${wiCount} work item(s), ${prCount} PR(s) waiting). Run \`minions init\` if you cloned the repo directly, or re-link the project: \`minions add ${project.localPath || project.name}\`.`,
+        });
+      }
+      continue;
+    }
+
+    // Case 2: workSources exists but a sub-source is disabled while data sits
+    // unprocessed. Could be intentional, but worth surfacing.
+    const wiSrc = projSources?.workItems || topSources?.workItems;
+    if ((!wiSrc || wiSrc.enabled === false) && wiCount > 0) {
+      warnings.push({
+        id: 'project-worksources-disabled',
+        project: project.name,
+        message: `Project "${project.name}" has ${wiCount} unprocessed work item(s) but workSources.workItems.enabled is not true — engine will not dispatch them. Toggle in Dashboard → Settings → Project, or set \`workSources.workItems.enabled: true\` in config.json.`,
+      });
+    }
+    const prSrc = projSources?.pullRequests || topSources?.pullRequests;
+    if ((!prSrc || prSrc.enabled === false) && prCount > 0) {
+      warnings.push({
+        id: 'project-worksources-disabled',
+        project: project.name,
+        message: `Project "${project.name}" has ${prCount} pull-request record(s) but workSources.pullRequests.enabled is not true — engine will not poll or review them. Toggle in Dashboard → Settings → Project, or set \`workSources.pullRequests.enabled: true\` in config.json.`,
+      });
+    }
+  }
+  return warnings;
+}
+
+/**
+ * Boot-time auto-heal for the cloned-repo / hand-rolled-config footgun: any
+ * project missing a `workSources.workItems` or `workSources.pullRequests`
+ * sub-block gets the dashboard's default backfilled. We only touch *missing*
+ * sub-blocks — an explicit `enabled: false` is treated as user intent and
+ * left alone.
+ *
+ * Pure helper — mutates `config` in place and returns
+ * `{ changed: boolean, healed: Array<{ project, sources }> }` so the caller
+ * can decide whether to persist + log. Returns `{ changed: false, healed: [] }`
+ * for null/empty/malformed input.
+ */
+function backfillProjectWorkSourceDefaults(config) {
+  const result = { changed: false, healed: [] };
+  if (!config || typeof config !== 'object') return result;
+  const projects = Array.isArray(config.projects) ? config.projects : [];
+  for (const project of projects) {
+    if (!project || typeof project !== 'object') continue;
+    const filled = [];
+    if (!project.workSources || typeof project.workSources !== 'object') {
+      project.workSources = {};
+    }
+    if (!project.workSources.pullRequests) {
+      project.workSources.pullRequests = { enabled: true, cooldownMinutes: 30 };
+      filled.push('pullRequests');
+    }
+    if (!project.workSources.workItems) {
+      project.workSources.workItems = { enabled: true, cooldownMinutes: 0 };
+      filled.push('workItems');
+    }
+    if (filled.length > 0) {
+      result.changed = true;
+      result.healed.push({ project: project.name, sources: filled });
+    }
+  }
+  return result;
+}
+
 // ─── Status & Type Constants ─────────────────────────────────────────────────
 
 const WI_STATUS = {
@@ -2515,6 +2618,8 @@ module.exports = {
   resolveAgentMaxBudget, resolveAgentBareMode,
   applyLegacyCcModelMigration, _resetLegacyCcModelMigrationFlag,
   runtimeConfigWarnings,
+  projectWorkSourceWarnings,
+  backfillProjectWorkSourceDefaults,
   WI_STATUS, DONE_STATUSES, PLAN_TERMINAL_STATUSES, WORK_TYPE, PLAN_STATUS, PRD_ITEM_STATUS, PRD_MATERIALIZABLE, PR_STATUS, PR_POLLABLE_STATUSES, PR_PENDING_REASON, DISPATCH_RESULT, trackReviewMetric, queuePlanToPrd,
   WATCH_STATUS, WATCH_TARGET_TYPE, WATCH_CONDITION, WATCH_ABSOLUTE_CONDITIONS,
   PIPELINE_STATUS, STAGE_TYPE, MEETING_STATUS, AGENT_STATUS,

package/engine.js

@@ -2252,12 +2252,35 @@ function ensurePrBranchForDispatch(project, pr, automationType) {
 }
 
 
+// Tracks per-process which silent-discovery warnings have already been logged
+// so we don't spam the log every tick. Cleared on process exit (no need to
+// persist — the warning is for the operator at engine startup/run time).
+const _warnedSilentDiscovery = new Set();
+
+function _warnSilentDiscoveryOnce(kind, project, dataPath, config) {
+  const key = `${kind}:${project?.name || project?.localPath || 'default'}`;
+  if (_warnedSilentDiscovery.has(key)) return;
+  let count = 0;
+  try { const arr = safeJson(dataPath); if (Array.isArray(arr)) count = arr.length; } catch {}
+  if (count <= 0) return; // empty file is fine — no warning worth surfacing
+  _warnedSilentDiscovery.add(key);
+  const projName = project?.name || '(unnamed)';
+  const hasBlock = !!(project?.workSources?.[kind] || config?.workSources?.[kind]);
+  const hint = hasBlock
+    ? `Toggle in Dashboard → Settings → Project, or set \`workSources.${kind}.enabled: true\` in config.json.`
+    : `Run \`minions doctor\` to inspect, \`minions init\` if you cloned the repo without setup, or re-link the project: \`minions add ${project?.localPath || projName}\`.`;
+  log('warn', `Silent-discovery footgun: project "${projName}" has ${count} record(s) in ${path.basename(dataPath)} but workSources.${kind}.enabled is not true — engine will not pick them up. ${hint}`);
+}
+
 /**
  * Scan pull-requests.json for PRs needing review or fixes
  */
 async function discoverFromPrs(config, project) {
   const src = project?.workSources?.pullRequests || config.workSources?.pullRequests;
-  if (!src?.enabled) return [];
+  if (!src?.enabled) {
+    _warnSilentDiscoveryOnce('pullRequests', project, projectPrPath(project), config);
+    return [];
+  }
 
   const prs = queries.getPrs(project);
   const cooldownMs = (src.cooldownMinutes || 30) * 60 * 1000;
@@ -2757,7 +2780,10 @@ function refreshDeferredWorkItemPrompt(item, config) {
 
 function discoverFromWorkItems(config, project) {
   const src = project?.workSources?.workItems || config.workSources?.workItems;
-  if (!src?.enabled) return [];
+  if (!src?.enabled) {
+    _warnSilentDiscoveryOnce('workItems', project, projectWorkItemsPath(project), config);
+    return [];
+  }
 
   const root = project?.localPath ? path.resolve(project.localPath) : path.resolve(MINIONS_DIR, '..');
   const items = safeJson(projectWorkItemsPath(project)) || [];

package/minions.js

@@ -173,6 +173,13 @@ function buildProjectEntry({ name, description, localPath, repoHost, repositoryI
     repoName: repoName || name,
     mainBranch: mainBranch || 'main',
     prUrlBase: buildPrUrlBase({ repoHost, org, project, repoName }),
+    // Discovery defaults must mirror dashboard.js POST /api/projects — without
+    // these, discoverFromWorkItems / discoverFromPrs silently no-op (the engine
+    // looks healthy but never dispatches anything).
+    workSources: {
+      pullRequests: { enabled: true, cooldownMinutes: 30 },
+      workItems: { enabled: true, cooldownMinutes: 0 },
+    },
   };
 }
 

package/package.json

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