@yemi33/minions 0.1.2285 → 0.1.2287

package/engine/runtimes/copilot.js

@@ -433,6 +433,17 @@ function _mapEffort(level) {
 // `fallbackModel` opts are silently ignored (their capability flags are false
 // so engine code shouldn't pass them, but we tolerate them gracefully).
 
+// Map MIME type to file extension for --attachment temp file naming.
+const _MIME_EXT = {
+  'image/png': 'png',
+  'image/jpeg': 'jpg',
+  'image/gif': 'gif',
+  'image/webp': 'webp',
+};
+function _mimeToExt(mimeType) {
+  return _MIME_EXT[String(mimeType || '').toLowerCase()] || 'bin';
+}
+
 function buildArgs(opts = {}) {
   const {
     model,
@@ -445,6 +456,8 @@ function buildArgs(opts = {}) {
     suppressAgentsMd,
     reasoningSummaries,
     disabledMcpServers,
+    images,
+    tmpDir,
   } = opts;
 
   const args = [
@@ -498,6 +511,22 @@ function buildArgs(opts = {}) {
   // the `=`, commander.js treats the next token as a positional, not the value.
   if (sessionId) args.push(`--resume=${sessionId}`);
 
+  // W-mqv7324u0021db5d — image attachments. Write each base64 payload to a
+  // temp file in tmpDir and emit --attachment <path> (flag is repeatable).
+  // tmpDir is required; skip silently when absent so callers without image
+  // support don't crash (defense-in-depth on top of the caps.imageInput gate).
+  if (Array.isArray(images) && images.length && tmpDir) {
+    for (let i = 0; i < images.length; i++) {
+      const img = images[i];
+      if (!img || !img.dataBase64) continue;
+      const ext = _mimeToExt(img.mimeType);
+      const filename = `img-${i}-${Date.now().toString(36)}.${ext}`;
+      const filePath = path.join(tmpDir, filename);
+      fs.writeFileSync(filePath, Buffer.from(img.dataBase64, 'base64'));
+      args.push('--attachment', filePath);
+    }
+  }
+
   return args;
 }
 
@@ -1214,11 +1243,9 @@ const capabilities = {
   resumePromptCarryover: true,
   // Adapter implements createStreamConsumer(ctx) — required by llm.js accumulator
   streamConsumer: true,
-  // P-7b2e4d01: `--attachment <path>` is documented for non-interactive mode
-  // but the headless smoke test was inconclusive (spike P-3f8a1c92). Stub false
-  // until a clean re-test passes; enabling it also needs temp-file materializing
-  // of the base64 payload (a different adapter-local path than Claude's inline).
-  imageInput: false,
+  // `--attachment <path>` works in non-interactive mode (live-tested; see W-mqv7324u0021db5d).
+  // Base64 payloads are materialized to tmp files inside llmTmpDir before spawn.
+  imageInput: true,
 };
 
 // Install hint surfaced when `resolveBinary()` returns null. Covers all

package/engine/shared.js

@@ -1866,6 +1866,17 @@ function mutateJsonFileLocked(filePath, mutateFn, {
         try { if (fileExists) fs.copyFileSync(filePath, backupPath); } catch { /* backup is best-effort */ }
       }
       safeWrite(filePath, finalData);
+      // Phase 10 step 2 — dual-write PRD content to SQL. The single chokepoint:
+      // every prd/*.json mutation through mutateJsonFileLocked mirrors into the
+      // prds/prd_items/prd_verify_prs tables. JSON stays canonical (nothing
+      // reads SQL yet); this keeps the mirror trustworthy for the read-flip.
+      // BEST-EFFORT: parsePrdPath fast-rejects non-PRD paths, and a SQLite
+      // failure must never break the JSON write. mirrorPrdToSql swallows
+      // internally; the require is guarded for the (engine-agnostic) load order.
+      try {
+        const prdStore = require('./prd-store');
+        if (prdStore.parsePrdPath(filePath)) prdStore.mirrorPrdToSql(filePath, finalData);
+      } catch { /* mirror is best-effort — never break the canonical JSON write */ }
       // Side-effect hook fired only when an actual write happened. Callers
       // use this to emit cache-invalidation signals (events table row) so
       // skip-write-unchanged paths (dedup, idempotent no-op POSTs) don't
@@ -2635,12 +2646,21 @@ const CHECKOUT_MODES = Object.freeze({ WORKTREE: 'worktree', LIVE: 'live' });
 function resolveCheckoutMode(project, workItemType) {
   if (!project || typeof project !== 'object') return CHECKOUT_MODES.WORKTREE;
   const canonical = project.checkoutMode;
-  // liveValidation without checkoutMode: 'live' is a misconfiguration — warn and ignore.
-  if (project.liveValidation && canonical !== CHECKOUT_MODES.LIVE) {
+  // Resolve the effective mode: canonical field first, then legacy worktreeMode fallback.
+  let effectiveMode;
+  if (canonical === CHECKOUT_MODES.LIVE || canonical === CHECKOUT_MODES.WORKTREE) {
+    effectiveMode = canonical;
+  } else if (project.worktreeMode === 'live') {
+    effectiveMode = CHECKOUT_MODES.LIVE;
+  } else {
+    effectiveMode = CHECKOUT_MODES.WORKTREE;
+  }
+  // liveValidation without an effective live mode is a misconfiguration — warn and ignore.
+  if (project.liveValidation && effectiveMode !== CHECKOUT_MODES.LIVE) {
     log('warn', 'resolveCheckoutMode: liveValidation is set but checkoutMode is not "live" — liveValidation ignored',
       { projectName: project.name });
   }
-  if (canonical === CHECKOUT_MODES.LIVE) {
+  if (effectiveMode === CHECKOUT_MODES.LIVE) {
     // Apply liveValidation routing when the block is present and workItemType is provided.
     if (project.liveValidation && workItemType !== undefined) {
       return workItemType === project.liveValidation.type
@@ -2649,11 +2669,6 @@ function resolveCheckoutMode(project, workItemType) {
     }
     return CHECKOUT_MODES.LIVE;
   }
-  if (canonical === CHECKOUT_MODES.WORKTREE) return CHECKOUT_MODES.WORKTREE;
-  // Legacy field fallback (only consulted when checkoutMode is absent/unknown).
-  const legacy = project.worktreeMode;
-  if (legacy === 'live') return CHECKOUT_MODES.LIVE;
-  // legacy 'isolated' (and anything else) → the default worktree behavior.
   return CHECKOUT_MODES.WORKTREE;
 }
 
@@ -4387,6 +4402,7 @@ const FAILURE_CLASS = {
   SPAWN_PHASE_STALL: 'spawn-phase-stall', // W-mq0e2dae000a003d: process spawned and ran startup-only events (MCP init / hooks) but never emitted real task progress; CPU usage stayed below threshold past the grace window. Engine kills the wedged child and treats this as retryable (fresh-session) so a re-spawn can clear a transient MCP wedge.
   OUTPUT_TRUNCATED: 'output-truncated',   // P-8e4c2a17: the agent streamed more stdout than the engine's hard capture cap (engine.js AGENT_OUTPUT_CAP_BYTES, 1MB) BEFORE the terminal `result` event arrived. The result (session id, completion block, final text) lives at the END of the stream, so it fell outside the captured window and parseOutput found nothing — the dispatch would otherwise fail as an opaque UNKNOWN and retry to death. Surfaced loudly with an actionable message; non-retryable (mechanical retry just reproduces the overflow — the agent must reduce output volume or the task must be split).
   VERIFY_MISSING_PR: 'verify-missing-pr', // W-mqsk1ip00006cbae: a verify WI exited done but no PR was attached (neither _prUrl/_pr on the item nor a matching pull-requests.json entry for the plan). Flipped to failed so the plan doesn't silently advance without an E2E PR. Retryable — agent may have phantom-crashed before pushing the branch.
+  PROJECT_NOT_FOUND: 'project_not_found', // W-mqv2wsy30002e090: a work item's `project` field names a project that is not configured (resolveConfiguredProject / formatUnknownProjectError → `Project "<name>" not found. Known projects: …`). Stamped at discovery time so the dashboard PR-column renderer surfaces the red failReason snippet like other non-retryable failures instead of burying it in the Agent column. Non-retryable — operator must fix the WI's project field or configure the project.
   UNKNOWN: 'unknown',                     // Unclassified failure
 };
 

package/engine/watch-actions.js

@@ -562,7 +562,10 @@ registerActionType(WATCH_ACTION_TYPE.WEBHOOK, {
 // minions-api — first-class loopback API caller for the in-process dashboard.
 // Restricts `endpoint` to paths starting with `/api/` so a watch can't reach
 // external hosts (use `webhook` for that). Always targets
-// `http://127.0.0.1:${MINIONS_PORT||7331}${endpoint}` and sets
+// `http://127.0.0.1:${shared.readDashboardPortFile(MINIONS_DIR)?.port||7331}${endpoint}`
+// — the *actual* bound dashboard port from the dashboard-port.json beacon, not
+// the frozen MINIONS_PORT env (which stays at the requested value when the
+// dashboard falls back to 7332+ on EADDRINUSE) — and sets
 // `X-Minions-Internal: 1` so dashboard handlers can recognize that the
 // request originated from the engine's own action surface (Origin/Referer
 // are intentionally absent — the dashboard's origin gate already allows

package/engine.js

@@ -849,6 +849,7 @@ async function findExistingWorktree(repoDir, branchName) {
 }
 
 function isWorktreeRetryableError(err) {
+  if (err?._incompleteCheckout) return true;
   const msg = String(err?.message || '');
   return msg.includes('ETIMEDOUT')
     || msg.includes('index.lock')
@@ -957,6 +958,29 @@ async function runWorktreeAdd(rootDir, worktreePath, addArgs, gitOpts, worktreeC
         log('warn', `Retrying git worktree add (attempt ${attempt + 1}/${retries + 1}) for ${path.basename(worktreePath)}`);
       }
       await shared.shellSafeGit(['worktree', 'add', worktreePath, ...addArgs], { ...gitOpts, cwd: rootDir });
+      // W-mqvaxv65000m76f2 (issue #430, Layer 1) — GVFS partial-checkout guard.
+      // On large GVFS repos (e.g. 1JS with 296K files), `git worktree add`
+      // exits cleanly but only writes a .git file — no source files are checked
+      // out. The engine would otherwise treat the empty worktree as valid for
+      // reuse; the subsequent `git status` preflight fails (nothing to stat) and
+      // the dispatch loop recurs. Detect the empty checkout and throw a retriable
+      // error so the retry loop re-creates the worktree on the next attempt.
+      let worktreeEntries;
+      try { worktreeEntries = fs.readdirSync(worktreePath).filter(e => e !== '.git'); }
+      catch { worktreeEntries = null; } // If the read fails, skip the check — don't block normal cases.
+      if (worktreeEntries !== null && worktreeEntries.length === 0) {
+        log('warn', `runWorktreeAdd: GVFS partial checkout detected at ${worktreePath} (only .git written) — removing and retrying`);
+        try {
+          await shared.shellSafeGit(['worktree', 'remove', '--force', worktreePath], { ...gitOpts, cwd: rootDir, timeout: 30000 });
+        } catch (rmErr) {
+          log('warn', `runWorktreeAdd: worktree remove after partial checkout failed (${rmErr.message}) — falling back to fs-level cleanup`);
+          try { fs.rmSync(worktreePath, { recursive: true, force: true }); } catch {}
+          try { await shared.shellSafeGit(['worktree', 'prune'], { ...gitOpts, cwd: rootDir, timeout: 15000 }); } catch {}
+        }
+        const incompleteErr = new Error(`GVFS incomplete checkout at ${worktreePath}: worktree add exited cleanly but no source files were checked out (only .git was written). Retriable.`);
+        incompleteErr._incompleteCheckout = true;
+        throw incompleteErr;
+      }
       // W-mqecdoot — stamp the engine ownership marker so the out-of-root
       // worktree GC can distinguish a worktree we created from one a human
       // developer made by hand. Best-effort; never blocks the spawn.
@@ -5992,8 +6016,10 @@ function materializePlansAsWorkItems(config) {
   let planFiles;
   try { planFiles = fs.readdirSync(PRD_DIR).filter(f => f.endsWith('.json')); } catch { return; }
 
-  // Regex for detecting sequential PRD item IDs (P-001, P-002) — hoisted outside loop
-  const SEQUENTIAL_ID_RE = /^P-?\d+$/;
+  // Regex for detecting sequential PRD item IDs (P-001, M001, M-001, WI-001, …) — hoisted outside loop.
+  // Covers all patterns where an alphabetic prefix is followed by an optional dash and pure digits,
+  // e.g. P001, P-001, M001, M-001, WI-001. Does NOT match hex UUIDs like P-a3f9b2c1.
+  const SEQUENTIAL_ID_RE = /^[A-Za-z]+-?\d+$/;
 
   for (let file of planFiles) {
     // safeJsonNoRestore — if a PRD was archived between readdir and this
@@ -6211,7 +6237,9 @@ function materializePlansAsWorkItems(config) {
       mutateWorkItems(wiPath, existingItems => {
         for (const item of projItems) {
           // Re-open: 'updated' or 'missing' re-opens a done work item (#906)
-          const existingWi = existingItems.find(w => w.id === item.id);
+          // Use composite (sourcePlan, id) key so a WI from another PRD with the
+          // same id is not treated as already-materialized for this PRD.
+          const existingWi = existingItems.find(w => w.id === item.id && w.sourcePlan === file);
           const shouldReopen = item.status === PRD_ITEM_STATUS.UPDATED || item.status === PRD_ITEM_STATUS.MISSING;
           if (existingWi && DONE_STATUSES.has(existingWi.status) && shouldReopen) {
             shared.reopenWorkItem(existingWi);
@@ -6222,13 +6250,14 @@ function materializePlansAsWorkItems(config) {
             continue;
           }
 
-          // Skip if already materialized — work item ID = PRD item ID, check all projects
+          // Skip if already materialized — use composite (sourcePlan, id) key to prevent
+          // cross-PRD collision when two plans share the same item id (W-mqv6ql5w001w792f).
           let alreadyExists = !!existingWi;
           if (!alreadyExists) {
             for (const p of allProjects) {
               if (String(p.name || '').toLowerCase() === String(projName || '').toLowerCase()) continue;
               const otherItems = safeJsonArr(projectWorkItemsPath(p));
-              const otherWi = otherItems.find(w => w.id === item.id);
+              const otherWi = otherItems.find(w => w.id === item.id && w.sourcePlan === file);
               if (otherWi) {
                 if (DONE_STATUSES.has(otherWi.status) && shouldReopen) {
                   deferredReopens.push({ itemId: item.id, projectName: p.name, item });
@@ -8510,7 +8539,7 @@ function discoverCentralWorkItems(config) {
     const itemProjectResolution = shared.resolveConfiguredProject(item.project, projects);
     if (itemProjectResolution.error) {
       const error = itemProjectResolution.error;
-      mutations.set(item.id, { status: WI_STATUS.FAILED, failReason: error, failedAt: ts() });
+      mutations.set(item.id, { status: WI_STATUS.FAILED, failReason: error, failedAt: ts(), _failureClass: FAILURE_CLASS.PROJECT_NOT_FOUND });
       log('warn', `central work item ${item.id}: ${error}`);
       continue;
     }
@@ -8648,6 +8677,7 @@ function discoverCentralWorkItems(config) {
           status: WI_STATUS.FAILED,
           failReason: error,
           failedAt: ts(),
+          _failureClass: FAILURE_CLASS.PROJECT_NOT_FOUND,
           ...(declaredPlanProject ? { _declaredPlanProject: declaredPlanProject, _declaredPlanProjectMissing: true } : {}),
         });
         log('warn', `central work item ${item.id}: ${error}`);
@@ -8661,6 +8691,7 @@ function discoverCentralWorkItems(config) {
           status: WI_STATUS.FAILED,
           failReason: crossRepoFallbackError,
           failedAt: ts(),
+          _failureClass: FAILURE_CLASS.PROJECT_NOT_FOUND,
           _crossRepoTargetProjects: planTargetProjects.slice(),
         });
         log('warn', `central work item ${item.id} (cross-repo plan-to-prd): ${crossRepoFallbackError}`);
@@ -10288,12 +10319,15 @@ async function tickInner() {
       } else {
         // P-a3f9b205: surface the per-project live-mode gate. Order matters:
         // max_concurrency / agent_busy / branch_locked are all more specific
-        // and win when both apply.
+        // and win when both apply. Also check the pending item's own resolved
+        // checkout mode so worktree-mode items on hybrid projects are not
+        // falsely annotated live_checkout_busy (mirrors seeding guard above).
         const itemProjName = item.project || item.meta?.project?.name || null;
         if (
           itemProjName
           && !READ_ONLY_ROOT_TASK_TYPES.has(item.type)
           && postLiveProjectsInUse.has(itemProjName)
+          && shared.resolveCheckoutMode(shared.findProjectByName(shared.getProjects(config), itemProjName), item.type) === 'live'
         ) {
           reason = 'live_checkout_busy';
         }
@@ -10490,6 +10524,7 @@ module.exports = {
   resolveDependencyBranches, buildCrossRepoDepsSection, // exported for testing (P-faea3206)
   gitOutputToString, gitErrorOutput, classifyDepMergeFailureOutput, listUnmergedFiles, // exported for testing
   buildDepConflictFixItem, deriveConflictFixKey, // exported for testing (W-mpcwojgr000a0244)
+  runWorktreeAdd, // exported for testing (W-mqvaxv65000m76f2 — GVFS partial-checkout behavioral test)
   isWorktreeRetryableError, removeStaleIndexLock, syncReusedWorktree, assertCleanSharedWorktree, _quarantineDirtyWorktree, // exported for testing
   _statusPorcelainCmd, _killGitDescendantsForWorktree, _bumpQuarantineOutcome, // exported for testing (W-mq5n1zx5)
   _reapWorktreeHolders, _findTerminalWorktreeOwners, // exported for testing (W-mqila0t5 — CWD-pinned holder reap)

package/package.json

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