@yemi33/minions 0.1.1811 → 0.1.1813

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 0.1.1813 (2026-05-09)
+
+### Features
+- improve manual PR project inference (#2242)
+
+## 0.1.1812 (2026-05-09)
+
+### Features
+- stop invalid project fallback (#2245)
+- harden doc-chat dispatch prompt (#2249)
+
 ## 0.1.1811 (2026-05-09)
 
 ### Features

package/dashboard/js/command-center.js

@@ -1022,6 +1022,7 @@ function _tagServerExecuted(actions, actionResults) {
       if (r.id) actions[i]._serverId = r.id;
       if (r.warning) actions[i]._serverWarning = r.warning;
       if (r.duplicate) actions[i]._serverDuplicate = true;
+      if (r.reusedFromAction !== undefined) actions[i]._serverHidden = true;
     } else if (r && r.error) {
       actions[i]._serverExecuted = true;
       actions[i]._serverError = r.error;
@@ -1037,15 +1038,18 @@ async function ccExecuteAction(action, targetTabId) {
 
   // Server-executed actions: just show status, don't re-fire the API
   if (action._serverExecuted) {
+    if (action._serverHidden) return;
     if (action._serverError) {
       status.innerHTML = '✗ ' + escHtml(action.type) + ' failed: ' + escHtml(action._serverError);
       status.style.color = 'var(--red)';
     } else {
       var label = action._serverId ? escHtml(action._serverId) : escHtml(action.title || action.type);
-      status.innerHTML = '&#10003; ' + escHtml(action.type) + ': <strong>' + label + '</strong>' +
-        (action._serverDuplicate ? ' <span style="color:var(--orange)">already exists</span>' : '') +
+      var serverActionType = action.type || '';
+      var successLabel = serverActionType === 'dispatch' ? 'Dispatched' : serverActionType;
+      status.innerHTML = '&#10003; ' + escHtml(successLabel) + ': <strong>' + label + '</strong>' +
+        (action._serverDuplicate ? '<div style="font-size:10px;color:var(--orange);margin-top:2px">Already existed from a previous request; no duplicate work item was created.</div>' : '') +
         (action._serverWarning ? '<div style="font-size:10px;color:var(--muted);margin-top:2px">' + escHtml(action._serverWarning) + '</div>' : '');
-      status.style.color = action._serverDuplicate ? 'var(--orange)' : 'var(--green)';
+      status.style.color = 'var(--green)';
     }
     ccAddMessage('action', status.outerHTML, false, targetTabId);
     if (['dispatch','fix','explore','review','test','create-meeting'].includes(action.type)) wakeEngine();
@@ -1336,8 +1340,10 @@ async function ccExecuteAction(action, targetTabId) {
         break;
       }
       case 'link-pr': {
-        await _ccFetch('/api/pull-requests/link', { url: action.url, title: action.title || '', project: action.project || '', autoObserve: action.autoObserve !== false });
-        status.innerHTML = '&#10003; PR linked: <strong>' + escHtml(action.url) + '</strong>';
+        var prLinkRes = await _ccFetch('/api/pull-requests/link', { url: action.url, title: action.title || '', project: action.project || '', autoObserve: action.autoObserve !== false });
+        var prLinkData = await prLinkRes.json().catch(function() { return {}; });
+        status.innerHTML = '&#10003; PR linked: <strong>' + escHtml(action.url) + '</strong>' +
+          (prLinkData.message ? '<div style="font-size:11px;color:var(--muted);margin-top:4px">' + escHtml(prLinkData.message) + '</div>' : '');
         status.style.color = 'var(--green)';
         break;
       }

package/dashboard/js/modal-qa.js

@@ -367,9 +367,10 @@ function _qaBuildActionFeedbackHtml(actionFeedback) {
       return '<div class="modal-qa-action-feedback" style="' + baseStyle + 'color:var(--red)">&#10007; ' + type + ' failed: ' + escHtml(item.error) + '</div>';
     }
     const label = escHtml(item.id || item.duplicateOf || '');
-    const duplicate = item.duplicate ? ' <span style="color:var(--orange)">already exists</span>' : '';
+    const verb = item.type === 'dispatch' ? 'Dispatched' : type;
+    const duplicate = item.duplicate ? '<div style="font-size:10px;color:var(--orange);margin-top:2px">Already existed from a previous request; no duplicate work item was created.</div>' : '';
     const warning = item.warning ? '<div style="font-size:10px;color:var(--muted);margin-top:2px">' + escHtml(item.warning) + '</div>' : '';
-    return '<div class="modal-qa-action-feedback" style="' + baseStyle + 'color:' + (item.duplicate ? 'var(--orange)' : 'var(--green)') + '">&#10003; ' + type + ': <strong>' + label + '</strong>' + duplicate + warning + '</div>';
+    return '<div class="modal-qa-action-feedback" style="' + baseStyle + 'color:var(--green)">&#10003; ' + verb + ': <strong>' + label + '</strong>' + duplicate + warning + '</div>';
   }).join('');
 }
 

package/dashboard/js/render-prs.js

@@ -125,7 +125,7 @@ function openAddPrModal() {
     '<div style="display:flex;flex-direction:column;gap:10px">' +
       '<label style="color:var(--text);font-size:var(--text-md)">PR URL <input id="pr-link-url" style="' + inputStyle + '" placeholder="https://github.com/org/repo/pull/123"></label>' +
       '<label style="color:var(--text);font-size:var(--text-md)">Title <input id="pr-link-title" style="' + inputStyle + '" placeholder="Short description (optional — auto-detected from URL)"></label>' +
-      '<label style="color:var(--text);font-size:var(--text-md)">Project <select id="pr-link-project" style="' + inputStyle + '"><option value="">Auto / Central</option>' + projOpts + '</select></label>' +
+      '<label style="color:var(--text);font-size:var(--text-md)">Project <select id="pr-link-project" style="' + inputStyle + '"><option value="">Auto-detect from URL (central if no unique match)</option>' + projOpts + '</select></label>' +
       '<label style="color:var(--text);font-size:var(--text-md)">Context <textarea id="pr-link-context" rows="3" style="' + inputStyle + ';resize:vertical" placeholder="Why are you linking this? What should agents know about it?"></textarea></label>' +
       '<label style="display:flex;align-items:center;gap:8px;color:var(--text);font-size:var(--text-md);margin-top:4px;cursor:pointer">' +
         '<input type="checkbox" id="pr-link-observe" style="width:16px;height:16px;accent-color:var(--blue)">' +
@@ -151,14 +151,16 @@ async function _submitLinkPr(e) {
   const autoObserve = document.getElementById('pr-link-observe')?.checked || false;
 
   try { closeModal(); } catch { /* expected */ }
-  showToast('cmd-toast', 'PR linked' + (autoObserve ? ' (auto-observe on)' : ''), true);
   try {
     const res = await fetch('/api/pull-requests/link', {
       method: 'POST', headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({ url, title, project, context, autoObserve })
     });
     const data = await res.json();
-    if (res.ok) { refresh(); } else { alert('Failed: ' + (data.error || 'unknown')); openAddPrModal(); }
+    if (res.ok) {
+      showToast('cmd-toast', (data.message || 'PR linked') + (autoObserve ? ' (auto-observe on)' : ''), true, 6000);
+      refresh();
+    } else { alert('Failed: ' + (data.error || 'unknown')); openAddPrModal(); }
   } catch (e) { alert('Error: ' + e.message); openAddPrModal(); }
 }
 

package/dashboard.js

@@ -97,6 +97,13 @@ function reloadConfig() {
 }
 ensureConfiguredProjectStateFiles();
 
+function resolveScheduleProjectValue(project, projects = PROJECTS) {
+  if (project === undefined) return { project: undefined };
+  const target = shared.resolveConfiguredProject(project, projects);
+  if (target.error) return { project: null, error: target.error };
+  return { project: target.project?.name || null };
+}
+
 function mutateDashboardConfig(mutator) {
   return mutateJsonFileLocked(CONFIG_PATH, (config) => {
     if (!config || typeof config !== 'object' || Array.isArray(config)) config = {};
@@ -375,6 +382,83 @@ function findProjectByName(projects, projectName) {
   return shared.findProjectByName(projects, projectName);
 }
 
+function resolveManualPrLinkProject(url, projectName, projects = PROJECTS) {
+  const explicitProjectName = String(projectName || '').trim();
+  if (explicitProjectName) {
+    const explicitProject = shared.resolveProjectSource(explicitProjectName, projects, { allowCentral: false, minionsDir: MINIONS_DIR });
+    if (explicitProject.error) {
+      const err = new Error(explicitProject.error);
+      err.statusCode = 400;
+      throw err;
+    }
+    const targetProject = explicitProject.project;
+    return {
+      project: targetProject,
+      resolution: {
+        reason: 'explicit',
+        project: targetProject.name || explicitProjectName,
+        storage: 'project',
+        message: `Linked to selected project "${targetProject.name || explicitProjectName}".`,
+      },
+    };
+  }
+
+  const parsedPr = shared.parsePrUrl(url);
+  const prScope = parsedPr?.scope || '';
+  if (!prScope) {
+    return {
+      project: null,
+      resolution: {
+        reason: 'unrecognized-url',
+        project: 'central',
+        storage: 'central',
+        message: 'Could not infer a project from this PR URL; linked in central PR tracking.',
+      },
+    };
+  }
+
+  const matches = projects.filter(p => shared.getProjectPrScope(p) === prScope);
+  if (matches.length === 1) {
+    const targetProject = matches[0];
+    return {
+      project: targetProject,
+      resolution: {
+        reason: 'inferred',
+        scope: prScope,
+        project: targetProject.name || '',
+        storage: 'project',
+        message: `Inferred project "${targetProject.name}" from PR scope ${prScope}.`,
+      },
+    };
+  }
+
+  if (matches.length > 1) {
+    const names = matches.map(p => p.name).filter(Boolean);
+    return {
+      project: null,
+      resolution: {
+        reason: 'ambiguous',
+        scope: prScope,
+        project: 'central',
+        storage: 'central',
+        matches: names,
+        message: `PR scope ${prScope} matches multiple configured projects (${names.join(', ')}); linked in central PR tracking. Select a project to attach it.`,
+      },
+    };
+  }
+
+  return {
+    project: null,
+    resolution: {
+      reason: 'unmatched',
+      scope: prScope,
+      project: 'central',
+      storage: 'central',
+      message: `No configured project matches PR scope ${prScope}; linked in central PR tracking.`,
+    },
+  };
+}
+
 function resolveWorkItemsCreateTarget(projectName, projects = PROJECTS) {
   const target = shared.resolveProjectSource(projectName, projects, { defaultWhenSingle: true, minionsDir: MINIONS_DIR });
   if (target.error) return { error: target.error };
@@ -409,6 +493,73 @@ function findWorkItemsTargetById(id, source, projects = PROJECTS) {
   return { found: false };
 }
 
+function buildPlanWorkItem(body, projects = PROJECTS, options = {}) {
+  if (!body?.title || !String(body.title).trim()) return { error: 'title is required' };
+  const target = resolveWorkItemsCreateTarget(body.project, projects);
+  if (target.error) return { error: target.error };
+  let now = options.now ? new Date(options.now) : new Date();
+  if (!Number.isFinite(now.getTime())) now = new Date();
+  const item = {
+    id: options.id || ('W-' + shared.uid()),
+    title: body.title,
+    type: 'plan',
+    priority: body.priority || 'high',
+    description: body.description || '',
+    status: WI_STATUS.PENDING,
+    created: now.toISOString(),
+    createdBy: 'dashboard',
+    branchStrategy: body.branch_strategy || body.branchStrategy || 'parallel',
+  };
+  if (target.project) item.project = target.project.name;
+  if (body.agent) item.agent = body.agent;
+  return { item, id: item.id };
+}
+
+function buildManualPrdItemPlan(body, projects = PROJECTS, options = {}) {
+  if (!body?.name || !String(body.name).trim()) return { error: 'name is required' };
+  const target = resolveWorkItemsCreateTarget(body.project, projects);
+  if (target.error) return { error: target.error };
+
+  const overrideProject = body.item_project ?? body.itemProject;
+  const itemProjectTarget = overrideProject !== undefined
+    ? shared.resolveConfiguredProject(overrideProject, projects)
+    : null;
+  if (itemProjectTarget?.error) return { error: itemProjectTarget.error };
+
+  let now = options.now ? new Date(options.now) : new Date();
+  if (!Number.isFinite(now.getTime())) now = new Date();
+  const nowTime = now.getTime();
+  const projectName = target.project?.name || (projects.length > 0 ? projects[0].name : 'Unknown');
+  const itemProjectName = itemProjectTarget?.project?.name || target.project?.name || (projects.length === 1 ? projects[0].name : '');
+  const item = {
+    id: body.id || ('M' + String(nowTime).slice(-4)),
+    name: String(body.name).trim(),
+    description: body.description || '',
+    priority: body.priority || 'medium',
+    estimated_complexity: body.estimated_complexity || 'medium',
+    status: 'missing',
+    depends_on: [],
+    acceptance_criteria: [],
+  };
+  if (itemProjectName) item.project = itemProjectName;
+
+  return {
+    plan: {
+      version: 'manual-' + now.toISOString().slice(0, 10),
+      project: projectName,
+      generated_by: 'dashboard',
+      generated_at: now.toISOString().slice(0, 10),
+      plan_summary: item.name,
+      status: 'approved',
+      requires_approval: false,
+      branch_strategy: 'parallel',
+      missing_features: [item],
+      open_questions: [],
+    },
+    id: item.id,
+  };
+}
+
 function validatePipelineProjects(pipeline, projects = PROJECTS) {
   const refs = [];
   const collect = (value) => {
@@ -418,6 +569,7 @@ function validatePipelineProjects(pipeline, projects = PROJECTS) {
       if (value.project !== undefined) collect(value.project);
       else if (value._project !== undefined) collect(value._project);
       else if (value.name !== undefined) collect(value.name);
+      else if (value.localPath !== undefined) collect(value.localPath);
       return;
     }
     refs.push(String(value));
@@ -480,21 +632,7 @@ function linkPullRequestForTracking({ url, title, project: projectName, autoObse
     throw err;
   }
   const projects = shared.getProjects(config);
-  const explicitProjectName = String(projectName || '').trim();
-  const explicitProject = explicitProjectName
-    ? shared.resolveProjectSource(explicitProjectName, projects, { allowCentral: false, minionsDir: MINIONS_DIR })
-    : null;
-  let targetProject = explicitProject?.project || null;
-  if (explicitProject?.error) {
-    const err = new Error(explicitProject.error);
-    err.statusCode = 400;
-    throw err;
-  }
-  if (!explicitProjectName) {
-    const prScope = shared.parsePrUrl(url)?.scope || '';
-    const matches = prScope ? projects.filter(p => shared.getProjectPrScope(p) === prScope) : [];
-    if (matches.length === 1) targetProject = matches[0];
-  }
+  const { project: targetProject, resolution: projectResolution } = resolveManualPrLinkProject(url, projectName, projects);
   const prPath = targetProject ? shared.projectPrPath(targetProject) : shared.centralPullRequestsPath(MINIONS_DIR);
 
   const prNumMatch = url.match(/\/pull\/(\d+)|pullrequest\/(\d+)/);
@@ -519,11 +657,12 @@ function linkPullRequestForTracking({ url, title, project: projectName, autoObse
     _contextOnly: !autoObserve,
     _autoObserve: !!autoObserve,
     _context: contextText,
+    _projectResolution: projectResolution,
   }, {
     project: targetProject,
     itemId: linkedWorkItemId,
   });
-  return { ...result, prPath, targetProject, prNum };
+  return { ...result, prPath, targetProject, projectResolution, prNum };
 }
 
 function _normalizeSkillDirForCompare(dir) {
@@ -2686,6 +2825,8 @@ function normalizePipelineForCompare(pipeline) {
     stages: Array.isArray(pipeline.stages) ? pipeline.stages : [],
     trigger: pipeline.trigger && typeof pipeline.trigger === 'object' ? pipeline.trigger : {},
     enabled: pipeline.enabled !== false,
+    project: pipeline.project !== undefined ? pipeline.project : null,
+    projects: Array.isArray(pipeline.projects) ? pipeline.projects : [],
     stopWhen: pipeline.stopWhen || null,
     monitoredResources: Array.isArray(pipeline.monitoredResources) ? pipeline.monitoredResources : [],
   };
@@ -2699,6 +2840,8 @@ function buildPipelineFromAction(action) {
     trigger: action.trigger && typeof action.trigger === 'object' ? action.trigger : {},
     enabled: action.enabled !== false,
   };
+  if (action.project !== undefined) pipeline.project = action.project;
+  if (Array.isArray(action.projects)) pipeline.projects = action.projects;
   if (action.stopWhen) pipeline.stopWhen = action.stopWhen;
   if (Array.isArray(action.monitoredResources) && action.monitoredResources.length > 0) {
     pipeline.monitoredResources = action.monitoredResources;
@@ -2713,6 +2856,10 @@ function pipelineDefinitionsEqual(a, b) {
 function createPipelineFromAction(action) {
   const { savePipeline, getPipeline } = require('./engine/pipeline');
   const pipeline = buildPipelineFromAction(action);
+  const projectError = validatePipelineProjects(pipeline);
+  if (projectError) {
+    return { type: 'create-pipeline', id: pipeline.id, error: projectError };
+  }
   const existing = getPipeline(pipeline.id);
   if (existing) {
     if (pipelineDefinitionsEqual(existing, pipeline)) {
@@ -3078,7 +3225,9 @@ async function _ccExecuteLocalApiAction(action) {
 
 async function executeCCActions(actions, { source = 'command-center', inferredProject = null } = {}) {
   const results = [];
-  for (const rawAction of actions) {
+  const dispatchIdsCreatedInThisCall = new Map();
+  for (let actionIndex = 0; actionIndex < actions.length; actionIndex++) {
+    const rawAction = actions[actionIndex];
     const action = normalizeCCAction(rawAction);
     if (action?._intentFallbackError) {
       results.push({
@@ -3178,9 +3327,19 @@ async function executeCCActions(actions, { source = 'command-center', inferredPr
           const createResult = createWorkItemWithDedup(wiPath, item);
           if (!createResult.created) {
             const duplicateId = createResult.duplicateOf || createResult.item?.id;
+            if (duplicateId && dispatchIdsCreatedInThisCall.has(duplicateId)) {
+              results.push({
+                type: action.type,
+                id: duplicateId,
+                ok: true,
+                reusedFromAction: dispatchIdsCreatedInThisCall.get(duplicateId),
+              });
+              break;
+            }
             results.push({ type: action.type, id: duplicateId, ok: true, duplicate: true, duplicateOf: duplicateId });
             break;
           }
+          dispatchIdsCreatedInThisCall.set(id, actionIndex);
           results.push({ type: action.type, id, ok: true });
 
           // Pre-flight routing check: warn the user if no agent is currently available so the new
@@ -3404,6 +3563,7 @@ function _buildDocChatActionFeedback(actions, actionResults) {
       feedback.push({ type, error: String(result.error) });
       continue;
     }
+    if (result.reusedFromAction !== undefined) continue;
     const id = result.id || result.duplicateOf;
     if (!result.ok || !id) continue;
     const item = { type, id: String(id), ok: true };
@@ -5035,21 +5195,12 @@ const server = http.createServer(async (req, res) => {
     try {
       const body = await readBody(req);
       if (!body.title || !body.title.trim()) return jsonReply(res, 400, { error: 'title is required' });
-      const target = resolveWorkItemsCreateTarget(body.project);
-      if (target.error) return jsonReply(res, 400, { error: target.error });
+      const planWorkItem = buildPlanWorkItem(body);
+      if (planWorkItem.error) return jsonReply(res, 400, { error: planWorkItem.error });
       // Write as a work item with type 'plan' — user must explicitly execute plan-to-prd after reviewing
       const wiPath = path.join(MINIONS_DIR, 'work-items.json');
-      const id = 'W-' + shared.uid();
-      const item = {
-        id, title: body.title, type: 'plan',
-        priority: body.priority || 'high', description: body.description || '',
-        status: WI_STATUS.PENDING, created: new Date().toISOString(), createdBy: 'dashboard',
-        branchStrategy: body.branch_strategy || body.branchStrategy || 'parallel',
-      };
-      if (target.project) item.project = target.project.name;
-      if (body.agent) item.agent = body.agent;
-      mutateWorkItems(wiPath, items => { items.push(item); });
-      return jsonReply(res, 200, { ok: true, id, agent: body.agent || '' });
+      mutateWorkItems(wiPath, items => { items.push(planWorkItem.item); });
+      return jsonReply(res, 200, { ok: true, id: planWorkItem.id, agent: body.agent || '' });
     } catch (e) { return jsonReply(res, 400, { error: e.message }); }
   }
 
@@ -5057,31 +5208,14 @@ const server = http.createServer(async (req, res) => {
     try {
       const body = await readBody(req);
       if (!body.name || !body.name.trim()) return jsonReply(res, 400, { error: 'name is required' });
-      const target = resolveWorkItemsCreateTarget(body.project);
-      if (target.error) return jsonReply(res, 400, { error: target.error });
+      const manualPrd = buildManualPrdItemPlan(body);
+      if (manualPrd.error) return jsonReply(res, 400, { error: manualPrd.error });
 
       if (!fs.existsSync(PRD_DIR)) fs.mkdirSync(PRD_DIR, { recursive: true });
 
-      const id = body.id || ('M' + String(Date.now()).slice(-4));
       const planFile = 'manual-' + shared.uid() + '.json';
-      const plan = {
-        version: 'manual-' + new Date().toISOString().slice(0, 10),
-        project: target.project?.name || 'Unknown',
-        generated_by: 'dashboard',
-        generated_at: new Date().toISOString().slice(0, 10),
-        plan_summary: body.name,
-        status: 'approved',
-        requires_approval: false,
-        branch_strategy: 'parallel',
-        missing_features: [{
-          id, name: body.name, description: body.description || '',
-          priority: body.priority || 'medium', estimated_complexity: body.estimated_complexity || 'medium',
-          status: 'missing', depends_on: [], acceptance_criteria: [],
-        }],
-        open_questions: [],
-      };
-      safeWrite(path.join(PRD_DIR, planFile), plan);
-      return jsonReply(res, 200, { ok: true, id, file: planFile });
+      safeWrite(path.join(PRD_DIR, planFile), manualPrd.plan);
+      return jsonReply(res, 200, { ok: true, id: manualPrd.id, file: planFile });
     } catch (e) { return jsonReply(res, 400, { error: e.message }); }
   }
 
@@ -7414,9 +7548,10 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     const body = await readBody(req);
     let { id, cron, title, type, project, agent, description, priority, enabled } = body;
     if (!cron || !title) return jsonReply(res, 400, { error: 'cron and title are required' });
-    const projectTarget = shared.resolveConfiguredProject(project, PROJECTS);
+    reloadConfig();
+    const projectTarget = resolveScheduleProjectValue(project, PROJECTS);
     if (projectTarget.error) return jsonReply(res, 400, { error: projectTarget.error });
-    project = projectTarget.project?.name || null;
+    project = projectTarget.project || null;
 
     // Auto-generate ID from title if not provided
     if (!id) {
@@ -7451,10 +7586,11 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     const body = await readBody(req);
     let { id, cron, title, type, project, agent, description, priority, enabled } = body;
     if (!id) return jsonReply(res, 400, { error: 'id required' });
+    reloadConfig();
     if (project !== undefined) {
-      const projectTarget = shared.resolveConfiguredProject(project, PROJECTS);
+      const projectTarget = resolveScheduleProjectValue(project, PROJECTS);
       if (projectTarget.error) return jsonReply(res, 400, { error: projectTarget.error });
-      project = projectTarget.project?.name || null;
+      project = projectTarget.project || null;
     }
 
     let missingSchedules = false;
@@ -7516,16 +7652,14 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     reloadConfig();
     const sched = (CONFIG.schedules || []).find(s => s.id === id);
     if (!sched) return jsonReply(res, 404, { error: 'Schedule not found' });
-    if (sched.project) {
-      const projectTarget = shared.resolveConfiguredProject(sched.project, PROJECTS);
-      if (projectTarget.error) return jsonReply(res, 400, { error: projectTarget.error });
-      sched.project = projectTarget.project.name;
-    }
+    const projectTarget = resolveScheduleProjectValue(sched.project, PROJECTS);
+    if (projectTarget.error) return jsonReply(res, 400, { error: projectTarget.error });
+    const schedForRun = { ...sched, project: projectTarget.project || null };
 
     const schedulerMod = require('./engine/scheduler');
     let item;
     try {
-      item = schedulerMod.createScheduledWorkItem(sched);
+      item = schedulerMod.createScheduledWorkItem(schedForRun);
     } catch (e) {
       return jsonReply(res, 400, { error: e.message });
     }
@@ -7536,7 +7670,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       meeting = createMeeting({
         title: item.title,
         agenda: item.description,
-        participants: Array.isArray(sched.participants) ? sched.participants : [],
+        participants: Array.isArray(schedForRun.participants) ? schedForRun.participants : [],
       });
     } else {
       const centralPath = path.join(MINIONS_DIR, 'work-items.json');
@@ -7555,22 +7689,22 @@ What would you like to discuss or change? When you're happy, say "approve" and I
         return jsonReply(res, 409, {
           error: 'Schedule already has an active work item',
           id: duplicate.id,
-          scheduleId: sched.id,
+          scheduleId: schedForRun.id,
         });
       }
     }
 
-    const runEntry = schedulerMod.recordScheduleRun(sched.id, item.id);
+    const runEntry = schedulerMod.recordScheduleRun(schedForRun.id, item.id);
     try {
       shared.mutateControl(control => ({ ...control, _wakeupAt: Date.now() }));
     } catch (e) {
-      shared.log('warn', `Schedule run-now wakeup failed for ${sched.id}: ${e.message}`);
+      shared.log('warn', `Schedule run-now wakeup failed for ${schedForRun.id}: ${e.message}`);
     }
     invalidateStatusCache();
     return jsonReply(res, 200, {
       ok: true,
       id: item.id,
-      scheduleId: sched.id,
+      scheduleId: schedForRun.id,
       lastRun: runEntry?.lastRun || null,
       ...(meeting ? { meetingId: meeting.id } : {}),
     });
@@ -8356,7 +8490,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     { method: 'GET', path: /^\/api\/plans\/([^?]+)$/, template: '/api/plans/:file', desc: 'Read a full plan (JSON from prd/ or markdown from plans/)', handler: handlePlansRead },
 
     // PRD items
-    { method: 'POST', path: '/api/prd-items', desc: 'Create a PRD item as a plan file in prd/ (auto-approved)', params: 'name, description?, priority?, estimated_complexity?, project?, id?', handler: handlePrdItemsCreate },
+    { method: 'POST', path: '/api/prd-items', desc: 'Create a PRD item as a plan file in prd/ (auto-approved)', params: 'name, description?, priority?, estimated_complexity?, project?, item_project?, id?', handler: handlePrdItemsCreate },
     { method: 'POST', path: '/api/prd-items/update', desc: 'Edit a PRD item in its source plan JSON', params: 'source, itemId, name?, description?, priority?, estimated_complexity?, status?', handler: handlePrdItemsUpdate },
     { method: 'POST', path: '/api/prd-items/remove', desc: 'Remove a PRD item from plan + cancel materialized work item', params: 'source, itemId', handler: handlePrdItemsRemove },
     // /api/prd/regenerate removed — use /api/plans/approve which does diff-aware update
@@ -8390,9 +8524,17 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       } catch (e) {
         return jsonReply(res, e.statusCode || 400, { error: e.message }, req);
       }
-      const { id: prId, prPath, prNum, created, linked } = linkResult;
+      const { id: prId, prPath, prNum, created, linked, targetProject, projectResolution } = linkResult;
       invalidateStatusCache();
-      jsonReply(res, 200, { ok: true, id: prId, created, linked });
+      jsonReply(res, 200, {
+        ok: true,
+        id: prId,
+        created,
+        linked,
+        project: targetProject?.name || 'central',
+        projectResolution,
+        message: projectResolution?.message || 'PR linked.',
+      });
 
       // Async-enrich: fetch title, description, branch, author from GitHub/ADO API
       (async () => {
@@ -9012,6 +9154,9 @@ module.exports = {
   _findDuplicateWorkItemCreate: findDuplicateWorkItemCreate,
   _createWorkItemWithDedup: createWorkItemWithDedup,
   _resolveWorkItemsCreateTarget: resolveWorkItemsCreateTarget,
+  _buildPlanWorkItem: buildPlanWorkItem,
+  _buildManualPrdItemPlan: buildManualPrdItemPlan,
+  _resolveScheduleProjectValue: resolveScheduleProjectValue,
   _collectArchivedWorkItems: collectArchivedWorkItems,
   _createPipelineFromAction: createPipelineFromAction,
   _setCcLocalApiInvokerForTest,

package/engine/copilot-models.json

@@ -1,5 +1,5 @@
 {
   "runtime": "copilot",
   "models": null,
-  "cachedAt": "2026-05-09T08:23:02.798Z"
+  "cachedAt": "2026-05-09T09:32:10.535Z"
 }

package/engine/issues.js

@@ -9,6 +9,7 @@ const shared = require('./shared');
 
 const DEFAULT_REPO = 'yemi33/minions';
 const DEFAULT_LABELS = ['bug'];
+const WRITABLE_REPO_PERMISSIONS = new Set(['WRITE', 'MAINTAIN', 'ADMIN']);
 
 class GitHubIssueError extends Error {
   constructor(message, statusCode = 500) {
@@ -67,16 +68,105 @@ function extractIssueUrl(output) {
   return match ? match[0] : null;
 }
 
-function runGh(execFileSync, args, timeout) {
-  return execFileSync('gh', args, {
+function runGh(execFileSync, args, timeout, { env } = {}) {
+  const opts = {
     encoding: 'utf8',
     timeout,
     windowsHide: true,
-  });
+  };
+  if (env) opts.env = { ...process.env, ...env };
+  return execFileSync('gh', args, opts);
+}
+
+function isWritableRepoPermission(permission) {
+  return WRITABLE_REPO_PERMISSIONS.has(String(permission || '').trim().toUpperCase());
+}
+
+function repoViewerPermission({ repo, execFileSync, ghEnv }) {
+  const output = runGh(execFileSync, ['repo', 'view', repo, '--json', 'viewerPermission'], 10000, { env: ghEnv });
+  const parsed = JSON.parse(output || '{}');
+  return String(parsed.viewerPermission || '').trim().toUpperCase();
+}
+
+function parseGhAuthUsers(output) {
+  const users = [];
+  const seen = new Set();
+  for (const line of String(output || '').split(/\r?\n/)) {
+    const match = line.match(/\baccount\s+([^\s()]+)/i) || line.match(/\bas\s+([^\s()]+)/i);
+    if (!match) continue;
+    const user = match[1].trim();
+    const key = user.toLowerCase();
+    if (!user || seen.has(key)) continue;
+    seen.add(key);
+    users.push(user);
+  }
+  return users;
+}
+
+function listAuthenticatedGhUsers({ execFileSync }) {
+  const output = runGh(execFileSync, ['auth', 'status', '--hostname', 'github.com'], 10000);
+  return parseGhAuthUsers(output);
+}
+
+function ghTokenForUser({ user, execFileSync }) {
+  return String(runGh(execFileSync, ['auth', 'token', '--hostname', 'github.com', '--user', user], 10000) || '').trim();
+}
+
+function resolveWritableGitHubEnv({ repo, execFileSync }) {
+  let activePermission = '';
+  let activeError = null;
+  try {
+    activePermission = repoViewerPermission({ repo, execFileSync });
+    if (isWritableRepoPermission(activePermission)) return undefined;
+  } catch (e) {
+    activeError = e;
+  }
+
+  let users = [];
+  let accountListError = null;
+  try {
+    users = listAuthenticatedGhUsers({ execFileSync });
+  } catch (e) {
+    if (activeError && isAuthError(activeError) && isAuthError(e)) {
+      throw new GitHubIssueError('GitHub auth required. Run: gh auth login', 401);
+    }
+    accountListError = e;
+  }
+
+  const candidateErrors = [];
+  for (const user of users) {
+    try {
+      const token = ghTokenForUser({ user, execFileSync });
+      if (!token) continue;
+      const ghEnv = { GH_TOKEN: token };
+      const permission = repoViewerPermission({ repo, execFileSync, ghEnv });
+      if (isWritableRepoPermission(permission)) return ghEnv;
+    } catch (e) {
+      candidateErrors.push(`${user}: ${conciseGhMessage(e)}`);
+    }
+  }
+
+  const activeDetail = activePermission
+    ? ` Active account permission is ${activePermission}.`
+    : activeError
+      ? ` Active account permission could not be checked: ${conciseGhMessage(activeError)}.`
+      : '';
+  const authStatusDetail = accountListError
+    ? ` Authenticated accounts could not be listed: ${conciseGhMessage(accountListError)}.`
+    : '';
+  const candidateDetail = candidateErrors.length
+    ? ` Checked ${candidateErrors.length} authenticated account(s) without finding write access.`
+    : '';
+  throw new GitHubIssueError(
+    `No authenticated GitHub account with write access to ${repo}.${activeDetail} ` +
+      `${authStatusDetail}${candidateDetail} ` +
+      `Run: gh auth login --hostname github.com with a profile that can write to ${repo}, or set GH_TOKEN for that account.`,
+    403
+  );
 }
 
-function listRepoLabels({ repo, execFileSync }) {
-  const output = runGh(execFileSync, ['label', 'list', '--repo', repo, '--json', 'name', '--limit', '1000'], 15000);
+function listRepoLabels({ repo, execFileSync, ghEnv }) {
+  const output = runGh(execFileSync, ['label', 'list', '--repo', repo, '--json', 'name', '--limit', '1000'], 15000, { env: ghEnv });
   const parsed = JSON.parse(output || '[]');
   if (!Array.isArray(parsed)) {
     throw new GitHubIssueError('GitHub label list returned an unexpected response shape');
@@ -89,14 +179,14 @@ function listRepoLabels({ repo, execFileSync }) {
   return labelsByLower;
 }
 
-function resolveLabels({ labels, repo, execFileSync }) {
+function resolveLabels({ labels, repo, execFileSync, ghEnv }) {
   const requested = normalizeLabels(labels);
   if (requested.length === 0) {
     return { requested, labelsToApply: [], labelsSkipped: [], validationUnavailable: false };
   }
 
   try {
-    const available = listRepoLabels({ repo, execFileSync });
+    const available = listRepoLabels({ repo, execFileSync, ghEnv });
     const labelsToApply = [];
     const labelsSkipped = [];
     for (const label of requested) {
@@ -175,10 +265,10 @@ function _redactIssueContent(value, { repo, projects } = {}) {
   });
 }
 
-function createIssueWithLabels({ title, bodyFile, repo, labels, execFileSync }) {
+function createIssueWithLabels({ title, bodyFile, repo, labels, execFileSync, ghEnv }) {
   const args = ['issue', 'create', '--repo', repo, '--title', title, '--body-file', bodyFile];
   if (labels.length > 0) args.push('--label', labels.join(','));
-  const output = runGh(execFileSync, args, 30000);
+  const output = runGh(execFileSync, args, 30000, { env: ghEnv });
   const url = extractIssueUrl(output);
   if (!url) {
     throw new GitHubIssueError(`Issue may not have been created: ${conciseGhMessage(output)}`);
@@ -202,6 +292,7 @@ function createGitHubIssue({
   } catch (e) {
     throw new GitHubIssueError('gh CLI not found. Install from https://cli.github.com/');
   }
+  const ghEnv = resolveWritableGitHubEnv({ repo, execFileSync });
 
   const redactionProjects = projects || shared.getProjects();
   const safeTitle = _redactIssueContent(title, { repo, projects: redactionProjects });
@@ -214,13 +305,14 @@ function createGitHubIssue({
 
   let resolved;
   try {
-    resolved = resolveLabels({ labels, repo, execFileSync });
+    resolved = resolveLabels({ labels, repo, execFileSync, ghEnv });
     const created = createIssueWithLabels({
       title: safeTitle,
       bodyFile,
       repo,
       labels: resolved.labelsToApply,
       execFileSync,
+      ghEnv,
     });
     const filedWithoutLabels = resolved.requested.length > 0 && resolved.labelsToApply.length === 0;
     return {
@@ -237,7 +329,7 @@ function createGitHubIssue({
     if (isAuthError(e)) throw new GitHubIssueError('GitHub auth required. Run: gh auth login', 401);
     if (resolved && resolved.labelsToApply.length > 0 && isLabelUnavailableError(e)) {
       try {
-        const created = createIssueWithLabels({ title: safeTitle, bodyFile, repo, labels: [], execFileSync });
+        const created = createIssueWithLabels({ title: safeTitle, bodyFile, repo, labels: [], execFileSync, ghEnv });
         const skipped = normalizeLabels([...resolved.labelsSkipped, ...resolved.labelsToApply], []);
         return {
           ok: true,

package/engine/pipeline.js

@@ -205,19 +205,26 @@ function _pipelineProjectValues(...values) {
   for (const value of values) {
     if (value === undefined) continue;
     if (Array.isArray(value)) out.push(...value);
+    else if (value && typeof value === 'object' && value.project !== undefined) out.push(value.project);
+    else if (value && typeof value === 'object' && value._project !== undefined) out.push(value._project);
     else out.push(value);
   }
   return out;
 }
 
-function _resolvePipelineProjects(values, config) {
+function _pipelineProjectValuePresent(value) {
+  if (value === undefined) return false;
+  if (value === null) return true;
+  if (typeof value === 'string') return value.trim() !== '';
+  return true;
+}
+
+function _resolvePipelineProjectValues(rawValues, 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 (!_pipelineProjectValuePresent(raw)) continue;
     if (raw === null || String(raw).trim().toLowerCase() === 'central') {
       if (!seen.has('central')) { seen.add('central'); resolved.push(null); }
       continue;
@@ -230,6 +237,16 @@ function _resolvePipelineProjects(values, config) {
   return { projects: resolved.length ? resolved : [null] };
 }
 
+function _resolvePipelineProjects(scopes, config) {
+  for (const scope of (Array.isArray(scopes) ? scopes : [scopes])) {
+    const values = _pipelineProjectValues(...(Array.isArray(scope) ? scope : [scope]))
+      .filter(_pipelineProjectValuePresent);
+    if (values.length === 0) continue;
+    return _resolvePipelineProjectValues(values, config);
+  }
+  return { projects: [null] };
+}
+
 function _pipelineProjectSlug(project) {
   return project ? shared.safeSlugComponent(project.name || 'project', 32).toLowerCase() : 'central';
 }
@@ -339,12 +356,9 @@ function executeTaskStage(stage, stageState, run, config, pipeline = {}) {
   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,
+      [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) {
@@ -376,7 +390,11 @@ function executeTaskStage(stage, stageState, run, config, pipeline = {}) {
       touchedProjects.push(project?.name || null);
     }
   }
-  return { status: PIPELINE_STATUS.RUNNING, artifacts: { workItems: [...new Set(createdIds)], projects: [...new Set(touchedProjects)] } };
+  const projects = [...new Set(touchedProjects)];
+  return {
+    status: PIPELINE_STATUS.RUNNING,
+    artifacts: { workItems: [...new Set(createdIds)], projects },
+  };
 }
 
 function executeTaskStageLegacy(stage, stageState, run, config) {
@@ -488,7 +506,10 @@ async function executePlanStage(stage, stageState, run, config, pipeline = {}) {
   if (!fs.existsSync(plansDir)) fs.mkdirSync(plansDir, { recursive: true });
 
   const slug = slugify(stage.title || 'pipeline-plan');
-  const projectResolution = _resolvePipelineProjects([stage.projects, stage.project, pipeline.projects, pipeline.project], config);
+  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) : ''}`;
@@ -1093,6 +1114,7 @@ module.exports = {
   getPipelineRuns, getActiveRun, startRun, updateRunStage, completeRun,
   discoverPipelineWork,
   evaluateCondition, // exported for testing
-  executeTaskStage, isStageComplete, resolveTemplate, // exported for testing
+  executeTaskStage, executePlanStage, isStageComplete, resolveTemplate, // exported for testing
+  _resolvePipelineProjects, // exported for testing
   _findMeetingsInRun, _findExistingPlanForMeeting, _findExistingPrdForPlan, // exported for testing
 };

package/engine/shared.js

@@ -2963,7 +2963,7 @@ function upsertPullRequestRecord(prPath, entry, { project = null, itemId = null,
           target[key] = normalizedEntry[key];
         }
       }
-      for (const key of ['_manual', '_autoObserve', '_context']) {
+      for (const key of ['_manual', '_autoObserve', '_context', '_projectResolution']) {
         if (normalizedEntry[key] != null) target[key] = normalizedEntry[key];
       }
       if (normalizedEntry._contextOnly != null) {

package/engine.js

@@ -592,7 +592,7 @@ async function spawnAgent(dispatchItem, config) {
   // Resolve prompt — prefers sidecar file when dispatchItem._promptFile is set
   // (large prompts are written to engine/contexts/<id>.md to keep dispatch.json
   // small — see shared.sidecarDispatchPrompt / #1167).
-  const taskPrompt = shared.resolveDispatchPrompt(dispatchItem);
+  let taskPrompt = shared.resolveDispatchPrompt(dispatchItem);
   const claudeConfig = config.claude || {};
   const engineConfig = config.engine || {};
   const startedAt = ts();
@@ -601,15 +601,16 @@ async function spawnAgent(dispatchItem, config) {
 
   // Resolve project context for this dispatch
   // meta.project has {name, localPath} — enrich with full config (mainBranch, repoHost, etc.)
-  const metaProject = meta?.project || {};
+  const metaProject = meta?.project;
   const projects = getProjects(config);
-  const fullProject = shared.findProjectByNameOrPath(projects, metaProject.name || metaProject.localPath);
-  if ((metaProject.name || metaProject.localPath) && !fullProject) {
-    const err = new Error(shared.formatUnknownProjectError(metaProject.name || metaProject.localPath, projects));
+  const projectResolution = shared.resolveConfiguredProject(metaProject, projects, { defaultWhenSingle: true });
+  if (projectResolution.error) {
+    const err = new Error(projectResolution.error);
     updateAgentStatus(id, AGENT_STATUS.FAILED, err.message);
     throw err;
   }
-  const project = fullProject ? { ...fullProject, ...metaProject } : (projects.length === 1 && !(metaProject.name || metaProject.localPath) ? projects[0] : {});
+  const metaProjectFields = metaProject && typeof metaProject === 'object' ? metaProject : {};
+  const project = projectResolution.project ? { ...projectResolution.project, ...metaProjectFields } : {};
   const rootDir = project.localPath ? path.resolve(project.localPath) : path.resolve(MINIONS_DIR, '..');
 
   // Determine working directory
@@ -621,8 +622,8 @@ async function spawnAgent(dispatchItem, config) {
   const _gitOpts = { stdio: 'pipe', timeout: 30000, windowsHide: true, env: shared.gitEnv() };
   const _worktreeGitOpts = { ..._gitOpts, timeout: worktreeCreateTimeout };
 
-  // Build prompt before worktree setup — prompt doesn't depend on worktree path
-  // and this avoids blocking 200ms of file reads behind 20-60s of git operations
+  // Build the initial prompt before worktree setup, then refresh shared-branch
+  // work-item prompts after setup because reused worktrees can live at arbitrary paths.
   const systemPrompt = buildSystemPrompt(agentId, config, project);
   const agentContext = buildAgentContext(agentId, config, project);
   const pendingSteering = steering.buildPendingSteeringPrompt(agentId);
@@ -642,15 +643,18 @@ async function spawnAgent(dispatchItem, config) {
     'This report is the primary completion signal; fenced completion blocks are only a fallback.',
     '',
   ].join('\n') : '';
-  const taskPromptWithSteering = pendingSteering.prompt
-    ? `${pendingSteering.prompt}\n\n---\n\n${taskPrompt}`
-    : taskPrompt;
-  const taskPromptWithReport = completionReportInstruction
-    ? `${taskPromptWithSteering}\n\n---\n\n${completionReportInstruction}`
-    : taskPromptWithSteering;
-  const fullTaskPrompt = agentContext
-    ? `## Agent Context\n\n${agentContext}\n---\n\n## Your Task\n\n${taskPromptWithReport}`
-    : taskPromptWithReport;
+  const buildFullTaskPrompt = (promptBody) => {
+    const taskPromptWithSteering = pendingSteering.prompt
+      ? `${pendingSteering.prompt}\n\n---\n\n${promptBody}`
+      : promptBody;
+    const taskPromptWithReport = completionReportInstruction
+      ? `${taskPromptWithSteering}\n\n---\n\n${completionReportInstruction}`
+      : taskPromptWithSteering;
+    return agentContext
+      ? `## Agent Context\n\n${agentContext}\n---\n\n## Your Task\n\n${taskPromptWithReport}`
+      : taskPromptWithReport;
+  };
+  let fullTaskPrompt = buildFullTaskPrompt(taskPrompt);
   const tmpDir = path.join(ENGINE_DIR, 'tmp');
   if (!fs.existsSync(tmpDir)) fs.mkdirSync(tmpDir, { recursive: true });
   const safeId = id.replace(/[:\\/*?"<>|]/g, '-');
@@ -1064,6 +1068,25 @@ async function spawnAgent(dispatchItem, config) {
 
   updateAgentStatus(id, AGENT_STATUS.READY, 'Worktree ready, preparing to spawn process');
 
+  if (worktreePath && meta?.source === 'work-item' && meta?.item?.branchStrategy === 'shared-branch') {
+    const refreshed = renderProjectWorkItemPromptForAgent(
+      meta.item,
+      routing.normalizeWorkType(type, WORK_TYPE.IMPLEMENT),
+      agentId,
+      config,
+      project,
+      rootDir,
+      branchName,
+      { worktreePath }
+    );
+    if (refreshed.prompt) {
+      taskPrompt = refreshed.prompt;
+      fullTaskPrompt = buildFullTaskPrompt(taskPrompt);
+      safeWrite(promptPath, fullTaskPrompt);
+      log('info', `Refreshed shared-branch prompt for ${id} with worktree ${worktreePath}`);
+    }
+  }
+
   // Inject dirty file list when worktree has uncommitted changes (e.g., max_turns retry)
   // This signals to the respawned agent that prior work exists in the worktree (#960)
   if (worktreePath && fs.existsSync(worktreePath)) {
@@ -1714,7 +1737,7 @@ async function spawnAgent(dispatchItem, config) {
     }
   }, 5000);
 
-  // Move pending -> active under a lock to avoid cross-process lost updates (engine/dashboard)
+  // Move pending -> active under lock to avoid lost updates.
   mutateDispatch((dispatch) => {
     const idx = dispatch.pending.findIndex(d => d.id === id);
     if (idx < 0) return dispatch;
@@ -1736,9 +1759,7 @@ async function spawnAgent(dispatchItem, config) {
   // reads dispatchItem.started_at for runtimeMs. (W-moux9nwn0008f923)
   dispatchItem.started_at = startedAt;
 
-  // Atomically stamp dispatched_to/dispatched_at on the originating work item (#402)
-  // The discover phase sets these via safeWrite which can race with concurrent writes;
-  // this locked write ensures the fields are persisted reliably.
+  // Atomically stamp dispatched_to/dispatched_at on the originating work item (#402).
   if (meta?.item?.id) {
     try {
       let wiPath = null;
@@ -3072,7 +3093,8 @@ async function discoverFromPrs(config, project) {
 /**
  * Scan work-items.json for manually queued tasks
  */
-function renderProjectWorkItemPromptForAgent(item, workType, agentId, config, project, root, branchName) {
+function renderProjectWorkItemPromptForAgent(item, workType, agentId, config, project, root, branchName, options = {}) {
+  const worktreePath = options.worktreePath || path.resolve(root, config.engine?.worktreeRoot || '../worktrees', `${branchName}`);
   const vars = {
     ...buildBaseVars(agentId, config, project),
     item_id: item.id,
@@ -3089,7 +3111,7 @@ function renderProjectWorkItemPromptForAgent(item, workType, agentId, config, pr
     scope_section: `## Scope: Project — ${project?.name || 'default'}\n\nThis task is scoped to a single project.`,
     branch_name: branchName,
     project_path: root,
-    worktree_path: path.resolve(root, config.engine?.worktreeRoot || '../worktrees', `${branchName}`),
+    worktree_path: worktreePath,
     commit_message: item.commitMessage || `feat: ${item.title || item.id}`,
     notes_content: '',
     pr_id: item.pr_id || item._pr || item.targetPr || item.sourcePr || item.pr || '',
@@ -3740,12 +3762,9 @@ function discoverCentralWorkItems(config) {
 
     const workType = routing.normalizeWorkType(item.type, WORK_TYPE.IMPLEMENT);
     const isFanOut = item.scope === 'fan-out';
-    const explicitItemProject = typeof item.project === 'string' ? item.project : (item.project?.name || item.project?.localPath);
-    const explicitProjectTarget = explicitItemProject
-      ? shared.resolveProjectSource(explicitItemProject, dispatchProjects, { allowCentral: false })
-      : null;
-    if (explicitProjectTarget?.error) {
-      const error = explicitProjectTarget.error;
+    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() });
       log('warn', `central work item ${item.id}: ${error}`);
       continue;
@@ -3849,13 +3868,11 @@ function discoverCentralWorkItems(config) {
           planReadError = e;
         }
       }
-      const requestedProjectName = declaredPlanProject || explicitItemProject;
-      const requestedTarget = requestedProjectName
-        ? shared.resolveProjectSource(requestedProjectName, dispatchProjects, { allowCentral: false })
-        : null;
-      const requestedProject = requestedTarget?.project || null;
-      if (requestedTarget?.error) {
-        const error = requestedTarget.error;
+      const requestedProjectResolution = declaredPlanProject
+        ? shared.resolveConfiguredProject(declaredPlanProject, projects)
+        : itemProjectResolution;
+      if (requestedProjectResolution.error) {
+        const error = requestedProjectResolution.error;
         mutations.set(item.id, {
           status: WI_STATUS.FAILED,
           failReason: error,
@@ -3865,7 +3882,7 @@ function discoverCentralWorkItems(config) {
         log('warn', `central work item ${item.id}: ${error}`);
         continue;
       }
-      const targetProject = requestedProject || (dispatchProjects.length === 1 ? dispatchProjects[0] : null);
+      const targetProject = requestedProjectResolution.project || (projects.length === 1 ? projects[0] : null);
       if (declaredPlanProject) {
         const projectMutation = { project: targetProject.name, _declaredPlanProject: declaredPlanProject };
         mutations.set(item.id, Object.assign(mutations.get(item.id) || {}, projectMutation));
@@ -4916,6 +4933,7 @@ module.exports = {
 
   // Playbooks
   renderPlaybook, validatePlaybookVars, PLAYBOOK_REQUIRED_VARS, buildWorkItemDispatchVars,
+  renderProjectWorkItemPromptForAgent, // exported for testing
 
   // Timeout / Steering / Idle (re-exported from engine/timeout.js)
   checkTimeouts, checkSteering, checkIdleThreshold,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.1811",
+  "version": "0.1.1813",
   "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/doc-chat-system.md

@@ -18,6 +18,18 @@ Before answering, classify the human's chat message:
 
 Do not emit `===ACTIONS===` or fenced `action` JSON for normal small document questions, summaries, rewrites, extraction, or localized edits. If a small task becomes medium/large after inspection, stop and dispatch a work item rather than pushing through in doc-chat.
 
+## Explicit Dispatch/Delegation Hard Stop
+
+Explicit dispatch/delegation intent hard stop: when the human's chat message asks to `dispatch`, `delegate`, `assign`, `have Minions...`, `open work items for...`, `queue fixes for...`, or otherwise asks another agent/minion/work item to do the work, you MUST emit `===ACTIONS===` with dispatch JSON when the required fields are available, and you MUST NOT use `Write`, `Edit`, or `Bash` against any file. If a required dispatch field is genuinely unknown, ask for that missing field in plain text; do not edit files or run Bash while waiting for clarification.
+
+This rule takes precedence over all document-editing paths below. Do not "helpfully" start implementing, fixing, or testing inline after acknowledging a dispatch/delegation request. The document may mention source files, contain findings, or list exact edits to make; those references are inputs for the dispatched work item's description, not permission to edit those files in doc-chat.
+
+Negative example A: if a findings or audit document is open and the human says "dispatch fixes for every issue", the correct response is one or more dispatch actions. Do not use `Edit`, `Write`, or `Bash` on source files referenced by the document, such as `engine.js`, `engine/pipeline.js`, or `test/unit.test.js`, even if the findings make the fix look obvious.
+
+Negative example B: if the human says "go fix these items", "implement this list", "have minions tackle these", or similar delegation phrasing, the correct response is dispatch action JSON. Do not edit the referenced implementation files directly from doc-chat.
+
+ANY `Edit` or `Write` call targeting a path other than the document-context `filePath` is forbidden, regardless of how compelling, urgent, or specific the human request sounds. If the requested work spans any file other than the current document filePath, dispatch it instead of editing it.
+
 ## Minions Orchestration Requests
 
 For explicit dispatch/delegation requests or medium/larger work without a direct-handling override, emit the same Command Center work-item action shape:
@@ -48,6 +60,6 @@ For wholesale rewrites, format conversions, or changes touching most of the file
 
 ### Rules for both paths
 
-- Never edit any file other than the one named in the document context.
+- Never edit any file other than the one named in the document context. `Edit`/`Write` against any other path is forbidden; if the work needs other files, dispatch it.
 - If the user is asking a question rather than requesting an edit, do not edit. Answer in plain text.
 - If a JSON file's edit would invalidate it, prefer the whole-file rewrite path so the server can validate the result before persisting.