@yemi33/minions 0.1.1678 → 0.1.1679

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.1.1679 (2026-05-02)
+
+### Fixes
+-  preserve PR context for linked fix work items
+
 ## 0.1.1678 (2026-05-02)
 
 ### Fixes

package/dashboard.js

@@ -110,6 +110,22 @@ function normalizePrMetadata(metadata) {
   };
 }
 
+function getWorkItemPrRef(input) {
+  if (!input || typeof input !== 'object') return null;
+  return input.targetPr || input.pr || input.prId || input.prNumber || input.pullRequest || input.sourcePr || input.prUrl || null;
+}
+
+function copyWorkItemPrFields(item, input, pr = null) {
+  const prRef = getWorkItemPrRef(input);
+  if (!prRef && !pr) return;
+  const prNumber = pr ? shared.getPrNumber(pr) : shared.getPrNumber(prRef);
+  item.targetPr = pr?.id || prRef;
+  item.pr_id = pr?.id || (typeof prRef === 'string' ? prRef : '');
+  if (prNumber != null) item.prNumber = prNumber;
+  if (pr?.branch || input.prBranch) item.prBranch = pr?.branch || input.prBranch;
+  if (pr?.title || input.prTitle) item.prTitle = pr?.title || input.prTitle;
+  if (pr?.url || input.prUrl) item.prUrl = pr?.url || input.prUrl;
+}
 function linkPullRequestForTracking({ url, title, project: projectName, autoObserve, context, workItemId }, config = CONFIG, options = {}) {
   if (!url) {
     const err = new Error('url required');
@@ -1395,6 +1411,8 @@ async function executeCCActions(actions) {
           const workType = routing.normalizeWorkType(action.workType || (action.type !== 'dispatch' ? action.type : WORK_TYPE.IMPLEMENT), WORK_TYPE.IMPLEMENT);
           const id = 'W-' + shared.uid();
           const project = action.project || '';
+          const prRef = getWorkItemPrRef(action);
+          let linkedPr = null;
 
           // Strict project resolution. Silent fallback to PROJECTS[0] when the model named an unknown
           // project caused work items to land in the wrong repo. Now: unknown name → error; ambiguous
@@ -1408,6 +1426,18 @@ async function executeCCActions(actions) {
               results.push({ type: action.type, error: `Project "${project}" not found. Known projects: ${known}` });
               break;
             }
+          } else if (prRef) {
+            const allPrs = getPullRequests().filter(p => !p._ghost);
+            linkedPr = shared.findPrRecord(allPrs, prRef) || null;
+            if (linkedPr?._project && linkedPr._project !== 'central') {
+              targetProject = PROJECTS.find(p => p.name?.toLowerCase() === String(linkedPr._project).toLowerCase()) || null;
+            }
+            if (!targetProject && PROJECTS.length > 1) {
+              results.push({ type: action.type, error: `project field is required when ${PROJECTS.length} projects are configured: ${PROJECTS.map(p => p.name).join(', ')}` });
+              break;
+            } else if (!targetProject && PROJECTS.length === 1) {
+              targetProject = PROJECTS[0];
+            }
           } else if (PROJECTS.length > 1) {
             results.push({ type: action.type, error: `project field is required when ${PROJECTS.length} projects are configured: ${PROJECTS.map(p => p.name).join(', ')}` });
             break;
@@ -1416,6 +1446,16 @@ async function executeCCActions(actions) {
           }
           // PROJECTS.length === 0 → targetProject stays null, falls back to root work-items.json (existing behavior).
 
+          if (prRef && !linkedPr && targetProject) {
+            const projectPrs = shared.safeJson(shared.projectPrPath(targetProject)) || [];
+            shared.normalizePrRecords(projectPrs, targetProject);
+            linkedPr = shared.findPrRecord(projectPrs, prRef, targetProject) || null;
+          }
+          if (prRef && (workType === WORK_TYPE.FIX || workType === WORK_TYPE.REVIEW || workType === WORK_TYPE.TEST) && !linkedPr) {
+            results.push({ type: action.type, error: `PR not found: ${prRef}` });
+            break;
+          }
+
           const wiPath = targetProject ? shared.projectWorkItemsPath(targetProject) : path.join(MINIONS_DIR, 'work-items.json');
 
           // Promote `agent` (singular) → `agents` (array). Models emit either shape and the prior code
@@ -1438,14 +1478,16 @@ async function executeCCActions(actions) {
           const isOneShot = action.oneShot === true || (action.oneShot !== false && ccOneShotTypes.has(workType));
           shared.mutateJsonFileLocked(wiPath, items => {
             if (!Array.isArray(items)) items = [];
-            items.push({
+            const item = {
               id, title: action.title, type: workType,
               priority: action.priority || 'medium', description: action.description || '',
               status: WI_STATUS.PENDING, created: new Date().toISOString(),
-              createdBy: 'command-center', project,
+              createdBy: 'command-center', project: targetProject?.name || project,
               ...(agentHints.length ? { preferred_agent: agentHints[0], agents: agentHints } : {}),
               ...(isOneShot ? { oneShot: true } : {}),
-            });
+            };
+            copyWorkItemPrFields(item, action, linkedPr);
+            items.push(item);
             return items;
           }, { defaultValue: [] });
           results.push({ type: action.type, id, ok: true });
@@ -2740,6 +2782,7 @@ const server = http.createServer(async (req, res) => {
       if (body.acceptanceCriteria) item.acceptanceCriteria = body.acceptanceCriteria;
       if (body.skipPr) item.skipPr = true;
       if (body.oneShot) item.oneShot = true;
+      copyWorkItemPrFields(item, body);
       let dupId = null;
       mutateJsonFileLocked(wiPath, (items) => {
         if (!Array.isArray(items)) items = [];

package/engine/copilot-models.json

@@ -1,5 +1,5 @@
 {
   "runtime": "copilot",
   "models": null,
-  "cachedAt": "2026-05-02T05:22:33.108Z"
+  "cachedAt": "2026-05-02T05:46:43.671Z"
 }

package/engine/playbook.js

@@ -628,9 +628,13 @@ function selectPlaybook(workType, item) {
   if (workType === WORK_TYPE.IMPLEMENT || workType === WORK_TYPE.IMPLEMENT_LARGE) {
     return 'implement';
   }
-  if (workType === WORK_TYPE.REVIEW && !item?._pr && !item?.pr_id) {
+  const hasPrContext = !!(item?._pr || item?.pr_id || item?.targetPr || item?.sourcePr || item?.pr);
+  if (workType === WORK_TYPE.REVIEW && !hasPrContext) {
     return 'work-item';
   }
+  if (workType === WORK_TYPE.FIX && hasPrContext) {
+    return 'fix';
+  }
   const typeSpecificPlaybooks = ['explore', 'review', 'test', 'plan-to-prd', 'plan', 'ask', 'verify', 'decompose', 'docs', 'meeting-investigate', 'meeting-debate', 'meeting-conclude'];
   return typeSpecificPlaybooks.includes(workType) ? workType : 'work-item';
 }

package/engine.js

@@ -2592,6 +2592,14 @@ function renderProjectWorkItemPromptForAgent(item, workType, agentId, config, pr
     worktree_path: path.resolve(root, config.engine?.worktreeRoot || '../worktrees', `${branchName}`),
     commit_message: item.commitMessage || `feat: ${item.title || item.id}`,
     notes_content: '',
+    pr_id: item.pr_id || item._pr || item.targetPr || item.sourcePr || item.pr || '',
+    pr_number: item.prNumber || item.pr_number || '',
+    pr_title: item.pr_title || item.prTitle || '',
+    pr_branch: item.pr_branch || item.prBranch || '',
+    pr_author: item.pr_author || item.prAuthor || '',
+    pr_url: item.pr_url || item.prUrl || '',
+    reviewer: item.reviewer || 'Reviewer',
+    review_note: item.review_note || item.reviewNote || item.description || item.title || 'See PR thread comments',
   };
   const cpResult = buildWorkItemDispatchVars(item, vars, config, {
     worktreePath: vars.worktree_path || root,
@@ -2612,6 +2620,38 @@ function renderProjectWorkItemPromptForAgent(item, workType, agentId, config, pr
   };
 }
 
+function getWorkItemPrRef(item) {
+  if (!item || typeof item !== 'object') return null;
+  return item.targetPr || item.pr || item.pr_id || item.sourcePr || item.pullRequest || item.prUrl || item.prNumber || null;
+}
+
+function resolveWorkItemPrRecord(item, project) {
+  if (!project) return null;
+  const prRef = getWorkItemPrRef(item);
+  if (!prRef) return null;
+  const prs = safeJson(projectPrPath(project)) || [];
+  shared.normalizePrRecords(prs, project);
+  return shared.findPrRecord(prs, prRef, project);
+}
+
+function withWorkItemPrContext(item, pr) {
+  if (!pr) return item;
+  const prNumber = shared.getPrNumber(pr);
+  return {
+    ...item,
+    _pr: pr.id,
+    pr_id: pr.id,
+    targetPr: item.targetPr || pr.id,
+    prNumber: prNumber ?? item.prNumber,
+    pr_number: prNumber ?? item.pr_number,
+    pr_title: pr.title || item.pr_title || item.prTitle || '',
+    pr_branch: pr.branch || item.pr_branch || item.prBranch || '',
+    pr_author: pr.agent || item.pr_author || item.prAuthor || '',
+    pr_url: pr.url || item.pr_url || item.prUrl || '',
+    reviewer: item.reviewer || 'Reviewer',
+    review_note: item.review_note || item.reviewNote || item.description || item.title || 'See PR thread comments',
+  };
+}
 function projectFromDispatchMeta(metaProject, config) {
   if (!metaProject) return null;
   const projects = getProjects(config);
@@ -2775,8 +2815,17 @@ function discoverFromWorkItems(config, project) {
       skipped.noAgent++; continue;
     }
 
+    const linkedPr = resolveWorkItemPrRecord(item, project);
+    const promptItem = linkedPr ? withWorkItemPrContext(item, linkedPr) : item;
+    const prBranch = linkedPr?.branch || '';
+    const isPrTargeted = !!(linkedPr && (workType === WORK_TYPE.FIX || workType === WORK_TYPE.REVIEW || workType === WORK_TYPE.TEST));
+    if (!linkedPr && getWorkItemPrRef(item) && (workType === WORK_TYPE.FIX || workType === WORK_TYPE.REVIEW || workType === WORK_TYPE.TEST)) {
+      if (item._pendingReason !== 'pr_not_found') { item._pendingReason = 'pr_not_found'; needsWrite = true; }
+      log('warn', `Work item ${item.id} references PR ${getWorkItemPrRef(item)} but no tracked PR record was found`);
+      continue;
+    }
     const isShared = item.branchStrategy === 'shared-branch' && item.featureBranch;
-    const branchName = isShared ? item.featureBranch : (item.branch || `work/${item.id}`);
+    const branchName = isPrTargeted && prBranch ? prBranch : (isShared ? item.featureBranch : (item.branch || `work/${item.id}`));
     const deferredAgentResolution = agentId === routing.ANY_AGENT;
 
     // Branch mutex: skip if target branch is locked by an active dispatch
@@ -2789,7 +2838,7 @@ function discoverFromWorkItems(config, project) {
     }
 
     const promptAgentId = deferredAgentResolution ? reservedAgentId : agentId;
-    const promptResult = renderProjectWorkItemPromptForAgent(item, workType, promptAgentId, config, project, root, branchName);
+    const promptResult = renderProjectWorkItemPromptForAgent(promptItem, workType, promptAgentId, config, project, root, branchName);
     if (promptResult.needsReview) {
       log('warn', `Work item ${item.id} exceeded 3 checkpoint-resumes — marking as failed for manual intervention`);
       item.status = WI_STATUS.FAILED;
@@ -2827,7 +2876,7 @@ function discoverFromWorkItems(config, project) {
       agentRole: config.agents[agentId]?.role || tempAgents.get(agentId)?.role || 'Agent',
       task: `[${project?.name || 'project'}] ${item.title || item.description?.slice(0, 80) || item.id}`,
       prompt,
-      meta: { dispatchKey: key, source: 'work-item', branch: branchName, branchStrategy: item.branchStrategy || 'parallel', useExistingBranch: !!(item.branchStrategy === 'shared-branch' && item.featureBranch), item, project: { name: project?.name, localPath: project?.localPath }, deferAgentResolution: deferredAgentResolution }
+      meta: { dispatchKey: key, source: 'work-item', branch: branchName, branchStrategy: item.branchStrategy || 'parallel', useExistingBranch: !!(isPrTargeted || (item.branchStrategy === 'shared-branch' && item.featureBranch)), item: promptItem, project: { name: project?.name, localPath: project?.localPath }, deferAgentResolution: deferredAgentResolution, ...(linkedPr ? { pr: linkedPr } : {}) }
     });
 
     setCooldown(key);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.1678",
+  "version": "0.1.1679",
   "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/prompts/cc-system.md

@@ -80,8 +80,8 @@ I'll dispatch dallas to fix that bug.
 - `knowledge`: `title`, `content`, and `category` REQUIRED. Valid categories: architecture, conventions, project-notes, build-reports, reviews.
 
 Core action types:
-- **dispatch**: title (REQUIRED), workType, priority (low/medium/high), agents[] or agent (optional — both shapes accepted), project (REQUIRED when multi-project), description
-  workTypes: `explore` (research/report only, NO PR), `ask` (answer/report, NO PR), `implement` (new code, PR REQUIRED), `fix` (bug fix, PR REQUIRED), `review` (code review, NO PR), `test` (tests, PR if new), `verify` (merge/build/maintenance, NO PR)
+- **dispatch**: title (REQUIRED), workType, priority (low/medium/high), agents[] or agent (optional — both shapes accepted), project (REQUIRED when multi-project unless `pr` resolves to a tracked PR), description, pr (optional PR number/id/url for work that targets an existing PR)
+  workTypes: `explore` (research/report only, NO PR), `ask` (answer/report, NO PR), `implement` (new code, PR REQUIRED), `fix` (standalone bug fix creates a PR; include `pr` when fixing review comments/build failures on an existing PR), `review` (code review, NO PR), `test` (tests, PR if new), `verify` (merge/build/maintenance, NO PR)
   If the user wants a design/architecture artifact committed through a PR, dispatch `implement` or `docs` rather than `explore`.
   When the user names a specific agent ("assign this to lambert"), put exactly that one name in `agents` (e.g. `"agents": ["lambert"]`). A single-agent assignment is hard-pinned by the server — it will queue for that agent only and skip the routing table. Use multi-agent arrays only when the user names multiple agents or asks for fan-out.
 - **build-and-test**: pr, project (optional), agent (optional) — Run the build-and-test playbook against a PR. The agent will checkout the PR branch, run the project's build/test commands, and report results. Use when the user asks to "run tests on PR X" or "build PR X" or after a fix to verify nothing regressed.