@yemi33/minions 0.1.1809 → 0.1.1811

package/docs/pr-review-fix-loop.md

@@ -43,6 +43,7 @@ When multiple problems coexist, earlier triggers get the first chance to enqueue
 - Coalesces multiple comments arriving during cooldown into single fix
 - Routes to author
 - Not gated by `_evalEscalated` — humans can always force more fixes via PR comments even after the minion review loop escalates.
+- Fix agents must treat human comments as claims to verify, not commands. They inspect or reproduce each claimed issue, make the smallest correct fix only when the claim is valid, and otherwise reply with evidence-backed rationale.
 
 ### B. Review feedback (`changes-requested`)
 
@@ -51,6 +52,7 @@ When multiple problems coexist, earlier triggers get the first chance to enqueue
 - `review_note` = reviewer's feedback
 - Sets `fixDispatched = true` — prevents the later conflict fix from also firing this pass
 - **Review-loop escalation**: after `evalMaxIterations` review→fix cycles (default 3), `_evalEscalated` is set on the PR and *only this trigger plus minion review/re-review* stop. Triggers A (human comments), C (build failures), and D (merge conflicts) keep running. The dashboard PR row distinguishes the two states with separate badges (review badge `review-escalated` vs. build badge `build-escalated`).
+- Fix agents validate each requested-change claim before editing. Invalid, stale, already-addressed, out-of-scope, or harmful feedback should get a respectful evidence-backed rebuttal rather than a success-shaped code change.
 
 ### C. Build failures (`buildStatus === 'failing'`)
 

package/engine/cli.js

@@ -1157,11 +1157,14 @@ const commands = {
     }
 
     const config = getConfig();
-    const { getProjects, projectWorkItemsPath } = require('./shared');
+    const { getProjects, projectWorkItemsPath, resolveProjectSource } = require('./shared');
     const projects = getProjects(config);
