@yemi33/minions 0.1.2338 → 0.1.2339

package/engine.js

@@ -10645,55 +10645,84 @@ async function tickInner() {
 
   // Dispatch items — spawnAgent moves each from pending→active on disk.
   // We use the already-loaded item objects; spawnAgent handles the state transition.
+  //
+  // W-mr9o1oe0001c4601 — Spawn all claimed items for this tick CONCURRENTLY
+  // rather than awaiting each spawnAgent serially. `spawnAgent` does real
+  // wall-clock work per item (prompt build + `git worktree add`, which on a
+  // ~250k-file monorepo can take multiple seconds), so the old sequential loop
+  // made eager routing (engine/routing.js already fans work across every idle
+  // agent in a single allocation pass) visibly "trickle in" one agent at a time,
+  // contradicting the stated eager-dispatch design. `toDispatch` is already
+  // bounded by `slotsAvailable` (≤ maxConcurrent — the seed loop above decrements
+  // `generalSlots` and stops pushing at 0), so an unbounded Promise.allSettled
+  // here is naturally capped; no dedicated spawn-concurrency knob is needed.
+  // Concurrent `git worktree add` against the same repo is safe on this codebase:
+  // each worktree gets its own `.git/worktrees/<name>` metadata dir, and
+  // runWorktreeAdd already retries the exact lock-contention errors
+  // (`index.lock`, `could not lock`, `resource busy`, `already exists`) that
+  // concurrent adds can transiently produce. The per-project live-checkout gate
+  // (liveProjectsInUse) already caps live-mode projects to one mutating dispatch,
+  // so concurrent in-place writes to one operator checkout cannot happen here.
   const dispatched = new Set();
-  for (const item of toDispatch) {
-    if (!dispatched.has(item.id)) {
-      let proc;
-      try { proc = await spawnAgent(item, config); } catch (spawnErr) {
-        log('error', `spawnAgent exception for ${item.id}: ${spawnErr.message}`);
-        proc = null;
-      }
-      if (_isTickStale(myGeneration)) return;
-      if (proc === null) {
-        // spawnAgent failed (e.g., worktree creation error). It already called
-        // completeDispatch internally which handles retry logic, but log at the
-        // dispatch-loop level for visibility and handle any edge cases where
-        // completeDispatch wasn't called.
-        log('error', `spawnAgent returned null for ${item.id} (${item.type} → ${item.agent}) — spawn failed`);
-        // Defensive: ensure the work item is re-queued if completeDispatch didn't fire
-        if (item.meta?.item?.id) {
-          try {
-            const wiPath = item.meta.source === 'central-work-item' || item.meta.source === 'central-work-item-fanout'
-              ? path.join(ENGINE_DIR, '..', 'work-items.json')
-              : item.meta.project?.name ? projectWorkItemsPath({ name: item.meta.project.name, localPath: item.meta.project.localPath }) : null;
-            if (wiPath) {
-              if (_isTickStale(myGeneration)) return;
-              mutateWorkItems(wiPath, items => {
-                const wi = items.find(i => i.id === item.meta.item.id);
-                if (wi && wi.status === WI_STATUS.DISPATCHED) {
-                  // completeDispatch didn't update the work item — re-queue manually
-                  wi.status = WI_STATUS.PENDING;
-                  wi._retryCount = (wi._retryCount || 0) + 1;
-                  wi._lastRetryReason = 'spawnAgent returned null';
-                  wi._lastRetryAt = ts();
-                  delete wi.dispatched_at;
-                  delete wi.dispatched_to;
-                  log('info', `Re-queued ${item.meta.item.id} as pending (retry ${wi._retryCount})`);
-                }
-              });
-            }
-          } catch (e) { log('warn', `Failed to re-queue work item after spawn failure: ${e.message}`); }
-        }
-      } else {
-        dispatched.add(item.id);
-        // Sync PRD item status after successful spawn (#480)
-        if (item.meta?.item?.sourcePlan) {
-          try { syncPrdItemStatus(item.meta.item.id, WI_STATUS.DISPATCHED, item.meta.item.sourcePlan); }
-          catch (e) { log('warn', `prd sync after spawn: ${e.message}`); }
-        }
+  const spawnOneItem = async (item) => {
+    // Dedup by id (toDispatch is already deduped by seenPendingIds — defensive).
+    if (dispatched.has(item.id)) return;
+    // Staleness: if a newer tick force-released this one while we were building
+    // the batch, don't spawn a stale tick's agents.
+    if (_isTickStale(myGeneration)) return;
+    let proc;
+    try { proc = await spawnAgent(item, config); } catch (spawnErr) {
+      log('error', `spawnAgent exception for ${item.id}: ${spawnErr.message}`);
+      proc = null;
+    }
+    // A newer tick may have superseded us mid-spawn — don't mutate shared state.
+    if (_isTickStale(myGeneration)) return;
+    if (proc === null) {
+      // spawnAgent failed (e.g., worktree creation error). It already called
+      // completeDispatch internally which handles retry logic, but log at the
+      // dispatch-loop level for visibility and handle any edge cases where
+      // completeDispatch wasn't called.
+      log('error', `spawnAgent returned null for ${item.id} (${item.type} → ${item.agent}) — spawn failed`);
+      // Defensive: ensure the work item is re-queued if completeDispatch didn't fire
+      if (item.meta?.item?.id) {
+        try {
+          const wiPath = item.meta.source === 'central-work-item' || item.meta.source === 'central-work-item-fanout'
+            ? path.join(ENGINE_DIR, '..', 'work-items.json')
+            : item.meta.project?.name ? projectWorkItemsPath({ name: item.meta.project.name, localPath: item.meta.project.localPath }) : null;
+          if (wiPath) {
+            if (_isTickStale(myGeneration)) return;
+            mutateWorkItems(wiPath, items => {
+              const wi = items.find(i => i.id === item.meta.item.id);
+              if (wi && wi.status === WI_STATUS.DISPATCHED) {
+                // completeDispatch didn't update the work item — re-queue manually
+                wi.status = WI_STATUS.PENDING;
+                wi._retryCount = (wi._retryCount || 0) + 1;
+                wi._lastRetryReason = 'spawnAgent returned null';
+                wi._lastRetryAt = ts();
+                delete wi.dispatched_at;
+                delete wi.dispatched_to;
+                log('info', `Re-queued ${item.meta.item.id} as pending (retry ${wi._retryCount})`);
+              }
+            });
+          }
+        } catch (e) { log('warn', `Failed to re-queue work item after spawn failure: ${e.message}`); }
+      }
+    } else {
+      dispatched.add(item.id);
+      // Sync PRD item status after successful spawn (#480)
+      if (item.meta?.item?.sourcePlan) {
+        try { syncPrdItemStatus(item.meta.item.id, WI_STATUS.DISPATCHED, item.meta.item.sourcePlan); }
+        catch (e) { log('warn', `prd sync after spawn: ${e.message}`); }
       }
     }
-  }
+  };
+  // Promise.allSettled: one item's spawn failure never affects another's, and
+  // each spawnOneItem already swallows its own errors (per-item try/catch), so a
+  // rejected task here is not expected — allSettled is belt-and-suspenders.
+  await Promise.allSettled(toDispatch.map((item) => spawnOneItem(item)));
+  // A force-release may have superseded this tick while spawns were in flight —
+  // abort before the downstream skip-reason annotation reads/mutates shared state.
+  if (_isTickStale(myGeneration)) return;
 
   // Annotate remaining pending items with skipReason so dashboard can show why they're waiting.
   // Re-read dispatch after spawns (spawnAgent moves items from pending→active).

package/package.json

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