@yemi33/minions 0.1.1907 → 0.1.1908

package/engine/lifecycle.js

@@ -2998,6 +2998,93 @@ function writeNonCleanAgentReport(dispatchItem, agentId, outcome, structuredComp
   shared.writeToInbox(agentId || 'engine', `agent-${outcome}-${dispatchItem.id}`, content, null, metadata);
 }
 
+/**
+ * Permissively pull all assistant-message content out of a stream-json log.
+ *
+ * The standard runtime parsers (engine/runtimes/*.parseOutput) intentionally drop
+ * `assistant.message` content when the same event also carries `toolRequests`
+ * (so a "I'll create files now" preamble doesn't leak into the user-visible
+ * result text). For decompose dispatches the JSON block IS the deliverable, so
+ * if the agent emits the block in the same turn it issues a tool call (very
+ * common — the agent writes a sidecar note in the same turn) the standard
+ * parser drops the entire JSON and decomposition silently produces no children
+ * (W-mp3d2e6u000i9ca9). This helper concatenates EVERY content/deltaContent
+ * chunk regardless of toolRequests so the JSON-block regex can find it.
+ *
+ * Returns '' when raw is empty or contains no parseable assistant content.
+ */
+function _collectAllAssistantContent(raw) {
+  const safeRaw = raw == null ? '' : String(raw);
+  if (!safeRaw) return '';
+  const parts = [];
+  for (const rawLine of safeRaw.split('\n')) {
+    const line = rawLine.trim();
+    if (!line || !line.startsWith('{')) continue;
+    let obj;
+    try { obj = JSON.parse(line); } catch { continue; }
+    if (!obj || typeof obj !== 'object') continue;
+    const type = obj.type;
+    // Copilot stream-json: {type:'assistant.message',data:{content,toolRequests}}
+    if (type === 'assistant.message' || type === 'assistant.message_delta') {
+      const c = obj.data?.content;
+      if (typeof c === 'string' && c) parts.push(c);
+      const d = obj.data?.deltaContent;
+      if (typeof d === 'string' && d) parts.push(d);
+    }
+    // Claude stream-json: {type:'assistant',message:{content:[{type:'text',text}]}}
+    if (type === 'assistant' && obj.message?.content) {
+      const blocks = Array.isArray(obj.message.content) ? obj.message.content : [];
+      for (const b of blocks) {
+        if (b?.type === 'text' && typeof b.text === 'string' && b.text) parts.push(b.text);
+      }
+    }
+  }
+  return parts.join('');
+}
+
+/**
+ * Extract a decomposition object ({parent_id, sub_items}) from raw agent stdout.
+ *
+ * Strategy:
+ *   1. Try the standard runtime parser first (preserves existing behavior when
+ *      the agent emits the block in a content-only turn).
+ *   2. Fall back to a permissive scan that joins ALL assistant content. This
+ *      catches the common case where the agent emits the JSON block in the
+ *      same turn as a tool call (which the standard parser drops).
+ *
+ * In both passes, scan ALL ```json fenced blocks and pick the first one whose
+ * parsed body has a non-empty `sub_items` (or `subItems`) array. This is more
+ * robust than picking the first match — agents sometimes emit example/spec
+ * JSON blocks before the real decomposition output.
+ *
+ * Returns the parsed decomposition object, or null if none found.
+ * Exported for unit testing.
+ */
+function extractDecompositionJson(stdout, runtimeName) {
+  const candidates = [];
+  try {
+    const parsed = shared.parseStreamJsonOutput(stdout, runtimeName);
+    if (parsed?.text) candidates.push(parsed.text);
+  } catch { /* runtime resolution failure — fall through to permissive scan */ }
+  const permissive = _collectAllAssistantContent(stdout);
+  if (permissive && permissive !== candidates[0]) candidates.push(permissive);
+
+  const blockRe = /```json\s*\n([\s\S]*?)```/g;
+  for (const text of candidates) {
+    if (!text) continue;
+    blockRe.lastIndex = 0;
+    let m;
+    while ((m = blockRe.exec(text)) !== null) {
+      let parsed;
+      try { parsed = JSON.parse(m[1]); }
+      catch { continue; }
+      const subs = parsed?.sub_items || parsed?.subItems;
+      if (Array.isArray(subs) && subs.length > 0) return parsed;
+    }
+  }
+  return null;
+}
+
 /**
  * Handle decomposition result — parse sub-items from agent output and create child work items.
  * Called from runPostCompletionHooks when type === 'decompose'.
@@ -3007,19 +3094,9 @@ function handleDecompositionResult(stdout, meta, config, runtimeName) {
   const parentId = meta?.item?.id;
   if (!parentId) return 0;
 
-  // Parse sub-items JSON from agent output
-  const { text } = shared.parseStreamJsonOutput(stdout, runtimeName);
-  const jsonMatch = text.match(/```json\s*\n([\s\S]*?)```/);
-  if (!jsonMatch) {
-    log('warn', `Decomposition for ${parentId}: no JSON block found in output`);
-    return 0;
-  }
-
-  let decomposition;
-  try {
-    decomposition = JSON.parse(jsonMatch[1]);
-  } catch (err) {
-    log('warn', `Decomposition for ${parentId}: invalid JSON — ${err.message}`);
+  const decomposition = extractDecompositionJson(stdout, runtimeName);
+  if (!decomposition) {
+    log('warn', `Decomposition for ${parentId}: no usable JSON block found in output`);
     return 0;
   }
 
@@ -3171,8 +3248,33 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
   let skipDoneStatus = false;
   if (type === WORK_TYPE.DECOMPOSE && effectiveSuccess && meta?.item?.id) {
     const subCount = handleDecompositionResult(stdout, meta, config, runtimeName);
-    if (subCount > 0) skipDoneStatus = true; // parent already marked 'decomposed' by handler
-    // If decomposition produced nothing, fall through to mark parent as done
+    if (subCount > 0) {
+      skipDoneStatus = true; // parent already marked 'decomposed' by handler
+    } else {
+      // Decompose claimed success but produced no children. Marking the parent
+      // DONE here would silently terminate an implement:large item with zero
+      // PRs (W-mp3d2e6u000i9ca9). Instead: clear _decomposing so the next
+      // discoverFromWorkItems pass can re-enter the decompose flow, and skip
+      // the DONE update so the parent stays pending. The dispatch retry layer
+      // will requeue it through the standard cooldown/backoff path.
+      skipDoneStatus = true;
+      const wiPath = resolveWorkItemPath(meta);
+      if (wiPath) {
+        try {
+          mutateJsonFileLocked(wiPath, data => {
+            if (!Array.isArray(data)) return data;
+            const wi = data.find(i => i.id === meta.item.id);
+            if (wi) {
+              delete wi._decomposing;
+              wi._lastDecomposeFailure = ts();
+              wi._pendingReason = 'decompose_no_children';
+            }
+            return data;
+          }, { skipWriteIfUnchanged: true });
+        } catch (err) { log('warn', `Decompose retry-prep cleanup: ${err.message}`); }
+      }
+      log('warn', `Decomposition for ${meta.item.id}: success report but no children created — parent left pending for retry`);
+    }
   }
 
   // Verify review work items include a verdict — must run BEFORE updateWorkItemStatus(DONE),
@@ -3764,4 +3866,6 @@ module.exports = {
   processPendingRebases,
   findDependentActivePrs,
   isPrAttachmentRequired,
+  extractDecompositionJson,
+  handleDecompositionResult,
 };

package/package.json

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

package/engine/copilot-models.json

@@ -1,5 +0,0 @@
-{
-  "runtime": "copilot",
-  "models": null,
-  "cachedAt": "2026-05-12T22:39:24.196Z"
-}