-    const targetProject = opts.project
-      ? projects.find(p => p.name?.toLowerCase() === opts.project?.toLowerCase()) || projects[0]
-      : projects[0];
+    const target = opts.project ? resolveProjectSource(opts.project, projects, { allowCentral: false }) : null;
+    if (target?.error) {
+      console.log(target.error);
+      return;
+    }
+    const targetProject = target?.project || projects[0];
     const wiPath = projectWorkItemsPath(targetProject);
     let item;
     mutateWorkItems(wiPath, items => {
@@ -1202,11 +1205,14 @@ const commands = {
     }
 
     const config = getConfig();
-    const { getProjects } = require('./shared');
+    const { getProjects, resolveProjectSource } = require('./shared');
     const projects = getProjects(config);
-    const targetProject = projectName
-      ? projects.find(p => p.name?.toLowerCase() === projectName.toLowerCase()) || projects[0]
-      : projects[0];
+    const target = projectName ? resolveProjectSource(projectName, projects, { allowCentral: false }) : null;
+    if (target?.error) {
+      console.log(target.error);
+      return;
+    }
+    const targetProject = target?.project || projects[0];
 
     if (!targetProject) {
       console.log('No projects configured. Run: minions add <dir>');
@@ -1395,7 +1401,7 @@ const commands = {
           const wiPath = (item.meta.source === 'central-work-item' || item.meta.source === 'central-work-item-fanout')
             ? path.join(MINIONS_DIR, 'work-items.json')
             : item.meta.project?.localPath
-              ? shared.projectWorkItemsPath({ localPath: item.meta.project.localPath, name: item.meta.project.name, workSources: config.projects?.find(p => p.name === item.meta.project.name)?.workSources })
+              ? shared.projectWorkItemsPath(shared.resolveProjectSource(item.meta.project, config.projects || [], { allowCentral: false }).project || item.meta.project)
               : null;
           if (wiPath) {
             mutateWorkItems(wiPath, items => {

package/engine/copilot-models.json

@@ -1,5 +1,5 @@
 {
   "runtime": "copilot",
   "models": null,
-  "cachedAt": "2026-05-08T20:58:39.806Z"
+  "cachedAt": "2026-05-09T08:23:02.798Z"
 }

package/engine/dispatch.js

@@ -79,7 +79,8 @@ function mutateDispatch(mutator) {
 
 function getDispatchProjectKey(project) {
   if (!project) return '';
-  return project.name || (project.localPath ? path.resolve(project.localPath).toLowerCase() : '');
+  if (project.name) return String(project.name).toLowerCase();
+  return project.localPath ? path.resolve(project.localPath).toLowerCase() : '';
 }
 
 function getPrDispatchTargetKey(entry) {
@@ -176,15 +177,8 @@ function addToDispatch(item) {
 function _resolveDispatchProject(projectRef, config) {
   if (!projectRef) return null;
   const projects = getProjects(config);
-  if (projectRef.name) {
-    const byName = projects.find(p => p.name === projectRef.name);
-    if (byName) return byName;
-  }
-  if (projectRef.localPath) {
-    const refPath = path.resolve(projectRef.localPath);
-    const byPath = projects.find(p => p.localPath && path.resolve(p.localPath) === refPath);
-    if (byPath) return byPath;
-  }
+  const resolved = shared.resolveProjectSource(projectRef, projects, { allowCentral: false });
+  if (resolved.project) return resolved.project;
   return projectRef;
 }
 

package/engine/lifecycle.js

@@ -160,7 +160,8 @@ function checkPlanCompletion(meta, config) {
   // Resolve the primary project for writing new work items (PR, verify)
   const projectName = plan.project;
   const primaryProject = projectName
-    ? projects.find(p => p.name?.toLowerCase() === projectName?.toLowerCase()) : projects[0];
+    ? shared.resolveProjectSource(projectName, projects, { allowCentral: false }).project
+    : (projects.length === 1 ? projects[0] : null);
   if (!primaryProject) {
     log('warn', `Plan ${planFile}: no primary project found — skipping PR/verify creation`);
     return;
@@ -196,9 +197,8 @@ function checkPlanCompletion(meta, config) {
     log('info', `Plan ${planFile}: verify WI ${existingVerify.id} already ${existingVerify.status} — skipping`);
   } else if (isReopenableVerify(existingVerify) && doneItems.length > 0) {
     const verifyProject = existingVerify.project || projectName;
-    const vWiPath = shared.projectWorkItemsPath(
-      projects.find(p => p.name?.toLowerCase() === verifyProject?.toLowerCase()) || primaryProject
-    );
+    const vProject = shared.resolveProjectSource(verifyProject, projects, { allowCentral: false }).project || primaryProject;
+    const vWiPath = shared.projectWorkItemsPath(vProject);
     let reopenedVerify = false;
     mutateWorkItems(vWiPath, items => {
       const v = items.find(w => w.id === existingVerify.id);
@@ -777,7 +777,8 @@ function syncPrsFromOutput(output, agentId, meta, config, opts = {}) {
 
   const projects = shared.getProjects(config);
   if (projects.length === 0 && !meta?.project?.name) return 0;
-  const defaultProject = (meta?.project?.name && projects.find(p => p.name === meta.project.name)) || projects[0];
+  const defaultProject = (meta?.project?.name && shared.resolveProjectSource(meta.project.name, projects, { allowCentral: false }).project) ||
+    (projects.length === 1 ? projects[0] : null);
   const useCentral = !defaultProject;
 
   // Match each PR to its correct project by finding which repo URL appears near the PR number in output
@@ -950,16 +951,15 @@ function hasCanonicalPrAttachment(itemId, config) {
 function resolvePrFallbackProject(meta, config) {
   const projects = shared.getProjects(config);
   if (meta?.project?.name) {
-    const match = projects.find(p => p.name === meta.project.name);
+    const match = shared.resolveProjectSource(meta.project.name, projects, { allowCentral: false }).project;
     if (match) return match;
   }
   if (meta?.project?.localPath) {
-    const metaPath = path.resolve(meta.project.localPath);
-    const match = projects.find(p => p.localPath && path.resolve(p.localPath) === metaPath);
+    const match = shared.resolveProjectSource(meta.project.localPath, projects, { allowCentral: false }).project;
     if (match) return match;
   }
   if (meta?.item?.project) {
-    const match = projects.find(p => p.name === meta.item.project);
+    const match = shared.resolveProjectSource(meta.item.project, projects, { allowCentral: false }).project;
     if (match) return match;
   }
   return projects.length === 1 ? projects[0] : null;
@@ -1813,7 +1813,7 @@ async function processPendingRebases(config) {
   for (const entry of snapshot) {
     if (isBranchActive(entry.branch)) { remaining.push(entry); continue; }
 
-    const project = shared.getProjects(config).find(p => p.name === entry.projectName);
+    const project = shared.resolveProjectSource(entry.projectName, shared.getProjects(config), { allowCentral: false }).project;
     if (!project) continue;
 
     const prs = getPrs(project);
@@ -2037,7 +2037,7 @@ function extractSkillsFromOutput(output, agentId, dispatchItem, config, runtimeN
     if (!m('created')) enrichedBlock = enrichedBlock.replace('---\n', `---\ncreated: ${dateStamp()}\n`);
     const skillDirName = name.replace(/[^a-z0-9-]/g, '-');
     if (scope === 'project' && project) {
-      const proj = shared.getProjects(config).find(p => p.name === project);
+      const proj = shared.resolveProjectSource(project, shared.getProjects(config), { allowCentral: false }).project;
       if (proj) {
         const projectSkillRoot = skillWriteTargets(effectiveRuntime, proj).project
           || path.resolve(proj.localPath, '.claude', 'skills');

package/engine/pipeline.js

@@ -200,6 +200,44 @@ function collectPipelinePrRefs(pipeline, run) {
   return refs;
 }
 
+function _pipelineProjectValues(...values) {
+  const out = [];
+  for (const value of values) {
+    if (value === undefined) continue;
+    if (Array.isArray(value)) out.push(...value);
+    else out.push(value);
+  }
+  return out;
+}
+
+function _resolvePipelineProjects(values, config) {
+  const projects = shared.getProjects(config);
+  const rawValues = _pipelineProjectValues(...values);
+  if (rawValues.length === 0) return { projects: [null] };
+  const resolved = [];
+  const seen = new Set();
+  for (const raw of rawValues) {
+    if (raw === undefined) continue;
+    if (raw === null || String(raw).trim().toLowerCase() === 'central') {
+      if (!seen.has('central')) { seen.add('central'); resolved.push(null); }
+      continue;
+    }
+    const result = shared.resolveConfiguredProject(raw, projects);
+    if (result.error) return { error: result.error };
+    const key = result.project?.name || 'central';
+    if (!seen.has(key)) { seen.add(key); resolved.push(result.project || null); }
+  }
+  return { projects: resolved.length ? resolved : [null] };
+}
+
+function _pipelineProjectSlug(project) {
+  return project ? shared.safeSlugComponent(project.name || 'project', 32).toLowerCase() : 'central';
+}
+
+function _pipelineWorkItemsPath(project) {
+  return project ? shared.projectWorkItemsPath(project) : CENTRAL_WI_PATH;
+}
+
 // ── Condition Evaluation ─────────────────────────────────────────────────────
 
 /**
@@ -267,11 +305,11 @@ async function executeStage(stage, run, pipeline, config) {
 
   switch (resolved.type) {
     case STAGE_TYPE.TASK:
-      return executeTaskStage(resolved, stageState, run, config);
+      return executeTaskStage(resolved, stageState, run, config, pipeline);
     case STAGE_TYPE.MEETING:
       return executeMeetingStage(resolved, stageState, run, config);
     case STAGE_TYPE.PLAN:
-      return executePlanStage(resolved, stageState, run, config);
+      return executePlanStage(resolved, stageState, run, config, pipeline);
     case STAGE_TYPE.API:
       return executeApiStage(resolved, stageState, run);
     case STAGE_TYPE.MERGE_PRS:
@@ -291,8 +329,57 @@ async function executeStage(stage, run, pipeline, config) {
   }
 }
 
-function executeTaskStage(stage, stageState, run, config) {
+function executeTaskStage(stage, stageState, run, config, pipeline = {}) {
   // Create work item(s) for the task
+  const items = stage.items || [{ title: stage.title, description: stage.description || '', type: stage.taskType || 'explore', agent: stage.agent }];
+  const count = stage.count || items.length;
+  const createdIds = [];
+  const touchedProjects = [];
+
+  for (let i = 0; i < count; i++) {
+    const item = items[i % items.length];
+    const projectResolution = _resolvePipelineProjects([
+      item.projects,
+      item.project,
+      stage.projects,
+      stage.project,
+      pipeline.projects,
+      pipeline.project,
+    ], config);
+    if (projectResolution.error) return { status: PIPELINE_STATUS.FAILED, error: projectResolution.error };
+    for (const project of projectResolution.projects) {
+      const projectSlug = _pipelineProjectSlug(project);
+      const id = `PL-${run.runId.slice(4, 12)}-${stage.id}-${i}${projectResolution.projects.length > 1 || project ? '-' + projectSlug : ''}`;
+      const wiPath = _pipelineWorkItemsPath(project);
+      mutateWorkItems(wiPath, workItems => {
+        if (workItems.some(w => w.id === id)) { createdIds.push(id); return workItems; }
+        workItems.push({
+          id,
+          title: item.title || stage.title,
+          description: item.description || stage.description || '',
+          type: routing.normalizeWorkType(item.type || stage.taskType, WORK_TYPE.EXPLORE),
+          priority: item.priority || stage.priority || 'medium',
+          // Agent is a soft routing hint unless agentLock/hardAgent is set.
+          ...(item.agent || stage.agent ? { agent: item.agent || stage.agent } : {}),
+          ...(item.agentLock === true || stage.agentLock === true || item.hardAgent === true || stage.hardAgent === true ? { agentLock: true } : {}),
+          ...(project ? { project: project.name } : {}),
+          status: WI_STATUS.PENDING,
+          created: ts(),
+          createdBy: 'pipeline:' + run.pipelineId,
+          branch: `pipeline/${run.pipelineId}/${stage.id}`,
+          _pipelineRun: run.runId,
+          _pipelineStage: stage.id,
+        });
+        return workItems;
+      });
+      createdIds.push(id);
+      touchedProjects.push(project?.name || null);
+    }
+  }
+  return { status: PIPELINE_STATUS.RUNNING, artifacts: { workItems: [...new Set(createdIds)], projects: [...new Set(touchedProjects)] } };
+}
+
+function executeTaskStageLegacy(stage, stageState, run, config) {
   const items = stage.items || [{ title: stage.title, description: stage.description || '', type: stage.taskType || 'explore', agent: stage.agent }];
   const count = stage.count || items.length;
   const wiPath = CENTRAL_WI_PATH;
@@ -396,13 +483,15 @@ function _findExistingPrdForPlan(planFile, prdDir) {
   return null;
 }
 
-async function executePlanStage(stage, stageState, run, config) {
+async function executePlanStage(stage, stageState, run, config, pipeline = {}) {
   const plansDir = PLANS_DIR;
   if (!fs.existsSync(plansDir)) fs.mkdirSync(plansDir, { recursive: true });
 
   const slug = slugify(stage.title || 'pipeline-plan');
-  const wiPath = CENTRAL_WI_PATH;
-  const wiId = `PL-${run.runId.slice(4, 12)}-${stage.id}-prd`;
+  const projectResolution = _resolvePipelineProjects([stage.projects, stage.project, pipeline.projects, pipeline.project], config);
+  if (projectResolution.error) return { status: PIPELINE_STATUS.FAILED, error: projectResolution.error };
+  const targetProjects = projectResolution.projects;
+  const wiIdForProject = (project) => `PL-${run.runId.slice(4, 12)}-${stage.id}-prd${targetProjects.length > 1 || project ? '-' + _pipelineProjectSlug(project) : ''}`;
 
   // ── Reconciliation: check if a plan already exists for a meeting in this run ──
   const meetingIds = _findMeetingsInRun(run);
@@ -422,26 +511,33 @@ async function executePlanStage(stage, stageState, run, config) {
         };
       }
 
-      // 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,
-          });
-        }
-      });
+      // Adopt or create plan-to-prd WIs atomically under lock for each target project.
+      const adoptedWiIds = [];
+      for (const project of targetProjects) {
+        const wiPath = _pipelineWorkItemsPath(project);
+        const wiId = wiIdForProject(project);
+        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,
+              ...(project ? { project: project.name } : {}),
+            });
+          }
+        });
+        adoptedWiIds.push(adoptedWiId);
+      }
       return {
         status: PIPELINE_STATUS.RUNNING,
-        artifacts: { plans: [existingPlanFile], workItems: [adoptedWiId], prds: [], prs: [] },
+        artifacts: { plans: [existingPlanFile], workItems: adoptedWiIds, prds: [], prs: [], projects: targetProjects.map(p => p?.name || null) },
       };
     }
   }
@@ -511,32 +607,39 @@ async function executePlanStage(stage, stageState, run, config) {
   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
-  mutateWorkItems(wiPath, workItems => {
-    if (!workItems.some(w => w.id === wiId)) {
-      workItems.push({
-        id: wiId,
-        title: `Convert plan to PRD: ${path.basename(filePath)}`,
-        type: WORK_TYPE.PLAN_TO_PRD,
-        priority: 'high',
-        status: WI_STATUS.PENDING,
-        planFile: path.basename(filePath),
-        created: ts(),
-        createdBy: 'pipeline:' + run.pipelineId,
-        branch: `pipeline/${run.pipelineId}/${stage.id}`,
-        _pipelineRun: run.runId,
-        _pipelineStage: stage.id,
-      });
-    }
-  });
+  const createdWiIds = [];
+  for (const project of targetProjects) {
+    const wiPath = _pipelineWorkItemsPath(project);
+    const wiId = wiIdForProject(project);
+    mutateWorkItems(wiPath, workItems => {
+      if (!workItems.some(w => w.id === wiId)) {
+        workItems.push({
+          id: wiId,
+          title: `Convert plan to PRD: ${path.basename(filePath)}`,
+          type: WORK_TYPE.PLAN_TO_PRD,
+          priority: 'high',
+          status: WI_STATUS.PENDING,
+          planFile: path.basename(filePath),
+          created: ts(),
+          createdBy: 'pipeline:' + run.pipelineId,
+          branch: `pipeline/${run.pipelineId}/${stage.id}`,
+          _pipelineRun: run.runId,
+          _pipelineStage: stage.id,
+          ...(project ? { project: project.name } : {}),
+        });
+      }
+    });
+    createdWiIds.push(wiId);
+  }
 
   return {
     status: PIPELINE_STATUS.RUNNING,
     artifacts: {
       plans: [path.basename(filePath)],
-      workItems: [wiId],
+      workItems: createdWiIds,
       prds: [], // discovered later when PRD materializes
       prs: [],  // discovered later when agents create PRs
+      projects: targetProjects.map(p => p?.name || null),
     }
   };
 }

package/engine/projects.js

@@ -56,8 +56,7 @@ function removeProject(target, options = {}) {
   try { config = JSON.parse(fs.readFileSync(configPath, 'utf8')); }
   catch (e) { return { ...summary, error: 'Failed to read config: ' + e.message }; }
 
-  const project = (config.projects || []).find(p =>
-    p.name === target || path.resolve(p.localPath || '') === path.resolve(target));
+  const project = shared.findProjectByNameOrPath(config.projects || [], target);
   if (!project) {
     const available = (config.projects || []).map(p => p.name).join(', ') || '(none)';
     return { ...summary, error: `No project linked matching: ${target}. Available: ${available}` };
@@ -66,21 +65,21 @@ function removeProject(target, options = {}) {
 
   // 1. Cancel pending/queued work items linked to this project (project-local
   //    file + central). Done items are preserved as history.
-  for (const wiPath of [
-    path.join(MINIONS_DIR, 'projects', project.name, 'work-items.json'),
+  summary.cancelledItems += dispatch.cancelPendingWorkItems(
+    shared.projectWorkItemsPath(project),
+    () => true,
+    'project-removed',
+  );
+  summary.cancelledItems += dispatch.cancelPendingWorkItems(
     path.join(MINIONS_DIR, 'work-items.json'),
-  ]) {
-    summary.cancelledItems += dispatch.cancelPendingWorkItems(
-      wiPath,
-      w => !w.project || w.project === project.name,
-      'project-removed',
-    );
-  }
+    w => String(w.project || '').toLowerCase() === String(project.name || '').toLowerCase(),
+    'project-removed',
+  );
 
   // 2. Drain dispatch — also kills active agent processes and unlinks pid +
   //    prompt sidecars in engine/tmp/, matching what plan delete does.
   summary.drainedDispatches = dispatch.cleanDispatchEntries(
-    d => _dispatchProjectName(d) === project.name,
+    d => String(_dispatchProjectName(d) || '').toLowerCase() === String(project.name || '').toLowerCase(),
   );
 
   // 3. Clean up worktrees under this project's worktree root, honoring
@@ -104,7 +103,7 @@ function removeProject(target, options = {}) {
   //    specifically. Don't touch schedules with project='any' or unset.
   if (Array.isArray(config.schedules)) {
     for (const s of config.schedules) {
-      if (s.project === project.name && s.enabled !== false) {
+      if (shared.resolveProjectSource(s.project, [project], { allowCentral: false }).project && s.enabled !== false) {
         s.enabled = false;
         summary.disabledSchedules++;
       }
@@ -165,20 +164,20 @@ function removeProject(target, options = {}) {
         ...(p.monitoredResources || []),
         ...((p.stages || []).flatMap(s => s.monitoredResources || [])),
       ];
-      if (refs.some(r => r && (r.project === project.name || r._project === project.name))) {
+      if (refs.some(r => r && shared.resolveProjectSource(r.project || r._project, [project], { allowCentral: false }).project)) {
         summary.pipelineRefs.push(p.id);
       }
     }
   } catch { /* pipelines optional */ }
 
   // 7. Remove from config.json (and persist any schedule disables)
-  config.projects = (config.projects || []).filter(p => p.name !== project.name);
+  config.projects = (config.projects || []).filter(p => !shared.resolveProjectSource(p, [project], { allowCentral: false }).project);
   try { fs.writeFileSync(configPath, JSON.stringify(config, null, 2)); }
   catch (e) { return { ...summary, error: 'Failed to write config: ' + e.message }; }
 
   // 8. Move (or purge) projects/<name>/ — preserves PR/work-item history by
   //    default so a re-add can pick up where it left off.
-  const dataDir = path.join(MINIONS_DIR, 'projects', project.name);
+  const dataDir = shared.projectStateDir(project);
   if (fs.existsSync(dataDir)) {
     if (dataMode === 'purge') {
       try { fs.rmSync(dataDir, { recursive: true, force: true }); summary.purgedDataDir = true; }

package/engine/queries.js

@@ -703,7 +703,7 @@ function buildPrUrlFromId(prId, pr, projects) {
       }
     }
   }
-  const project = pr?._project ? projects.find(p => p.name === pr._project) : null;
+  const project = pr?._project ? shared.resolveProjectSource(pr._project, projects, { allowCentral: false }).project : null;
   const prNumber = shared.getPrNumber(pr || prId);
   if (project?.prUrlBase && prNumber != null) return project.prUrlBase + prNumber;
   return '';
@@ -1179,7 +1179,7 @@ function getWorkItems(config) {
   const allPrs = getPullRequests(config);
   for (const item of allItems) {
     if (item._pr && !item._prUrl) {
-      const project = projects.find(p => p.name === item.project || p.name === item._source) || null;
+      const project = shared.resolveProjectSource(item.project || item._source, projects, { allowCentral: false }).project || null;
       const canonicalPrId = shared.getCanonicalPrId(project, item._pr);
       const displayPrId = shared.getPrDisplayId(item._pr);
       const exactPr = allPrs.find(p => p.id === canonicalPrId);
@@ -1418,7 +1418,7 @@ function getPrdInfo(config) {
   // Fallback: work item _pr field for anything still missing
   for (const wi of Object.values(wiById)) {
     if (!wi._pr || prdToPr[wi.id]?.length) continue;
-    const project = projects.find(p => p.name === wi.project || p.name === wi._source) || null;
+    const project = shared.resolveProjectSource(wi.project || wi._source, projects, { allowCentral: false }).project || null;
     const canonicalPrId = shared.getCanonicalPrId(project, wi._pr);
     const exactPr = prById[canonicalPrId] || null;
     const displayMatches = exactPr ? [] : Object.values(prById).filter(candidate => shared.getPrDisplayId(candidate) === shared.getPrDisplayId(wi._pr));