@yemi33/minions 0.1.152 → 0.1.154

package/engine/lifecycle.js

@@ -58,7 +58,7 @@ function checkPlanCompletion(meta, config) {
   const unmaterialized = [...planFeatureIds].filter(id => {
     if (workItemById[id]) return false;
     const prdItem = (plan.missing_features || []).find(f => f.id === id);
-    return !(prdItem && (prdItem.status === 'done' || prdItem.status === 'in-pr'));
+    return !(prdItem && prdItem.status === 'done');
   });
   if (unmaterialized.length > 0) {
     log('info', `Plan ${planFile}: ${unmaterialized.length}/${planFeatureIds.size} feature(s) not yet materialized as work items: ${unmaterialized.join(', ')}`);
@@ -68,16 +68,16 @@ function checkPlanCompletion(meta, config) {
   // Check 2: every feature's work item must be done (or PRD item marked done externally)
   const notDone = [...planFeatureIds].filter(id => {
     const w = workItemById[id];
-    if (w && (w.status === 'done' || w.status === 'in-pr')) return false; // in-pr accepted for backward compat
+    if (w && w.status === 'done') return false;
     const prdItem = (plan.missing_features || []).find(f => f.id === id);
-    return !(prdItem && (prdItem.status === 'done' || prdItem.status === 'in-pr'));
+    return !(prdItem && prdItem.status === 'done');
   });
   if (notDone.length > 0) {
     log('info', `Plan ${planFile}: waiting for done on ${notDone.length}/${planFeatureIds.size} item(s): ${notDone.join(', ')}`);
     return;
   }
 
-  const doneItems = planItems.filter(w => w.status === 'done' || w.status === 'in-pr');
+  const doneItems = planItems.filter(w => w.status === 'done');
   const failedItems = planItems.filter(w => w.status === 'failed');
 
   // 1. Mark plan as completed
@@ -603,7 +603,14 @@ function syncPrsFromOutput(output, agentId, meta, config) {
       dirtyTargets.set(targetName, { prs: safeJson(prPath) || [], prPath });
     }
     const entry = dirtyTargets.get(targetName);
-    if (entry.prs.some(p => p.id === fullId || String(p.id) === String(prId))) continue;
+    const existing = entry.prs.find(p => p.id === fullId || String(p.id) === String(prId));
+    if (existing) {
+      // Backfill prdItems if the entry was added by the poller before syncPrsFromOutput ran
+      if (meta?.item?.id && !existing.prdItems?.includes(meta.item.id)) {
+        existing.prdItems = [...(existing.prdItems || []), meta.item.id];
+      }
+      continue;
+    }
 
     let title = meta?.item?.title || '';
     const titleMatch = output.match(new RegExp(`${prId}[^\\n]*?[—–-]\\s*([^\\n]+)`, 'i'));
@@ -637,10 +644,26 @@ function syncPrsFromOutput(output, agentId, meta, config) {
 
 // ─── Post-Completion Hooks ──────────────────────────────────────────────────
 
+/**
+ * Resolve which project's pull-requests.json contains a given PR ID.
+ * Returns the project object, or null if not found in any project file.
+ */
+function resolveProjectForPr(prId) {
+  const config = getConfig();
+  for (const p of shared.getProjects(config)) {
+    const prs = safeJson(projectPrPath(p)) || [];
+    if (prs.some(pr => pr.id === prId)) return p;
+  }
+  return null;
+}
+
 function updatePrAfterReview(agentId, pr, project) {
 
   if (!pr?.id) return;
-  const prs = getPrs(project);
+  // Resolve actual project if not provided — avoids writing merged array to wrong path
+  const resolvedProject = project || resolveProjectForPr(pr.id);
+  if (!resolvedProject) { log('warn', `updatePrAfterReview: cannot resolve project for ${pr.id}`); return; }
+  const prs = getPrs(resolvedProject);
   const target = prs.find(p => p.id === pr.id);
   if (!target) return;
 
@@ -674,7 +697,7 @@ function updatePrAfterReview(agentId, pr, project) {
     shared.safeWrite(metricsPath, metrics);
   }
 
-  shared.safeWrite(project ? shared.projectPrPath(project) : path.join(path.resolve(MINIONS_DIR, '..'), '.minions', 'pull-requests.json'), prs);
+  shared.safeWrite(shared.projectPrPath(resolvedProject), prs);
   log('info', `Updated ${pr.id} → minions review: ${target.reviewStatus} by ${reviewerName}`);
   createReviewFeedbackForAuthor(agentId, { ...pr, ...target }, config);
 }
@@ -682,7 +705,10 @@ function updatePrAfterReview(agentId, pr, project) {
 function updatePrAfterFix(pr, project, source) {
 
   if (!pr?.id) return;
-  const prs = getPrs(project);
+  // Resolve actual project if not provided — avoids writing merged array to wrong path
+  const resolvedProject = project || resolveProjectForPr(pr.id);
+  if (!resolvedProject) { log('warn', `updatePrAfterFix: cannot resolve project for ${pr.id}`); return; }
+  const prs = getPrs(resolvedProject);
   const target = prs.find(p => p.id === pr.id);
   if (!target) return;
 
@@ -697,7 +723,7 @@ function updatePrAfterFix(pr, project, source) {
     log('info', `Updated ${pr.id} → reviewStatus: waiting (fix pushed)`);
   }
 
-  shared.safeWrite(project ? shared.projectPrPath(project) : path.join(path.resolve(MINIONS_DIR, '..'), '.minions', 'pull-requests.json'), prs);
+  shared.safeWrite(shared.projectPrPath(resolvedProject), prs);
 }
 
 // ─── Post-Merge / Post-Close Hooks ───────────────────────────────────────────
@@ -740,7 +766,7 @@ async function handlePostMerge(pr, project, config, newStatus) {
   }
 
   if (mergedItemId) {
-    // Mark PRD feature as implemented
+    // Mark PRD feature as done
     const prdDir = path.join(MINIONS_DIR, 'prd');
     try {
       const planFiles = fs.readdirSync(prdDir).filter(f => f.endsWith('.json'));
@@ -749,13 +775,13 @@ async function handlePostMerge(pr, project, config, newStatus) {
         const plan = safeJson(path.join(prdDir, pf));
         if (!plan?.missing_features) continue;
         const feature = plan.missing_features.find(f => f.id === mergedItemId);
-        if (feature && feature.status !== 'implemented') {
-          feature.status = 'implemented';
+        if (feature && feature.status !== 'done') {
+          feature.status = 'done';
           shared.safeWrite(path.join(prdDir, pf), plan);
           updated++;
         }
       }
-      if (updated > 0) log('info', `Post-merge: marked ${mergedItemId} as implemented for ${pr.id}`);
+      if (updated > 0) log('info', `Post-merge: marked ${mergedItemId} as done for ${pr.id}`);
     } catch (err) { log('warn', `Post-merge PRD update: ${err.message}`); }
 
     // Mark work item as done
@@ -1011,7 +1037,8 @@ function updateMetrics(agentId, dispatchItem, result, taskUsage, prsCreatedCount
     if (taskUsage.numTurns > cp.maxTurns) cp.maxTurns = taskUsage.numTurns;
     // Check if this dispatch hit the turn limit
     const engineConfig = require('./queries').getConfig()?.engine || {};
-    const turnLimit = engineConfig.maxTurns || 100;
+    // maxTurns default defined in ENGINE_DEFAULTS (shared.js) — avoid hardcoded fallback
+    const turnLimit = engineConfig.maxTurns || shared.ENGINE_DEFAULTS.maxTurns;
     if (taskUsage.numTurns >= turnLimit) cp.turnLimitHits++;
   }
 
@@ -1206,7 +1233,8 @@ function runPostCompletionHooks(dispatchItem, agentId, code, stdout, config) {
   if (meta?.item?.id) {
     try {
       const engineConfig = (config.engine || {});
-      const turnLimit = engineConfig.maxTurns || 100;
+      // maxTurns resolved from config, fallback to ENGINE_DEFAULTS (shared.js)
+      const turnLimit = engineConfig.maxTurns || shared.ENGINE_DEFAULTS.maxTurns;
       const turnCount = taskUsage?.numTurns || 0;
       const hitTurnLimit = turnCount >= turnLimit;
       let outputLogSizeBytes = 0;
@@ -1321,51 +1349,37 @@ function runPostCompletionHooks(dispatchItem, agentId, code, stdout, config) {
   }
 
   if (!isSuccess && meta?.item?.id) {
-    // Auto-retry: read fresh _retryCount from file (not stale dispatch-time snapshot)
-    let retries = (meta.item._retryCount || 0);
-    try {
-      const wiPath = meta.source === 'central-work-item' || meta.source === 'central-work-item-fanout'
-        ? path.join(MINIONS_DIR, 'work-items.json')
-        : meta.project?.name ? path.join(MINIONS_DIR, 'projects', meta.project.name, 'work-items.json') : null;
-      if (wiPath) {
-        const items = safeJson(wiPath) || [];
-        const wi = items.find(i => i.id === meta.item.id);
-        if (wi) retries = (wi._retryCount || 0); // Use fresh value from file
-      }
-    } catch { /* optional */ }
-
-    if (retries < 3) {
-      log('info', `Agent failed for ${meta.item.id} — auto-retry ${retries + 1}/3`);
-      updateWorkItemStatus(meta, 'pending', '');
+    const wiPath = resolveWiPath(meta);
+    if (wiPath) {
+      let finalStatus = null;
       try {
-        const wiPath = meta.source === 'central-work-item' || meta.source === 'central-work-item-fanout'
-          ? path.join(MINIONS_DIR, 'work-items.json')
-          : meta.project?.name ? path.join(MINIONS_DIR, 'projects', meta.project.name, 'work-items.json') : null;
-        if (wiPath) {
-          const items = safeJson(wiPath) || [];
+        mutateJsonFileLocked(wiPath, (items) => {
+          if (!Array.isArray(items)) return items;
           const wi = items.find(i => i.id === meta.item.id);
-          if (wi) {
-            wi._retryCount = retries + 1; wi.status = 'pending'; delete wi.dispatched_at; delete wi.dispatched_to;
-            if (type === 'decompose') delete wi._decomposing; // clear so item can retry decomposition
-            shared.safeWrite(wiPath, items);
+          if (!wi) return items;
+
+          const retries = wi._retryCount || 0;
+          if (retries < 3) {
+            log('info', `Agent failed for ${meta.item.id} — auto-retry ${retries + 1}/3`);
+            wi._retryCount = retries + 1;
+            wi.status = 'pending';
+            delete wi.dispatched_at;
+            delete wi.dispatched_to;
+            finalStatus = 'pending';
+          } else {
+            wi.status = 'failed';
+            wi.failReason = 'Agent failed (3 retries exhausted)';
+            wi.failedAt = ts();
+            finalStatus = 'failed';
           }
-        }
+          if (type === 'decompose') delete wi._decomposing;
+          return items;
+        });
       } catch (err) { log('warn', `Retry update: ${err.message}`); }
-    } else {
-      updateWorkItemStatus(meta, 'failed', 'Agent failed (3 retries exhausted)');
-    }
-    // Clear _decomposing flag on failure so item doesn't get permanently stuck
-    if (type === 'decompose') {
-      try {
-        const wiPath = meta.source === 'central-work-item' || meta.source === 'central-work-item-fanout'
-          ? path.join(MINIONS_DIR, 'work-items.json')
-          : meta.project?.name ? path.join(MINIONS_DIR, 'projects', meta.project.name, 'work-items.json') : null;
-        if (wiPath) {
-          const items = safeJson(wiPath) || [];
-          const wi = items.find(i => i.id === meta.item.id);
-          if (wi) { delete wi._decomposing; shared.safeWrite(wiPath, items); }
-        }
-      } catch (err) { log('warn', `Decompose cleanup: ${err.message}`); }
+      // Sync status to PRD outside the work-items lock
+      if (finalStatus) {
+        syncPrdItemStatus(meta.item.id, finalStatus, meta.item?.sourcePlan);
+      }
     }
   }
   // Meeting post-completion: collect findings/debate/conclusion
@@ -1418,7 +1432,7 @@ function runPostCompletionHooks(dispatchItem, agentId, code, stdout, config) {
   }
 
   // Detect implement tasks that completed without creating a PR
-  if (isSuccess && (type === 'implement' || type === 'implement:large' || type === 'fix') && prsCreatedCount === 0 && meta?.item?.id) {
+  if (isSuccess && (type === 'implement' || type === 'implement:large' || type === 'fix') && prsCreatedCount === 0 && meta?.item?.id && !meta?.item?.skipPr) {
     // Check if a PR already exists linked to this work item (from a previous attempt)
     const projects = shared.getProjects(config);
     const existingPrFound = Object.values(getPrLinks()).includes(meta.item.id);
@@ -1511,6 +1525,7 @@ module.exports = {
   updateWorkItemStatus,
   syncPrdItemStatus,
   syncPrsFromOutput,
+  resolveProjectForPr,
   updatePrAfterReview,
   updatePrAfterFix,
   handlePostMerge,

package/engine/playbook.js

@@ -478,7 +478,7 @@ function selectPlaybook(workType, item) {
   if (workType === 'review' && !item?._pr && !item?.pr_id) {
     return 'work-item';
   }
-  const typeSpecificPlaybooks = ['explore', 'review', 'test', 'plan-to-prd', 'plan', 'ask', 'verify', 'decompose', 'meeting-investigate', 'meeting-debate', 'meeting-conclude'];
+  const typeSpecificPlaybooks = ['explore', 'review', 'test', 'plan-to-prd', 'plan', 'ask', 'verify', 'evaluate', 'decompose', 'meeting-investigate', 'meeting-debate', 'meeting-conclude'];
   return typeSpecificPlaybooks.includes(workType) ? workType : 'work-item';
 }
 

package/engine/queries.js

@@ -506,9 +506,7 @@ function getWorkItems(config) {
     pending: 0,
     queued: 0,
     dispatched: 1,
-    'in-pr': 3, // backward compat — treated as done
     done: 3,
-    implemented: 3,
     failed: 4,
     paused: 5,
   };
@@ -627,7 +625,7 @@ function getPrdInfo(config) {
 
   const byStatus = {};
   items.forEach(item => { const s = item.status || 'missing'; byStatus[s] = byStatus[s] || []; byStatus[s].push(item); });
-  const complete = (byStatus['done'] || []).length + (byStatus['in-pr'] || []).length; // in-pr counted as done for backward compat
+  const complete = (byStatus['done'] || []).length;
   const inProgress = (byStatus['in-progress'] || []).length;
   const paused = (byStatus['paused'] || []).length;
   const missing = (byStatus['missing'] || []).length;
@@ -641,7 +639,7 @@ function getPrdInfo(config) {
     const t = planTimings[wi.sourcePlan];
     if (wi.dispatched_at) { const d = new Date(wi.dispatched_at).getTime(); if (!t.firstDispatched || d < t.firstDispatched) t.firstDispatched = d; }
     if (wi.completedAt) { const c = new Date(wi.completedAt).getTime(); if (!t.lastCompleted || c > t.lastCompleted) t.lastCompleted = c; }
-    if (wi.status !== 'done' && wi.status !== 'in-pr') t.allDone = false; // in-pr treated as done for backward compat
+    if (wi.status !== 'done') t.allDone = false;
   }
 
   const progress = {

package/engine.js

@@ -743,7 +743,7 @@ function areDependenciesMet(item, config) {
     } catch (e) { log('warn', 'read project work items for deps: ' + e.message); }
   }
   // PRD item statuses that count as "done" for dep resolution
-  const PRD_MET_STATUSES = new Set(['done', 'in-pr', 'implemented', 'complete']);
+  const PRD_MET_STATUSES = new Set(['done']);
 
   for (const depId of deps) {
     const depItem = allWorkItems.find(w => w.id === depId);
@@ -977,7 +977,7 @@ function materializePlansAsWorkItems(config) {
             log('info', `PRD ${file} invalidated (was awaiting-approval) — queuing regeneration from revised plan`);
 
             // Collect completed items to carry over to new PRD
-            const completedStatuses = new Set(['done', 'in-pr', 'implemented']); // in-pr kept for backward compat
+            const completedStatuses = new Set(['done']);
             const completedItems = (plan.missing_features || [])
               .filter(f => completedStatuses.has(f.status))
               .map(f => ({ id: f.id, name: f.name, status: f.status }));
@@ -1057,7 +1057,7 @@ function materializePlansAsWorkItems(config) {
     const useCentral = !defaultProject;
 
     const statusFilter = ['missing', 'planned'];
-    // Also materialize in-pr/done items that never got a work item (race with PR status sync)
+    // Also materialize done items that never got a work item (race with PR status sync)
     const allExistingWiIds = new Set();
     for (const p of allProjects) {
       for (const w of (safeJson(projectWorkItemsPath(p)) || [])) {
@@ -1070,7 +1070,7 @@ function materializePlansAsWorkItems(config) {
     }
     const items = plan.missing_features.filter(f =>
       statusFilter.includes(f.status) ||
-      ((f.status === 'in-pr' || f.status === 'done') && f.id && !allExistingWiIds.has(f.id))
+      (f.status === 'done' && f.id && !allExistingWiIds.has(f.id))
     );
 
     // Group items by target project (per-item project field overrides plan-level project)
@@ -2203,7 +2203,7 @@ async function tickInner() {
     try { await ghPollPrStatus(config); } catch (err) { log('warn', `GitHub PR status poll error: ${err?.message || err}${err?.stack ? ' | ' + err.stack.split('\n')[1]?.trim() : ''}`); }
     // Sync PR status back to PRD items (missing → done when active PR exists)
     try { syncPrdFromPrs(config); } catch (err) { log('warn', `PRD sync error: ${err?.message || err}`); }
-    // Check if any plans can be marked completed (all features done/in-pr)
+    // Check if any plans can be marked completed (all features done)
     try {
       const prdFiles = safeReadDir(PRD_DIR).filter(f => f.endsWith('.json'));
       for (const file of prdFiles) {

package/package.json

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