@yemi33/minions 0.1.1649 → 0.1.1650

package/CHANGELOG.md

@@ -1,11 +1,13 @@
 # Changelog
 
-## 0.1.1649 (2026-05-01)
+## 0.1.1650 (2026-05-01)
 
 ### Features
+- reject premature task_complete for nonterminal summaries
 - ADO build poll repositoryId GUID handling
 
 ### Fixes
+- yemi33/minions#1927
 - yemi33/minions#1925
 
 ## 0.1.1648 (2026-05-01)

package/engine/copilot-models.json

@@ -1,5 +1,5 @@
 {
   "runtime": "copilot",
   "models": null,
-  "cachedAt": "2026-05-01T01:27:16.930Z"
+  "cachedAt": "2026-05-01T01:28:04.266Z"
 }

package/engine/lifecycle.js

@@ -1704,6 +1704,119 @@ function normalizeCompletionStatus(status) {
   return String(status || '').trim().toLowerCase().replace(/[\s_]+/g, '-');
 }
 
+function isTerminalPendingValue(value) {
+  const text = String(value || '').trim().toLowerCase();
+  if (!text) return true;
+  return /^(?:none|n\/a|na|no|nothing|not-applicable|not applicable|-)$/.test(text)
+    || /^no\s+(?:pending|remaining|outstanding)\b/.test(text)
+    || /^(?:all\s+)?(?:pending|remaining|outstanding)\s+(?:work|items?|tasks?)?\s*(?:resolved|complete|completed|done|closed)$/.test(text);
+}
+
+function isTerminalPendingLine(line) {
+  const text = String(line || '').trim().toLowerCase();
+  return /\bno\s+pending\b/.test(text)
+    || /\bpending\s*[:=-]\s*(?:none|n\/a|na|no|nothing|not applicable|-)\b/.test(text)
+    || /\bpending\s+(?:work|items?|tasks?)?\s*(?:resolved|complete|completed|done|closed)\b/.test(text);
+}
+
+function detectNonTerminalResultSummary(resultSummary, structuredCompletion) {
+  const completionStatus = normalizeCompletionStatus(structuredCompletion?.status);
+  if (completionStatus) {
+    if (/^(?:partial|partially-complete|in-progress|pending|deferred|blocked|incomplete|to-be-continued)/.test(completionStatus)) {
+      return {
+        phrase: `status:${structuredCompletion.status}`,
+        reason: `Nonterminal completion summary: structured status is '${structuredCompletion.status}'`,
+      };
+    }
+    if (/^(?:fail|failed|failure|error)/.test(completionStatus)) {
+      return {
+        phrase: `status:${structuredCompletion.status}`,
+        reason: `Nonterminal completion summary: structured status is '${structuredCompletion.status}', not a successful terminal state`,
+      };
+    }
+  }
+
+  if (structuredCompletion?.pending && !isTerminalPendingValue(structuredCompletion.pending)) {
+    return {
+      phrase: 'pending',
+      reason: `Nonterminal completion summary: pending work remains (${String(structuredCompletion.pending).slice(0, 160)})`,
+    };
+  }
+
+  const text = String(resultSummary || '').replace(/\r/g, '').trim();
+  if (!text) return null;
+
+  const patterns = [
+    { phrase: 'still running', re: /\b(?:still|currently|continues?\s+to\s+be)\s+(?:running|ongoing|in\s+progress)\b/i },
+    { phrase: 'will check later', re: /\b(?:i(?:'|’)ll|i\s+will|we(?:'|’)ll|we\s+will|will)\s+(?:check|verify|review|follow\s+up|revisit)\s+(?:again\s+)?(?:later|soon|in\b|after\b|when\b)/i },
+    { phrase: 'wake up', re: /\bwake(?:\s|-)?up\b|\bwake\b.*\b(?:check|verify|review)\b/i },
+    { phrase: 'not yet complete', re: /\b(?:not\s+yet|isn(?:'|’)t|not|incomplete|not\s+fully|not\s+completely)\s+(?:complete|completed|done|finished|validated|verified)\b/i },
+    { phrase: 'partial', re: /\bpartial(?:ly)?\b/i },
+    { phrase: 'to be continued', re: /\bto\s+be\s+continued\b|\btbc\b/i },
+    { phrase: 'in progress', re: /\bin\s+progress\b|\bongoing\b|\bincomplete\b/i },
+  ];
+  for (const { phrase, re } of patterns) {
+    if (re.test(text)) {
+      return { phrase, reason: `Nonterminal completion summary: matched '${phrase}'` };
+    }
+  }
+
+  const pendingLines = text.split('\n').filter(line => /\bpending\b/i.test(line));
+  for (const line of pendingLines) {
+    if (!isTerminalPendingLine(line)) {
+      return { phrase: 'pending', reason: `Nonterminal completion summary: matched 'pending'` };
+    }
+  }
+
+  return null;
+}
+
+function deferNonTerminalCompletion(meta, detection) {
+  const itemId = meta?.item?.id;
+  const reason = detection?.reason || 'Nonterminal completion summary';
+  if (!itemId) return reason;
+  const wiPath = resolveWorkItemPath(meta);
+  if (!wiPath) return reason;
+
+  let finalStatus = WI_STATUS.PENDING;
+  try {
+    mutateJsonFileLocked(wiPath, data => {
+      if (!Array.isArray(data)) return data;
+      const w = data.find(i => i.id === itemId);
+      if (!w) return data;
+      const retries = w._retryCount || 0;
+      if (retries < ENGINE_DEFAULTS.maxRetries) {
+        w.status = WI_STATUS.PENDING;
+        w._retryCount = retries + 1;
+        w._lastRetryAt = ts();
+        w._lastRetryReason = reason;
+        w._pendingReason = 'nonterminal_completion';
+        delete w.completedAt;
+        delete w.dispatched_at;
+        delete w.dispatched_to;
+        delete w.failedAt;
+        finalStatus = WI_STATUS.PENDING;
+        log('warn', `Work item ${itemId} reported nonterminal success — retry ${retries + 1}/${ENGINE_DEFAULTS.maxRetries}: ${reason}`);
+      } else {
+        w.status = WI_STATUS.FAILED;
+        w.failReason = `${reason} after ${ENGINE_DEFAULTS.maxRetries} attempts`;
+        w.failedAt = ts();
+        delete w.completedAt;
+        delete w.dispatched_at;
+        delete w.dispatched_to;
+        delete w._pendingReason;
+        finalStatus = WI_STATUS.FAILED;
+        log('warn', `Work item ${itemId} failed — repeated nonterminal completion summaries after ${ENGINE_DEFAULTS.maxRetries} attempts`);
+      }
+      return data;
+    }, { defaultValue: [], skipWriteIfUnchanged: true });
+    syncPrdItemStatus(itemId, finalStatus, meta.item?.sourcePlan);
+  } catch (err) {
+    log('warn', `nonterminal completion gate: ${err.message}`);
+  }
+  return reason;
+}
+
 function writeNonCleanAgentReport(dispatchItem, agentId, outcome, structuredCompletion, resultSummary, exitCode) {
   if (!dispatchItem?.id || !outcome) {
     log('warn', 'Cannot write non-clean agent report without dispatch id and outcome');
@@ -1840,6 +1953,7 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
   // (P-2a6d9c4f, P-9c4f2d6a) populate dispatchItem.meta.runtimeName at spawn time.
   const runtimeName = dispatchItem.meta?.runtimeName || dispatchItem.runtimeName || 'claude';
   const { resultSummary, taskUsage, sessionId, model } = parseAgentOutput(stdout, runtimeName);
+  const completionGateSummary = resultSummary || (typeof stdout === 'string' && !stdout.includes('"type":') ? stdout : '');
 
   // Try structured completion protocol first (```completion block from agent output)
   const structuredCompletion = parseStructuredCompletion(stdout, runtimeName);
@@ -1878,9 +1992,11 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
   const effectiveSuccess = isSuccess || autoRecovered;
 
   const completionStatus = normalizeCompletionStatus(structuredCompletion?.status);
+  let nonCleanReportWritten = false;
   if (completionStatus.startsWith('partial') || autoRecovered || (completionStatus.startsWith('fail') && isSuccess)) {
     const outcome = completionStatus.startsWith('fail') ? 'failure' : 'partial';
-    writeNonCleanAgentReport(dispatchItem, agentId, outcome, structuredCompletion, resultSummary, code);
+    writeNonCleanAgentReport(dispatchItem, agentId, outcome, structuredCompletion, completionGateSummary, code);
+    nonCleanReportWritten = true;
   }
 
   // Handle decomposition results — create sub-items from decompose agent output
@@ -1987,6 +2103,18 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
   }
 
   let completionContractFailure = null;
+  if (effectiveSuccess && meta?.item?.id && !skipDoneStatus) {
+    const nonTerminalCompletion = detectNonTerminalResultSummary(completionGateSummary, structuredCompletion);
+    if (nonTerminalCompletion) {
+      skipDoneStatus = true;
+      const reason = deferNonTerminalCompletion(meta, nonTerminalCompletion);
+      completionContractFailure = { reason, itemId: meta.item.id, nonTerminal: true };
+      if (!nonCleanReportWritten) {
+        writeNonCleanAgentReport(dispatchItem, agentId, 'partial', structuredCompletion, completionGateSummary, code);
+      }
+    }
+  }
+
   if (effectiveSuccess && meta?.item?.id && !skipDoneStatus) {
     completionContractFailure = await enforcePrAttachmentContract(type, meta, agentId, config, resultSummary);
     if (completionContractFailure) skipDoneStatus = true;
@@ -2322,6 +2450,7 @@ module.exports = {
   parseReviewVerdict,
   isReviewBailout,
   parseStructuredCompletion,
+  detectNonTerminalResultSummary,
   runPostCompletionHooks,
   syncPrdFromPrs,
   resolveWorkItemPath,

package/engine/timeout.js

@@ -147,7 +147,7 @@ function checkTimeouts(config) {
   const engineRestartGraceUntil = engine().engineRestartGraceUntil;
   const engineRestartGraceExempt = engine().engineRestartGraceExempt;
   const { completeDispatch } = dispatch();
-  const { runPostCompletionHooks } = require('./lifecycle');
+  const { runPostCompletionHooks, parseAgentOutput, parseStructuredCompletion, detectNonTerminalResultSummary } = require('./lifecycle');
 
   const timeout = config.engine?.agentTimeout || ENGINE_DEFAULTS.agentTimeout;
   const defaultStaleOrphanTimeout = config.engine?.heartbeatTimeout || ENGINE_DEFAULTS.heartbeatTimeout;
@@ -257,12 +257,25 @@ function checkTimeouts(config) {
           safeWrite(outputLogPath, `# Output for dispatch ${item.id}\n# Exit code: ${processExitCode}\n# Completed: ${ts()}\n# Detected via output scan\n\n## Result\n${text || '(no text)'}\n`);
         } catch (e) { log('warn', 'parse output result: ' + e.message); }
 
-        completeDispatch(item.id, isSuccess ? DISPATCH_RESULT.SUCCESS : DISPATCH_RESULT.ERROR,
-          isSuccess ? 'Completed (detected from output)' : `Exited with code ${processExitCode} (detected from output)`);
+        const fullLogForHooks = safeRead(liveLogPath) || liveLogTail;
+        let completionDetection = null;
+        let outputResultSummary = '';
+        try {
+          const runtimeName = item.meta?.runtimeName || item.runtimeName || 'claude';
+          outputResultSummary = parseAgentOutput(fullLogForHooks, runtimeName).resultSummary || '';
+          const gateSummary = outputResultSummary || (!fullLogForHooks.includes('"type":') ? fullLogForHooks : '');
+          completionDetection = isSuccess
+            ? detectNonTerminalResultSummary(gateSummary, parseStructuredCompletion(fullLogForHooks, runtimeName))
+            : null;
+        } catch (e) { log('warn', 'completion summary gate: ' + e.message); }
+
+        completeDispatch(item.id, completionDetection ? DISPATCH_RESULT.ERROR : (isSuccess ? DISPATCH_RESULT.SUCCESS : DISPATCH_RESULT.ERROR),
+          completionDetection ? completionDetection.reason : (isSuccess ? 'Completed (detected from output)' : `Exited with code ${processExitCode} (detected from output)`),
+          outputResultSummary,
+          completionDetection ? { processWorkItemFailure: false } : {});
 
         // Run post-completion hooks via shared helper (async — fire and forget in timeout context).
         // Pass the actual exit code so autoRecovery (PR-created-but-failed) still works correctly.
-        const fullLogForHooks = safeRead(liveLogPath) || liveLogTail;
         runPostCompletionHooks(item, item.agent, processExitCode, fullLogForHooks, config).catch(e => log('warn', 'post-completion hooks: ' + e.message));
 
         if (hasProcess) {

package/package.json

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