@yemi33/minions 0.1.2356 → 0.1.2357

package/engine/pipeline.js

@@ -501,11 +501,16 @@ function _findMeetingsInRun(run) {
   return meetings;
 }
 
-// Check if a plan already exists for a given meeting (created manually via dashboard)
-function _findExistingPlanForMeeting(meetingIds, plansDir) {
+// Check if a plan already exists for a given meeting (created manually via
+// dashboard, or previously by this same pipeline stage). `pipelineSlugPrefix`
+// (optional) is the slug a pipeline plan stage writes its files under
+// (`slugify(stage.title)`) — matching on it catches pre-existing pipeline
+// plans that predate the `**Source Meeting:**` marker below.
+function _findExistingPlanForMeeting(meetingIds, plansDir, pipelineSlugPrefix) {
   const files = safeReadDir(plansDir).filter(f => f.endsWith('.md'));
-  // Build slug prefixes for both pipeline and dashboard naming conventions
+  // Build slug prefixes for dashboard, and (optionally) pipeline naming conventions
   const slugPrefixes = [];
+  if (pipelineSlugPrefix) slugPrefixes.push(pipelineSlugPrefix);
   for (const mid of meetingIds) {
     const mtg = safeJson(path.join(MEETINGS_DIR, mid + '.json'));
     if (mtg?.title) {
@@ -575,6 +580,18 @@ function _findExistingPrdForPlan(planFile, prdDir) {
   return null;
 }
 
+// A well-formed plan (LLM path or fallback path) always starts with a markdown
+// title and has substantive body content. Guards against `maxTurns: 1` LLM
+// calls that spend their single turn on tool-oriented preamble/narration
+// instead of the plan itself (W-mrbn0eex000265d7) — that kind of response is a
+// short mid-task fragment, not a plan, and must not be written verbatim.
+function _looksLikePlanContent(content) {
+  if (!content) return false;
+  const trimmed = content.trim();
+  if (trimmed.length < 200) return false;
+  return trimmed.startsWith('#');
+}
+
 async function executePlanStage(stage, stageState, run, config, pipeline = {}) {
   const plansDir = PLANS_DIR;
   if (!fs.existsSync(plansDir)) fs.mkdirSync(plansDir, { recursive: true });
@@ -591,7 +608,7 @@ async function executePlanStage(stage, stageState, run, config, pipeline = {}) {
   // ── Reconciliation: check if a plan already exists for a meeting in this run ──
   const meetingIds = _findMeetingsInRun(run);
   if (meetingIds.length > 0) {
-    const existingPlanFile = _findExistingPlanForMeeting(meetingIds, plansDir);
+    const existingPlanFile = _findExistingPlanForMeeting(meetingIds, plansDir, slug);
     if (existingPlanFile) {
       log('info', `Pipeline ${run.pipelineId}: reconciling plan stage — adopting existing plan "${existingPlanFile}"`);
 
@@ -686,9 +703,11 @@ async function executePlanStage(stage, stageState, run, config, pipeline = {}) {
     });
     if (result.missingRuntime) {
       log('warn', `Pipeline plan LLM skipped: ${result.text || result.stderr || 'runtime unavailable'} — falling back to raw meeting context`);
-    } else if (result.text) {
+    } else if (result.text && _looksLikePlanContent(result.text)) {
       content = result.text;
       log('info', `Pipeline plan: LLM generated ${content.length} chars from meeting context`);
+    } else if (result.text) {
+      log('warn', `Pipeline plan LLM response looked like a fragment, not a plan (${result.text.length} chars, doesn't start with a title) — discarding and falling back to raw meeting context`);
     }
   } catch (e) { log('warn', `Pipeline plan LLM failed: ${e.message} — falling back to raw meeting context`); }
 
@@ -701,6 +720,14 @@ async function executePlanStage(stage, stageState, run, config, pipeline = {}) {
     if (stage.description) content += stage.description + '\n';
   }
 
+  // Stamp every source meeting so a future/duplicate invocation for this run
+  // can find this plan via `_findExistingPlanForMeeting`'s content scan — the
+  // reconciliation guard above only matches on this literal marker or a slug
+  // prefix, and generated content (LLM or fallback) never included it before.
+  if (meetingIds.length > 0) {
+    content += '\n\n---\n\n' + meetingIds.map(mid => `**Source Meeting:** ${mid}`).join('\n') + '\n';
+  }
+
   const filename = `${slug}-${dateStamp()}.md`;
   const filePath = shared.uniquePath(path.join(plansDir, filename));
   safeWrite(filePath, content);
@@ -1021,7 +1048,7 @@ function isStageComplete(stage, stageState, run, config) {
       if (prIds.length === 0) return true; // nothing to merge
       const projects = shared.getProjects(config);
       for (const project of projects) {
-        const prs = safeJson(shared.projectPrPath(project)) || [];
+        const prs = safeJsonArr(shared.projectPrPath(project));
         for (const prId of prIds) {
           const pr = shared.findPrRecord(prs, prId, project);
           if (pr && pr.status !== PR_STATUS.MERGED && pr.status !== PR_STATUS.ABANDONED) return false;
@@ -1173,7 +1200,7 @@ async function discoverPipelineWork(config) {
             if (meetingIds.length > 0) {
               const plansDir = PLANS_DIR;
               if (fs.existsSync(plansDir)) {
-                const existingPlan = _findExistingPlanForMeeting(meetingIds, plansDir);
+                const existingPlan = _findExistingPlanForMeeting(meetingIds, plansDir, slugify(nextPlanStage.title || 'pipeline-plan'));
                 if (existingPlan) {
                   updateRunStage(pipeline.id, activeRun.runId, stage.id, {
                     status: PIPELINE_STATUS.COMPLETED, completedAt: ts(),
@@ -1207,7 +1234,34 @@ async function discoverPipelineWork(config) {
           stageState.status = PIPELINE_STATUS.FAILED;
           anyFailed = true;
         } else if (depsReady) {
-          const result = await executeStage(stage, activeRun, pipeline, config);
+          // W-mrbn0eex000265d7: persist RUNNING BEFORE the (potentially slow,
+          // up-to-120s LLM-backed) executeStage call resolves. Plan stages in
+          // particular kick off an LLM call; the stage's persisted status
+          // previously stayed PENDING for the whole call, so a concurrent or
+          // retried invocation of discoverPipelineWork (overlapping tick, or
+          // resumed run after an engine restart mid-await) would see PENDING
+          // again and re-execute the stage, writing a second duplicate plan
+          // file. Marking RUNNING first means a re-entrant call takes the
+          // RUNNING branch above (isStageComplete) instead of re-executing.
+          updateRunStage(pipeline.id, activeRun.runId, stage.id, { status: PIPELINE_STATUS.RUNNING, startedAt: ts() });
+          stageState.status = PIPELINE_STATUS.RUNNING;
+          // W-mrbn0eex000265d7 (review follow-up): the RUNNING status above is
+          // already persisted, so if executeStage throws instead of resolving
+          // (e.g. a lock-timeout in mutateWorkItems, an fs error), an uncaught
+          // rejection would propagate out of discoverPipelineWork to the
+          // engine.js tick-phase catch, which only logs a warning — leaving
+          // this stage's persisted status stuck at RUNNING forever with no
+          // follow-up transition (previously it stayed PENDING and simply
+          // retried next tick). Catch here and route the failure through the
+          // normal FAILED path so dependents fail fast instead of the run
+          // stalling silently.
+          let result;
+          try {
+            result = await executeStage(stage, activeRun, pipeline, config);
+          } catch (e) {
+            log('warn', `Pipeline ${pipeline.id}: stage ${stage.id} threw during execution: ${e.message}`);
+            result = { status: PIPELINE_STATUS.FAILED, error: e.message };
+          }
           updateRunStage(pipeline.id, activeRun.runId, stage.id, { ...result, startedAt: ts() });
           Object.assign(stageState, result, { startedAt: ts() });
           if (result.status === PIPELINE_STATUS.RUNNING) {

package/engine/playbook.js

@@ -12,7 +12,7 @@ const queries = require('./queries');
 const { wrapUntrusted, buildSource } = require('./untrusted-fence');
 const { MINIONS_BRAND_URL } = require('./comment-format');
 
-const { safeJson, safeRead, getProjects, log, ts, dateStamp, truncateTextBytes, ENGINE_DEFAULTS, WI_STATUS, WORK_TYPE, PR_STATUS, DISPATCH_RESULT, getProjectOrg } = shared;
+const { safeJsonArr, safeRead, getProjects, log, ts, dateStamp, truncateTextBytes, ENGINE_DEFAULTS, WI_STATUS, WORK_TYPE, PR_STATUS, DISPATCH_RESULT, getProjectOrg } = shared;
 const { getConfig, getDispatch, getNotes, getPrs, getKnowledgeBaseIndex, AGENTS_DIR } = queries;
 
 const MINIONS_DIR = shared.MINIONS_DIR;
@@ -1060,11 +1060,12 @@ function renderPlaybook(type, vars) {
 // ─── Playbook Section Validator ──────────────────────────────────────────────
 
 // Required structural section patterns — warn (do not throw) when absent.
-// Pluralisation: /^## Tools?\b/m matches both '## Tool' and '## Tools'.
+// Only '## Your Task' is checked: it's the one section every playbook template
+// actually implements. '## Tools' / '## Constraints' were removed (#775) —
+// no template in playbooks/ defines those headers, so the checks always
+// failed and produced 100%-failure-rate warn-level noise in engine/log.json.
 const _REQUIRED_PROMPT_SECTIONS = [
   { pattern: /^## Your Task\b/m,   label: '## Your Task' },
-  { pattern: /^## Tools?\b/m,      label: '## Tools' },
-  { pattern: /^## Constraints\b/m, label: '## Constraints' },
 ];
 
 /**
@@ -1266,7 +1267,7 @@ function buildAgentContext(agentId, config, project) {
   }
   // Also check central pull-requests.json
   try {
-    const centralPrs = safeJson(path.join(MINIONS_DIR, 'pull-requests.json')) || [];
+    const centralPrs = safeJsonArr(path.join(MINIONS_DIR, 'pull-requests.json'));
     for (const pr of centralPrs.filter(pr => pr.status === PR_STATUS.ACTIVE)) {
       if (!allPrs.some(p => p.id === pr.id)) allPrs.push({ ...pr, _project: 'central' });
     }

package/engine/queries.js

@@ -72,6 +72,25 @@ function _resetPrEnrichmentCacheForTest() {
   _prEnrichmentInFlight.clear();
 }
 
+// W-mrcs8yqk001o6893 — shared enrichment-fallback resolver. Both the prLinks
+// loop and the wi._pr fallback loop in getPrdInfo() need the SAME defensive
+// behavior when the canonical PR id has no live record in pull-requests.json
+// (e.g. it was merged and then swept by the merged-PR cleanup routine): check
+// the enrichment cache first, else synthesize PR_STATUS.ACTIVE as a
+// placeholder and kick off a fire-and-forget enrollment so the next poll
+// (within PR_ENRICHMENT_TTL_MS) resolves the real status. Previously only the
+// wi._pr loop did this (W-mq5uzmc6001d708f); the prLinks loop hardcoded
+// `pr?.status || PR_STATUS.ACTIVE` with no self-heal, so PRs reached only via
+// pr_links stayed 'active' forever once removed from pull-requests.json.
+function _resolvePrStatusWithEnrichment(pr, canonicalPrId, project, itemId) {
+  if (pr?.status) return pr.status;
+  if (!canonicalPrId) return PR_STATUS.ACTIVE;
+  const cachedStatus = _getCachedPrEnrichment(canonicalPrId);
+  if (cachedStatus) return cachedStatus;
+  _scheduleAsyncPrEnrollment(canonicalPrId, project, itemId);
+  return PR_STATUS.ACTIVE;
+}
+
 /**
  * Read the first `bytes` and last `bytes` of a file efficiently using byte offsets.
  * For files <= 2*bytes, reads the whole file. Returns { head, tail } strings.
@@ -572,15 +591,6 @@ function _buildArchiveNotesByWiMap() {
   return out;
 }
 
-// Test/maintenance hook — drop the archive notes cache (mirrors the other
-// invalidate* helpers). Not normally needed: the cache self-heals via the
-// dir-mtime gate + TTL.
-function invalidateArchiveNotesByWiCache() {
-  _archiveNotesByWiCache = null;
-  _archiveNotesByWiCacheAt = 0;
-  _archiveNotesByWiCacheMtime = null;
-}
-
 // Build a wiId → [filename, ...] map by scanning the inbox + archive dirs.
 // Archive entries are prefixed with `archive:` so the dashboard renderer can
 // tell them apart (matches the convention already used by _artifacts.notes).
@@ -2363,7 +2373,18 @@ function getPrdInfo(config) {
     const url = buildPrUrlFromId(prId, pr, projects);
     for (const itemId of (itemIds || [])) {
       if (!prdToPr[itemId]) prdToPr[itemId] = [];
-      prdToPr[itemId].push({ id: prId, url, title: pr?.title || '', status: pr?.status || PR_STATUS.ACTIVE, _project: pr?._project || '' });
+      // W-mrcs8yqk001o6893 — when the pr_links mapping outlives the PR record
+      // (merged-PR sweep removes it from pull-requests.json but pr_links is
+      // never pruned), resolve the item's project so we can self-heal the
+      // status the same way the wi._pr fallback loop below does.
+      let itemProject = null;
+      if (!pr) {
+        const itemSource = (wiById[itemId] || allWiById[itemId] || {}).project
+          || (wiById[itemId] || allWiById[itemId] || {})._source || null;
+        itemProject = itemSource ? shared.resolveProjectSource(itemSource, projects, { allowCentral: false }).project || null : null;
+      }
+      const status = _resolvePrStatusWithEnrichment(pr, prId, itemProject, itemId);
+      prdToPr[itemId].push({ id: prId, url, title: pr?.title || '', status, _project: pr?._project || '' });
     }
   }
   // Fallback: work item _pr field for anything still missing
@@ -2379,17 +2400,8 @@ function getPrdInfo(config) {
     // exists (orphan _pr pointer), use a cached status from a prior async
     // enrollment if available, else synthesize ACTIVE and schedule a
     // fire-and-forget enrollment so the next status poll renders correctly.
-    let synthesizedStatus = pr?.status;
-    if (!pr && canonicalPrId) {
-      const cachedStatus = _getCachedPrEnrichment(canonicalPrId);
-      if (cachedStatus) {
-        synthesizedStatus = cachedStatus;
-      } else {
-        synthesizedStatus = PR_STATUS.ACTIVE;
-        _scheduleAsyncPrEnrollment(canonicalPrId, project, wi.id);
-      }
-    }
-    prdToPr[wi.id] = [{ id: pr?.id || canonicalPrId || wi._pr, url, title: pr?.title || '', status: synthesizedStatus || PR_STATUS.ACTIVE, _project: project?.name || '' }];
+    const synthesizedStatus = _resolvePrStatusWithEnrichment(pr, canonicalPrId, project, wi.id);
+    prdToPr[wi.id] = [{ id: pr?.id || canonicalPrId || wi._pr, url, title: pr?.title || '', status: synthesizedStatus, _project: project?.name || '' }];
   }
   // Aggregate sub-task PRs to decomposed parent (sub-tasks aren't PRD items but their PRs should show)
   for (const pr of allPrs) {
@@ -3422,7 +3434,7 @@ module.exports = {
   getKnowledgeBaseEntries, getKnowledgeBaseEntriesSnapshot, getKnowledgeBaseIndex,
 
   // Work items & PRD
-  getWorkItems, invalidateWorkItemsCache, invalidateArchiveNotesByWiCache, getPrdInfo,
+  getWorkItems, invalidateWorkItemsCache, getPrdInfo,
 
   // W-mq5uzmc6001d708f — test hooks for the defensive PR enrichment cache.
   _resetPrEnrichmentCacheForTest,

package/engine/shared.js

@@ -2306,8 +2306,47 @@ function runFile(file, args, opts = {}) {
   return _spawn(file, args, { windowsHide: true, ...opts });
 }
 
+// True when `p` is a UNC path (`\\server\share\...` or its forward-slash
+// form `//server/share/...`, e.g. `\\wsl.localhost\Ubuntu\...` / `\\wsl$\...`
+// for a WSL-hosted project). Windows' cmd.exe — the default shell
+// `execSync`/`exec` spawn under — refuses a UNC path as its working
+// directory ("UNC paths are not supported. Defaulting to Windows
+// directory."), which silently redirects the child's actual cwd elsewhere.
+function isUncPath(p) {
+  return typeof p === 'string' && (p.startsWith('\\\\') || p.startsWith('//'));
+}
+
+// Minimal argv tokenizer for the small, hardcoded `git ...` command strings
+// built elsewhere in this file — splits on whitespace, honoring
+// double-quoted segments (the only quoting these callers use, e.g. a branch
+// name interpolated as `"refs/heads/${branch}"`). Not a general shell
+// parser; only ever fed strings this codebase constructs itself.
+function _splitGitCommandLine(cmd) {
+  const argv = [];
+  const re = /"([^"]*)"|(\S+)/g;
+  let m;
+  while ((m = re.exec(cmd)) !== null) argv.push(m[1] !== undefined ? m[1] : m[2]);
+  return argv;
+}
+
 function execSilent(cmd, opts = {}) {
-  return _execSync(cmd, { stdio: 'pipe', windowsHide: true, ...opts });
+  const merged = { stdio: 'pipe', windowsHide: true, ...opts };
+  // W-mrcv3ky7000c2338 / opg#772 — a `git ...` shellout whose `cwd` is a UNC
+  // path (WSL-hosted project, or any other UNC-rooted checkout) would
+  // otherwise run through cmd.exe, which can't chdir into a UNC path and
+  // silently defaults to the Windows directory instead — the subsequent git
+  // command then fails with "fatal: not a git repository", and callers like
+  // cleanup.js's orphan/quarantine worktree-dir reaper have no ground truth
+  // for which worktrees are registered, so quarantined worktree husks are
+  // never reaped (unbounded disk growth). Re-parse into argv and run via
+  // execFileSync (shell:false) instead — that bypasses cmd.exe entirely and
+  // Windows' CreateProcess honors a UNC cwd correctly, exactly like
+  // shared.shellSafeGitSync / shared.removeWorktree already do.
+  if (typeof cmd === 'string' && /^git\b/.test(cmd.trim()) && isUncPath(merged.cwd)) {
+    const argv = _splitGitCommandLine(cmd);
+    return _execFileSync(argv[0], argv.slice(1), merged);
+  }
+  return _execSync(cmd, merged);
 }
 
 /**
@@ -9174,6 +9213,7 @@ module.exports = {
   exec,
   execAsync,
   execSilent,
+  isUncPath,
   shellSafeGh,
   shellSafeGit,
   removeStaleIndexLock,