@yemi33/minions 0.1.643 → 0.1.645

package/CHANGELOG.md

@@ -1,10 +1,14 @@
 # Changelog
 
-## 0.1.643 (2026-04-09)
+## 0.1.645 (2026-04-09)
 
 ### Features
+-  pipeline plan stage reconciliation and UX fixes
 -  track notes, plans, and PRDs as work item artifacts
 
+### Fixes
+-  use startsWith for inbox note matching to prevent false matches
+
 ## 0.1.642 (2026-04-09)
 
 ### Features

package/dashboard/js/render-meetings.js

@@ -380,12 +380,22 @@ function _viewPlanWithBack(file, meetingId) {
 }
 
 function _findLinkedPlan(meeting) {
-  if (!meeting?.conclusion?.content) return null;
-  const match = meeting.conclusion.content.match(/plans\/([\w-]+\.md)/);
-  if (!match) return null;
-  const file = match[1];
-  const plans = window._lastStatus?.plans || [];
-  return plans.find(function(p) { return p.file === file; }) || { file, summary: file };
+  var plans = window._lastStatus?.plans || [];
+  // Check 1: regex in conclusion text (agent may reference plan path)
+  if (meeting?.conclusion?.content) {
+    var match = meeting.conclusion.content.match(/plans\/([\w-]+\.md)/);
+    if (match) {
+      var file = match[1];
+      return plans.find(function(p) { return p.file === file; }) || { file, summary: file };
+    }
+  }
+  // Check 2: title-slug filename match (dashboard naming convention: "meeting-follow-up-{title}")
+  if (meeting?.title) {
+    var titleSlug = ('Meeting follow-up: ' + meeting.title).toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, 50);
+    var found = plans.find(function(p) { return p.file && p.file.startsWith(titleSlug); });
+    if (found) return found;
+  }
+  return null;
 }
 
 async function _createPlanFromMeeting(id, btn) {
@@ -435,7 +445,7 @@ async function _createPlanFromMeeting(id, btn) {
     const title = 'Meeting follow-up: ' + (m.title || id);
     const planRes = await fetch('/api/plans/create', {
       method: 'POST', headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ title, content: planContent })
+      body: JSON.stringify({ title, content: planContent, meetingId: id })
     });
     const planData = await planRes.json();
     if (planRes.ok && planData.ok) {

package/dashboard/styles.css

@@ -39,7 +39,7 @@
   .timestamp { color: var(--muted); font-size: var(--text-md); font-variant-numeric: tabular-nums; }
 
   .layout { display: none; } /* Replaced by page-layout */
-  section { padding: var(--space-8) var(--space-9); border-bottom: 1px solid var(--border); overflow: hidden; min-width: 0; }
+  section { padding: var(--space-8) var(--space-9); border-bottom: 1px solid var(--border); overflow: visible; min-width: 0; }
 
   /* Sidebar navigation */
   .page-layout { display: flex; flex: 1; min-height: 0; overflow: hidden; }

package/engine/pipeline.js

@@ -284,39 +284,91 @@ function executeMeetingStage(stage, stageState, run, config) {
   return { status: PIPELINE_STATUS.RUNNING, artifacts: { meetings: createdIds } };
 }
 
+// Find meeting artifacts from any stage in the run (not just direct deps)
+function _findMeetingsInRun(run) {
+  const meetings = [];
+  for (const [, stageState] of Object.entries(run.stages || {})) {
+    for (const mid of (stageState.artifacts?.meetings || [])) {
+      if (!meetings.includes(mid)) meetings.push(mid);
+    }
+  }
+  return meetings;
+}
+
+// Check if a plan already exists for a given meeting (created manually via dashboard)
+function _findExistingPlanForMeeting(meetingIds, planSlug, plansDir) {
+  const files = safeReadDir(plansDir).filter(f => f.endsWith('.md'));
+  const slugPrefix = planSlug.slice(0, 30);
+  let slugMatch = null;
+  for (const file of files) {
+    // Fallback: title-slug filename match (checked first to avoid unnecessary reads)
+    if (!slugMatch && file.startsWith(slugPrefix)) slugMatch = file;
+    // Primary: explicit Source Meeting header (written by dashboard /api/plans/create)
+    const content = safeRead(path.join(plansDir, file));
+    if (!content) continue;
+    for (const mid of meetingIds) {
+      if (content.includes('**Source Meeting:** ' + mid)) return file;
+    }
+  }
+  return slugMatch;
+}
+
 async function executePlanStage(stage, stageState, run, config) {
-  // Create a plan .md file from the stage config + previous stage output
   const plansDir = path.join(__dirname, '..', 'plans');
   if (!fs.existsSync(plansDir)) fs.mkdirSync(plansDir, { recursive: true });
 
   const slug = (stage.title || 'pipeline-plan').toLowerCase().replace(/[^a-z0-9]+/g, '-').slice(0, 50);
-  const filename = `${slug}-${dateStamp()}.md`;
-  const filePath = shared.uniquePath(path.join(plansDir, filename));
+  const wiPath = path.join(__dirname, '..', 'work-items.json');
+  const wiId = `PL-${run.runId.slice(4, 12)}-${stage.id}-prd`;
 
-  // Build meeting context from dependency stages
+  // ── 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, slug, plansDir);
+    if (existingPlanFile) {
+      log('info', `Pipeline ${run.pipelineId}: reconciling plan stage — adopting existing plan "${existingPlanFile}"`);
+      // Adopt or create plan-to-prd WI atomically under lock
+      let adoptedWiId = wiId;
+      mutateWorkItems(wiPath, workItems => {
+        const existing = workItems.find(w => w.type === WORK_TYPE.PLAN_TO_PRD && w.planFile === existingPlanFile);
+        if (existing) {
+          existing._pipelineRun = run.runId;
+          existing._pipelineStage = stage.id;
+          adoptedWiId = existing.id;
+        } else if (!workItems.some(w => w.id === wiId)) {
+          workItems.push({
+            id: wiId, title: `Convert plan to PRD: ${existingPlanFile}`,
+            type: WORK_TYPE.PLAN_TO_PRD, priority: 'high', status: WI_STATUS.PENDING,
+            planFile: existingPlanFile, created: ts(), createdBy: 'pipeline:' + run.pipelineId,
+            branch: `pipeline/${run.pipelineId}/${stage.id}`, _pipelineRun: run.runId, _pipelineStage: stage.id,
+          });
+        }
+      });
+      return {
+        status: PIPELINE_STATUS.RUNNING,
+        artifacts: { plans: [existingPlanFile], workItems: [adoptedWiId], prds: [], prs: [] },
+      };
+    }
+  }
+
+  // ── No existing plan — build meeting context from ALL run stages (not just direct deps) ──
   let meetingContext = '';
+  for (const mid of meetingIds) {
+    try {
+      const mtg = safeJson(path.join(__dirname, '..', 'meetings', mid + '.json'));
+      if (mtg) {
+        const transcript = (mtg.transcript || []).map(t =>
+          '### ' + (t.agent || 'agent') + ' (' + (t.type || '') + ', Round ' + (t.round || '?') + ')\n\n' + (t.content || '')
+        ).join('\n\n---\n\n');
+        meetingContext += '# Meeting: ' + (mtg.title || mid) + '\n\n**Agenda:** ' + (mtg.agenda || '') + '\n\n' + transcript + '\n\n';
+      }
+    } catch (e) { log('warn', `Pipeline plan: failed to read meeting ${mid}: ${e.message}`); }
+  }
+  // Also include direct dep output (for non-meeting stages)
   if (stage.dependsOn) {
     for (const depId of stage.dependsOn) {
       const depStage = run.stages[depId];
-      if (!depStage) continue;
-
-      const meetingId = depStage.artifacts?.meetings?.[0];
-      if (meetingId) {
-        try {
-          const mtgPath = path.join(__dirname, '..', 'meetings', meetingId + '.json');
-          const mtg = safeJson(mtgPath);
-          if (mtg) {
-            // Build full meeting document (same as dashboard "Create Plan from Meeting")
-            const transcript = (mtg.transcript || []).map(t =>
-              '### ' + (t.agent || 'agent') + ' (' + (t.type || '') + ', Round ' + (t.round || '?') + ')\n\n' + (t.content || '')
-            ).join('\n\n---\n\n');
-            meetingContext += '# Meeting: ' + (mtg.title || depId) + '\n\n**Agenda:** ' + (mtg.agenda || '') + '\n\n' + transcript + '\n\n';
-            continue;
-          }
-        } catch { /* fall through */ }
-      }
-
-      if (depStage.output) {
+      if (depStage?.output && !depStage.artifacts?.meetings?.length) {
         meetingContext += '## From: ' + depId + '\n\n' + depStage.output + '\n\n';
       }
     }
@@ -350,11 +402,11 @@ async function executePlanStage(stage, stageState, run, config) {
     if (stage.description) content += stage.description + '\n';
   }
 
+  const filename = `${slug}-${dateStamp()}.md`;
+  const filePath = shared.uniquePath(path.join(plansDir, filename));
   safeWrite(filePath, content);
 
   // Create plan-to-prd work item — atomic write to prevent race with dispatch status updates
-  const wiPath = path.join(__dirname, '..', 'work-items.json');
-  const wiId = `PL-${run.runId.slice(4, 12)}-${stage.id}-prd`;
   mutateWorkItems(wiPath, workItems => {
     if (!workItems.some(w => w.id === wiId)) {
       workItems.push({

package/engine.js

@@ -795,7 +795,7 @@ async function spawnAgent(dispatchItem, config) {
           const _artToday = shared.dateStamp();
           const _artInboxDir = path.join(MINIONS_DIR, 'notes', 'inbox');
           let _artNotes = [];
-          try { _artNotes = shared.safeReadDir(_artInboxDir).filter(f => f.includes(agentId) && f.includes(_artToday)); } catch {}
+          try { _artNotes = shared.safeReadDir(_artInboxDir).filter(f => f.startsWith(agentId + '-') && f.includes(_artToday)); } catch {}
 
           mutateJsonFileLocked(artWiPath, data => {
             if (!Array.isArray(data)) return data;

package/package.json

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