@yemi33/minions 0.1.1809 → 0.1.1811

package/dashboard.js

@@ -130,8 +130,8 @@ function mergeSettingsConfigUpdate(current, candidate, body, patch = {}) {
   if (body.projects && Array.isArray(body.projects)) {
     if (!Array.isArray(current.projects)) current.projects = [];
     for (const update of body.projects) {
-      const candidateProject = (candidate.projects || []).find(p => p.name === update.name);
-      const currentProject = current.projects.find(p => p.name === update.name);
+      const candidateProject = shared.findProjectByName(candidate.projects || [], update.name);
+      const currentProject = shared.findProjectByName(current.projects, update.name);
       if (!candidateProject || !currentProject) continue;
       currentProject.workSources = candidateProject.workSources;
     }
@@ -259,12 +259,11 @@ function normalizeWorkItemDedupTitle(value) {
 function resolveWorkItemDedupProject(item, wiPath = '') {
   const projectName = normalizeWorkItemDedupText(item?.project || item?._project || item?._source);
   if (projectName) {
-    const namedProject = PROJECTS.find(p => p?.name === projectName);
-    if (namedProject) return namedProject;
+    const namedProject = shared.resolveProjectSource(projectName, PROJECTS, { allowCentral: false });
+    if (namedProject.project) return namedProject.project;
   }
   if (!wiPath) return null;
-  const resolvedWiPath = path.resolve(wiPath);
-  return PROJECTS.find(p => path.resolve(shared.projectWorkItemsPath(p)) === resolvedWiPath) || null;
+  return shared.resolveProjectSource(wiPath, PROJECTS, { allowCentral: false }).project || null;
 }
 
 function getWorkItemPrRefCandidates(item) {
@@ -369,29 +368,86 @@ function createWorkItemWithDedup(wiPath, item, options = {}) {
 }
 
 function formatUnknownProjectError(projectName, projects = []) {
-  const known = projects.map(p => p.name).filter(Boolean).join(', ') || '(none configured)';
-  return `Project "${projectName}" not found. Known projects: ${known}`;
+  return shared.formatUnknownProjectError(projectName, projects);
 }
 
 function findProjectByName(projects, projectName) {
-  const name = String(projectName || '').trim().toLowerCase();
-  if (!name) return null;
-  return projects.find(p => p.name?.toLowerCase() === name) || null;
+  return shared.findProjectByName(projects, projectName);
 }
 
 function resolveWorkItemsCreateTarget(projectName, projects = PROJECTS) {
-  const project = String(projectName || '').trim();
-  let targetProject = null;
-  if (project) {
-    targetProject = findProjectByName(projects, project);
-    if (!targetProject) return { error: formatUnknownProjectError(project, projects) };
-  } else if (projects.length === 1) {
-    targetProject = projects[0];
+  const target = shared.resolveProjectSource(projectName, projects, { defaultWhenSingle: true, minionsDir: MINIONS_DIR });
+  if (target.error) return { error: target.error };
+  return target;
+}
+
+function resolveProjectSourceTarget(source, projects = PROJECTS, options = {}) {
+  return shared.resolveProjectSource(source, projects, { minionsDir: MINIONS_DIR, ...options });
+}
+
+function dispatchPrefixForResolvedSource(target) {
+  return target?.project ? `work-${target.project.name}-` : 'central-work-';
+}
+
+function findWorkItemsTargetById(id, source, projects = PROJECTS) {
+  const explicitSource = source !== undefined && source !== null && String(source).trim() !== '';
+  if (explicitSource) {
+    const target = resolveProjectSourceTarget(source, projects);
+    if (target.error) return { error: target.error };
+    const items = shared.safeJson(target.wiPath) || [];
+    return { ...target, found: items.some(i => i.id === id) };
   }
-  return {
-    project: targetProject,
-    wiPath: targetProject ? shared.projectWorkItemsPath(targetProject) : path.join(MINIONS_DIR, 'work-items.json'),
+
+  const central = resolveProjectSourceTarget('central', projects);
+  const centralItems = shared.safeJson(central.wiPath) || [];
+  if (centralItems.some(i => i.id === id)) return { ...central, found: true };
+  for (const project of projects) {
+    const target = resolveProjectSourceTarget(project.name, projects);
+    const items = shared.safeJson(target.wiPath) || [];
+    if (items.some(i => i.id === id)) return { ...target, found: true };
+  }
+  return { found: false };
+}
+
+function validatePipelineProjects(pipeline, projects = PROJECTS) {
+  const refs = [];
+  const collect = (value) => {
+    if (value === undefined || value === null || value === '') return;
+    if (Array.isArray(value)) { value.forEach(collect); return; }
+    if (typeof value === 'object') {
+      if (value.project !== undefined) collect(value.project);
+      else if (value._project !== undefined) collect(value._project);
+      else if (value.name !== undefined) collect(value.name);
+      return;
+    }
+    refs.push(String(value));
+  };
+  const collectResourceProjects = (resources) => {
+    for (const resource of Array.isArray(resources) ? resources : []) {
+      if (resource && typeof resource === 'object') {
+        if (resource.project !== undefined) collect(resource.project);
+        if (resource._project !== undefined) collect(resource._project);
+      }
+    }
   };
+  collect(pipeline.project);
+  collect(pipeline.projects);
+  collectResourceProjects(pipeline.monitoredResources);
+  for (const stage of pipeline.stages || []) {
+    collect(stage.project);
+    collect(stage.projects);
+    collectResourceProjects(stage.monitoredResources);
+    for (const item of stage.items || []) {
+      collect(item.project);
+      collect(item.projects);
+    }
+  }
+  for (const ref of refs) {
+    if (ref.trim().toLowerCase() === 'central') continue;
+    const result = shared.resolveConfiguredProject(ref, projects);
+    if (result.error) return result.error;
+  }
+  return null;
 }
 
 /**
@@ -425,13 +481,21 @@ function linkPullRequestForTracking({ url, title, project: projectName, autoObse
   }
   const projects = shared.getProjects(config);
   const explicitProjectName = String(projectName || '').trim();
-  const targetProject = explicitProjectName ? findProjectByName(projects, explicitProjectName) : (projects[0] || null);
-  if (explicitProjectName && !targetProject) {
-    const err = new Error(formatUnknownProjectError(explicitProjectName, projects));
+  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;
   }
-  const prPath = targetProject ? shared.projectPrPath(targetProject) : path.join(MINIONS_DIR, 'pull-requests.json');
+  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 prPath = targetProject ? shared.projectPrPath(targetProject) : shared.centralPullRequestsPath(MINIONS_DIR);
 
   const prNumMatch = url.match(/\/pull\/(\d+)|pullrequest\/(\d+)/);
   const prNum = prNumMatch ? (prNumMatch[1] || prNumMatch[2]) : Date.now().toString().slice(-6);
@@ -1814,8 +1878,8 @@ function _extractActionsJson(segment) {
   return null;
 }
 
-const CC_DISPATCH_ACTION_ALIASES = new Set(['fix', 'explore', 'review', 'test']);
-const CC_ACTION_INTENT_WORK_TYPES = new Set(['fix', 'implement', 'explore', 'review', 'test']);
+const CC_DISPATCH_ACTION_ALIASES = new Set(['fix', 'explore', 'review', 'test', 'implement', 'implement:large', 'ask', 'verify']);
+const CC_ACTION_INTENT_WORK_TYPES = new Set(['fix', 'implement', 'implement:large', 'explore', 'review', 'test', 'ask', 'verify']);
 
 function normalizeCCAction(action) {
   if (!action || typeof action !== 'object') return action;
@@ -1830,7 +1894,19 @@ function normalizeCCAction(action) {
 
 function _ccCleanIntentString(value, max = 500) {
   if (typeof value !== 'string') return '';
-  return value.replace(/[\0\r\n]+/g, ' ').replace(/\s+/g, ' ').trim().slice(0, max);
+  let out = '';
+  let lastWasSpace = true;
+  for (const ch of value) {
+    const isSpace = ch === '\0' || ch === ' ' || ch === '\n' || ch === '\r' || ch === '\t';
+    if (isSpace) {
+      if (!lastWasSpace) out += ' ';
+      lastWasSpace = true;
+    } else {
+      out += ch;
+      lastWasSpace = false;
+    }
+  }
+  return out.trim().slice(0, max);
 }
 
 function _ccNormalizeIntentMetadata(meta) {
@@ -1851,36 +1927,25 @@ function _ccNormalizeIntentMetadata(meta) {
 }
 
 function _messageExplicitlyRequestsMinionsOrchestration(message) {
-  const text = String(message || '').toLowerCase();
-  if (!text.trim()) return false;
-  return [
-    /\b(?:dispatch|delegate|assign|queue)\b/,
-    /\b(?:create|open|file)\s+(?:a\s+)?(?:work\s*item|task)\b/,
-    /\b(?:have|ask|tell)\s+(?:minions|an?\s+agent|[a-z][\w-]*)\s+(?:to\s+)?(?:fix|implement|review|test|explore|investigate)\b/,
-    /\bminions\b[^.?!\n]*\b(?:fix|implement|review|test|explore|investigate|plan)\b/,
-    /\b(?:create|make|draft|write)\s+(?:a\s+)?minions?\s+plan\b/,
-  ].some(pattern => pattern.test(text));
+  const normalized = _normalizeIntentText(message);
+  if (!normalized.trim()) return false;
+  if (_messageHasDelegationIntent(message)) return true;
+  if (_intentHasAnyToken(normalized, ['minions']) &&
+      (_messageHasMediumLargeWorkIntent(message) || _messageRequestsPlanIntent(message))) return true;
+  if (_intentHasAnyToken(normalized, ['agent', 'agents']) && _messageHasMediumLargeWorkIntent(message)) return true;
+  return _intentHasVerbObject(normalized, ['create', 'make', 'draft', 'write'], ['plan']) &&
+    _intentHasAnyToken(normalized, ['minion', 'minions']);
 }
 
 function _ccInferMessageActionIntent(message, source = 'command-center') {
-  const text = String(message || '').trim();
-  const lower = text.toLowerCase();
-  if (!lower) return null;
-  if (source === 'doc-chat' && !_messageExplicitlyRequestsMinionsOrchestration(text)) return null;
-  if (/^\/plan\b/.test(lower) || /\b(?:make|create|draft|write|design|come up with)\s+(?:a\s+)?plan\b/.test(lower) || /\bplan\s+(?:this|that|it|for|how|out)\b/.test(lower)) {
+  const normalized = _normalizeIntentText(message);
+  if (!normalized.trim()) return null;
+  if (source === 'doc-chat' && !_messageExplicitlyRequestsMinionsOrchestration(message)) return null;
+  if (_messageRequestsPlanIntent(message)) {
     return { kind: 'plan' };
   }
-  const workPatterns = [
-    ['fix', /\b(?:fix|repair|resolve|patch|debug)\b|\b(?:bug|broken|crash|error|regression|failing|failure)\b/],
-    ['implement', /\b(?:implement|build|add|create|ship)\b/],
-    ['review', /\b(?:review|code review|inspect|audit)\b/],
-    ['test', /\b(?:test|verify|validate|run tests?|write tests?|add tests?|coverage|build)\b/],
-    ['explore', /\b(?:explore|investigate|research|analyze|understand|look into|map out|survey)\b/],
-  ];
-  for (const [workType, pattern] of workPatterns) {
-    if (pattern.test(lower)) return { kind: 'work-item', workType };
-  }
-  return null;
+  if (!_messageHasDelegationIntent(message) && !_messageHasMediumLargeWorkIntent(message, { source })) return null;
+  return { kind: 'work-item', workType: _inferDelegatedWorkType(message) };
 }
 
 function _ccInferMetadataActionIntent(meta) {
@@ -1892,52 +1957,64 @@ function _ccInferMetadataActionIntent(meta) {
 }
 
 function _ccActionIntentTargetText(message, intent) {
-  let text = _ccCleanIntentString(message, 500);
-  text = text
-    .replace(/^\/(?:plan|fix|implement|review|test|explore)\s+/i, '')
-    .replace(/^(?:please\s+)?(?:dispatch|delegate|assign|queue)\s+(?:a\s+|an\s+)?(?:work\s*item|task|agent)?\s*(?:to\s+)?/i, '')
-    .replace(/^(?:please\s+)?(?:create|open|file)\s+(?:a\s+)?(?:work\s*item|task)\s+(?:to\s+|for\s+)?/i, '')
-    .replace(/^(?:please\s+)?(?:have|ask|tell)\s+(?:minions|an?\s+agent|[a-z][\w-]*)\s+(?:to\s+)?/i, '')
-    .replace(/^(?:please\s+)?/, '')
-    .trim();
+  const tokens = _intentTokens(_normalizeIntentText(_ccCleanIntentString(message, 500)));
+  let start = 0;
+  const skip = (terms) => {
+    if (terms.includes(tokens[start])) {
+      start++;
+      return true;
+    }
+    return false;
+  };
+  skip(['please']);
+  if (tokens[start] && tokens[start].startsWith('/')) start++;
+  if (['dispatch', 'delegate', 'assign', 'queue', 'enqueue'].includes(tokens[start])) {
+    start++;
+    while (['a', 'an', 'the', 'work', 'item', 'task', 'agent', 'to'].includes(tokens[start])) start++;
+  } else if (['create', 'open', 'file'].includes(tokens[start]) && tokens[start + 1] && ['a', 'an', 'the', 'work', 'item', 'task'].includes(tokens[start + 1])) {
+    start++;
+    while (['a', 'an', 'the', 'work', 'item', 'task', 'to', 'for'].includes(tokens[start])) start++;
+  } else if (['have', 'ask', 'tell'].includes(tokens[start])) {
+    start++;
+    while (tokens[start] && !['to', 'fix', 'implement', 'review', 'test', 'explore', 'investigate', 'audit'].includes(tokens[start])) start++;
+    if (tokens[start] === 'to') start++;
+  }
   if (intent?.kind === 'plan') {
-    text = text.replace(/^(?:make|create|draft|write|design|come up with)\s+(?:a\s+)?plan\s+(?:for\s+|to\s+|about\s+)?/i, '')
-      .replace(/^plan\s+(?:out\s+)?(?:for\s+|how\s+to\s+|this\s+|that\s+|it\s+)?/i, '');
+    while (['make', 'create', 'draft', 'write', 'design', 'plan', 'out', 'a', 'an', 'the', 'for', 'to', 'about', 'how'].includes(tokens[start])) start++;
   } else if (intent?.workType) {
-    const workType = intent.workType;
-    const verbPattern = {
-      fix: /^(?:fix|repair|resolve|patch|debug)\s+(?:the\s+|a\s+|an\s+)?/i,
-      implement: /^(?:implement|build|add|create|ship)\s+(?:the\s+|a\s+|an\s+)?/i,
-      review: /^(?:review|code review|inspect|audit)\s+(?:the\s+|a\s+|an\s+)?/i,
-      test: /^(?:test|verify|validate|run tests?\s+(?:for\s+|on\s+)?|write tests?\s+(?:for\s+)?|add tests?\s+(?:for\s+)?)\s*(?:the\s+|a\s+|an\s+)?/i,
-      explore: /^(?:explore|investigate|research|analyze|understand|look into|map out|survey)\s+(?:the\s+|a\s+|an\s+)?/i,
-    }[workType];
-    if (verbPattern) text = text.replace(verbPattern, '');
-    text = text.replace(/^(?:a\s+)?(?:fix|review|test|implementation|exploration|investigation)\s+(?:for\s+|to\s+|of\s+)?/i, '');
+    while (['fix', 'repair', 'resolve', 'patch', 'debug', 'implement', 'build', 'add', 'create', 'ship', 'review', 'inspect', 'audit', 'test', 'verify', 'validate', 'run', 'write', 'explore', 'investigate', 'research', 'analyze', 'analyse', 'understand', 'look', 'map', 'survey', 'a', 'an', 'the', 'for', 'to', 'of', 'on', 'about'].includes(tokens[start])) start++;
   }
-  return text.replace(/^(?:for|to|of|on|about)\s+/i, '').trim();
+  while (['for', 'to', 'of', 'on', 'about', 'a', 'an', 'the'].includes(tokens[start])) start++;
+  return tokens.slice(start).join(' ');
 }
 
 function _ccIntentHasConcreteTarget(message, metadataTitle, intent) {
   const raw = String(message || '');
-  if (/\b(?:PR|pull request|issue)\s*#?\d+\b/i.test(raw) || /\bW-[a-z0-9][a-z0-9-]*\b/i.test(raw) || /https?:\/\//i.test(raw)) return true;
-  const target = _ccActionIntentTargetText(metadataTitle || raw, intent)
-    .replace(/[.!?]+$/g, '')
-    .trim()
-    .toLowerCase();
+  const normalized = _normalizeIntentText(raw);
+  const tokens = _intentTokens(normalized);
+  if (raw.includes('http://') || raw.includes('https://')) return true;
+  for (let i = 0; i < tokens.length; i++) {
+    if (['pr', 'issue'].includes(tokens[i]) && tokens[i + 1] && _intentTokenIsNumeric(tokens[i + 1])) return true;
+    if (tokens[i] === 'pull' && tokens[i + 1] === 'request' && tokens[i + 2] && _intentTokenIsNumeric(tokens[i + 2])) return true;
+    if (tokens[i] === 'w' && tokens[i + 1] && tokens[i + 1].length >= 2) return true;
+  }
+  const target = _ccActionIntentTargetText(metadataTitle || raw, intent).trim().toLowerCase();
   if (!target) return false;
-  if (/^(?:this|that|it|these|those|same|above|the above|here|there)(?:\s+(?:one|thing|issue|bug|task|request|change|pr|pull request|code|test|plan|doc|document|file))?$/.test(target)) {
-    return false;
-  }
+  const targetTokens = _intentTokens(_normalizeIntentText(target));
+  const generic = new Set(['this', 'that', 'it', 'these', 'those', 'same', 'above', 'here', 'there', 'one', 'thing', 'issue', 'bug', 'task', 'request', 'change', 'pr', 'pull', 'code', 'test', 'plan', 'doc', 'document', 'file']);
+  if (targetTokens.length > 0 && targetTokens.every(token => generic.has(token))) return false;
   return target.length >= 3;
 }
 
 function _ccIntentTitle(message, metadataTitle, intent) {
   const metaTitle = _ccCleanIntentString(metadataTitle, 300);
   if (metaTitle && _ccIntentHasConcreteTarget(message, metaTitle, intent)) return metaTitle;
-  const cleaned = _ccCleanIntentString(message, 300).replace(/^\/plan\s+/i, 'plan ');
+  const cleaned = _ccCleanIntentString(message, 300);
   if (!cleaned) return '';
-  return cleaned.charAt(0).toUpperCase() + cleaned.slice(1);
+  const title = intent?.kind === 'plan'
+    ? cleaned
+    : _delegatedWorkTitle(cleaned, intent?.workType || 'ask');
+  return title.charAt(0).toUpperCase() + title.slice(1);
 }
 
 function _ccFallbackMissingTargetError(intent) {
@@ -1945,17 +2022,20 @@ function _ccFallbackMissingTargetError(intent) {
   return `Missing target for ${label} request. Specify a concrete title, PR/work item, file, or feature to ${label}.`;
 }
 
-function _actionsWithIntentFallback(actions, { message = '', intentMetadata = null, source = 'command-center' } = {}) {
-  const existing = Array.isArray(actions) ? actions : [];
+function _actionsWithIntentFallback(actions, opts = {}) {
+  const { message = '', intentMetadata = null, source = 'command-center', filePath = null, title: docTitle = null, answerText = '', toolUses = [] } = opts;
+  const existing = Array.isArray(actions) ? actions.map(normalizeCCAction) : [];
+  if (_messageRequestsDirectHandling(message)) return existing.filter(a => normalizeCCAction(a)?.type !== 'dispatch');
+  if (existing.some(a => normalizeCCAction(a)?.type === 'dispatch')) return existing;
   if (existing.length > 0) return existing;
   const meta = _ccNormalizeIntentMetadata(intentMetadata);
   const messageIntent = _ccInferMessageActionIntent(message, source);
   const metadataIntent = source === 'doc-chat' ? null : _ccInferMetadataActionIntent(meta);
   const intent = messageIntent || metadataIntent;
-  if (!intent) return existing;
+  if (!intent) return _ensureDelegationForIntent(existing, { message, source, filePath, title: docTitle, answerText, toolUses });
 
   const title = _ccIntentTitle(message, meta.title, intent);
-  const hasTarget = _ccIntentHasConcreteTarget(message, meta.title || title, intent);
+  const hasTarget = _ccIntentHasConcreteTarget(message, meta.title, intent);
   const description = meta.description || _ccCleanIntentString(message, 2000);
   const common = {
     ...(title ? { title } : {}),
@@ -2038,6 +2118,261 @@ function parseCCActions(text) {
   return result;
 }
 
+const DELEGATION_ACTION_TERMS = ['dispatch', 'delegate', 'assign', 'queue', 'enqueue'];
+const DELEGATION_MINIONS_PHRASES = ['have minions', 'ask minions', 'tell minions', 'hand off', 'hand it off', 'hand this off', 'send to agent', 'send it to agent', 'send this to agent'];
+const MEDIUM_INVESTIGATION_TERMS = ['audit', 'investigate', 'research', 'explore', 'analyze', 'analyse'];
+const MEDIUM_INVESTIGATION_PHRASES = ['deep dive', 'root cause'];
+const MEDIUM_IMPLEMENT_TERMS = ['implement', 'fix', 'debug', 'repair', 'refactor', 'migrate', 'harden', 'redesign'];
+const MEDIUM_BUILD_VERBS = ['build', 'add', 'create'];
+const MEDIUM_BUILD_OBJECTS = ['feature', 'support', 'endpoint', 'api', 'ui', 'page', 'component', 'flow', 'integration', 'automation', 'test', 'tests', 'tool', 'command', 'dashboard', 'service', 'module'];
+const MEDIUM_REVIEW_TERMS = ['review', 'test', 'verify', 'validate'];
+const MEDIUM_SIZE_TERMS = ['medium', 'large', 'larger'];
+const MEDIUM_SIZE_PHRASES = ['cross cutting', 'multi file', 'multi step', 'multi stage', 'multi module'];
+const PLAN_INTENT_TERMS = ['plan'];
+const PLAN_CREATE_TERMS = ['make', 'create', 'draft', 'write', 'design'];
+const PLAN_CREATE_PHRASES = ['come up with'];
+const DOC_CHAT_DIRECT_DOC_TERMS = ['summarize', 'summary', 'quote', 'extract', 'rewrite', 'reword', 'copyedit', 'proofread', 'format', 'typo'];
+const DOC_CHAT_DOC_ACTION_TERMS = ['edit', 'update', 'change', 'review', 'check'];
+const DOC_CHAT_DOC_OBJECTS = ['document', 'doc', 'paragraph', 'section', 'selection', 'text', 'wording'];
+const DIRECT_QUICK_TERMS = ['quick', 'simple', 'small'];
+const DIRECT_QUICK_OBJECTS = ['question', 'answer', 'lookup', 'check'];
+const DIRECT_REPLY_TERMS = ['answer', 'respond', 'reply'];
+const DIRECT_REPLY_TARGETS = ['directly', 'inline', 'here'];
+const DIRECT_SELF_TERMS = ['do', 'handle', 'answer', 'fix', 'edit', 'update', 'change', 'review', 'check'];
+const DIRECT_SELF_TARGETS = ['yourself', 'directly'];
+const DIRECT_HANDLING_PHRASES = [
+  'you do it yourself', 'you handle it yourself', 'you handle this yourself',
+  'cc do it yourself', 'doc chat do it yourself', 'doc chat handle it yourself',
+  'do not dispatch', 'dont dispatch', 'do not delegate', 'dont delegate',
+  'do not assign', 'dont assign', 'do not queue', 'dont queue',
+  'do not enqueue', 'dont enqueue', 'do not create work item', 'dont create work item',
+  'no dispatch', 'no delegate', 'no delegation', 'no work item',
+  'without dispatching', 'without delegating', 'without creating work item',
+];
+
+function _isIntentWordChar(ch) {
+  const code = ch.charCodeAt(0);
+  return (code >= 48 && code <= 57) || (code >= 97 && code <= 122);
+}
+
+function _normalizeIntentText(message) {
+  const raw = String(message || '').toLowerCase();
+  let out = ' ';
+  let lastWasSpace = true;
+  for (const ch of raw) {
+    if (ch === '\'' || ch === '\u2019') continue;
+    if (_isIntentWordChar(ch)) {
+      out += ch;
+      lastWasSpace = false;
+    } else if (!lastWasSpace) {
+      out += ' ';
+      lastWasSpace = true;
+    }
+  }
+  return lastWasSpace ? out : out + ' ';
+}
+
+function _intentTokens(normalized) {
+  const text = String(normalized || '').trim();
+  return text ? text.split(' ') : [];
+}
+
+function _intentHasAnyToken(normalized, terms) {
+  const tokens = new Set(_intentTokens(normalized));
+  return terms.some(term => tokens.has(term));
+}
+
+function _intentHasPhrase(normalized, phrase) {
+  return String(normalized || '').includes(` ${phrase} `);
+}
+
+function _intentHasAnyPhrase(normalized, phrases) {
+  return phrases.some(phrase => _intentHasPhrase(normalized, phrase));
+}
+
+function _intentTokenIsNumeric(token) {
+  if (!token) return false;
+  for (const ch of String(token)) {
+    const code = ch.charCodeAt(0);
+    if (code < 48 || code > 57) return false;
+  }
+  return true;
+}
+
+function _intentHasVerbObject(normalized, verbs, objects) {
+  const verbSet = new Set(verbs);
+  const objectSet = new Set(objects);
+  const filler = new Set(['a', 'an', 'the', 'this', 'that', 'it', 'new', 'proper', 'some']);
+  const tokens = _intentTokens(normalized);
+  for (let i = 0; i < tokens.length; i++) {
+    if (!verbSet.has(tokens[i])) continue;
+    for (let j = i + 1; j < tokens.length && j <= i + 4; j++) {
+      if (filler.has(tokens[j])) continue;
+      if (objectSet.has(tokens[j])) return true;
+      break;
+    }
+  }
+  return false;
+}
+
+function _messageRequestsPlanIntent(message) {
+  const normalized = _normalizeIntentText(message);
+  const tokens = _intentTokens(normalized);
+  if (!tokens.length) return false;
+  if (tokens[0] === 'plan') return true;
+  if (_intentHasAnyPhrase(normalized, PLAN_CREATE_PHRASES) && _intentHasAnyToken(normalized, PLAN_INTENT_TERMS)) return true;
+  if (_intentHasVerbObject(normalized, PLAN_CREATE_TERMS, PLAN_INTENT_TERMS)) return true;
+  return _intentHasAnyToken(normalized, PLAN_INTENT_TERMS) &&
+    _intentHasAnyToken(normalized, ['this', 'that', 'it', 'for', 'how', 'out']);
+}
+
+function _messageHasDelegationIntent(message) {
+  const normalized = _normalizeIntentText(message);
+  if (!normalized.trim()) return false;
+  if (_intentHasAnyToken(normalized, DELEGATION_ACTION_TERMS)) return true;
+  if (_intentHasPhrase(normalized, 'work item') && _intentHasAnyToken(normalized, ['create', 'open', 'add'])) return true;
+  return _intentHasAnyPhrase(normalized, DELEGATION_MINIONS_PHRASES);
+}
+
+function _messageRequestsDirectHandling(message) {
+  const normalized = _normalizeIntentText(message);
+  if (!normalized.trim()) return false;
+  if (_intentHasAnyPhrase(normalized, DIRECT_HANDLING_PHRASES)) return true;
+  if (_intentHasAnyToken(normalized, DIRECT_QUICK_TERMS) && _intentHasAnyToken(normalized, DIRECT_QUICK_OBJECTS)) return true;
+  if (_intentHasVerbObject(normalized, DIRECT_REPLY_TERMS, DIRECT_REPLY_TARGETS)) return true;
+  return _intentHasVerbObject(normalized, DIRECT_SELF_TERMS, DIRECT_SELF_TARGETS);
+}
+
+function _messageIsSmallDocOnlyRequest(normalized) {
+  if (_intentHasAnyToken(normalized, DOC_CHAT_DIRECT_DOC_TERMS)) return true;
+  return _intentHasVerbObject(normalized, DOC_CHAT_DOC_ACTION_TERMS, DOC_CHAT_DOC_OBJECTS);
+}
+
+function _messageHasMediumLargeWorkIntent(message, { source = 'command-center' } = {}) {
+  const normalized = _normalizeIntentText(message);
+  if (!normalized.trim()) return false;
+  if (_messageRequestsDirectHandling(message)) return false;
+  if (source === 'doc-chat' && _messageIsSmallDocOnlyRequest(normalized)) return false;
+  return _intentHasAnyToken(normalized, MEDIUM_INVESTIGATION_TERMS) ||
+    _intentHasAnyPhrase(normalized, MEDIUM_INVESTIGATION_PHRASES) ||
+    _intentHasAnyToken(normalized, MEDIUM_IMPLEMENT_TERMS) ||
+    _intentHasVerbObject(normalized, MEDIUM_BUILD_VERBS, MEDIUM_BUILD_OBJECTS) ||
+    _intentHasAnyToken(normalized, MEDIUM_REVIEW_TERMS) ||
+    _intentHasAnyToken(normalized, MEDIUM_SIZE_TERMS) ||
+    _intentHasAnyPhrase(normalized, MEDIUM_SIZE_PHRASES);
+}
+
+function _inferDelegatedWorkType(message) {
+  const normalized = _normalizeIntentText(message);
+  if (_intentHasAnyToken(normalized, ['test', 'verify', 'validate']) || _intentHasPhrase(normalized, 'build and test')) return 'test';
+  if (_intentHasAnyToken(normalized, ['review']) || _intentHasPhrase(normalized, 'code review')) return 'review';
+  if (_intentHasAnyToken(normalized, ['fix', 'debug', 'repair', 'bug', 'broken', 'failing', 'failure', 'regression']) || _intentHasPhrase(normalized, 'root cause')) return 'fix';
+  if (_intentHasAnyToken(normalized, ['implement', 'refactor', 'migrate', 'harden', 'redesign']) ||
+      _intentHasVerbObject(normalized, MEDIUM_BUILD_VERBS, MEDIUM_BUILD_OBJECTS)) return 'implement';
+  if (_intentHasAnyToken(normalized, MEDIUM_INVESTIGATION_TERMS) || _intentHasAnyPhrase(normalized, MEDIUM_INVESTIGATION_PHRASES)) return 'explore';
+  return 'ask';
+}
+
+function _collapseWhitespace(text) {
+  let out = '';
+  let lastWasSpace = true;
+  for (const ch of String(text || '')) {
+    const isSpace = ch === ' ' || ch === '\n' || ch === '\r' || ch === '\t';
+    if (isSpace) {
+      if (!lastWasSpace) out += ' ';
+      lastWasSpace = true;
+    } else {
+      out += ch;
+      lastWasSpace = false;
+    }
+  }
+  return out.trim();
+}
+
+function _stripEdgeQuotes(text) {
+  const quotes = new Set(['"', "'", '`']);
+  let start = 0;
+  let end = String(text || '').length;
+  while (start < end && quotes.has(text[start])) start++;
+  while (end > start && quotes.has(text[end - 1])) end--;
+  return text.slice(start, end);
+}
+
+function _delegatedWorkTitle(message, workType) {
+  const compact = _stripEdgeQuotes(_collapseWhitespace(String(message || '')));
+  const trimmed = compact.length > 90 ? compact.slice(0, 87).trimEnd() + '...' : compact;
+  const fallback = {
+    fix: 'Fix requested issue',
+    review: 'Review requested work',
+    test: 'Test requested work',
+    implement: 'Implement requested work',
+    'implement:large': 'Implement requested work',
+    explore: 'Investigate requested work',
+    ask: 'Answer requested query',
+    verify: 'Verify requested work',
+  }[workType] || 'Handle requested work';
+  if (!trimmed) return fallback;
+  const prefix = {
+    fix: 'Fix',
+    review: 'Review',
+    test: 'Test',
+    implement: 'Implement',
+    'implement:large': 'Implement',
+    explore: 'Investigate',
+    ask: 'Answer',
+    verify: 'Verify',
+  }[workType] || 'Handle';
+  const lower = trimmed.toLowerCase();
+  const prefixLower = prefix.toLowerCase();
+  if (lower === prefixLower || lower.startsWith(prefixLower + ' ')) return trimmed;
+  return `${prefix}: ${trimmed}`;
+}
+
+function _priorityFromDelegationMessage(message) {
+  const normalized = _normalizeIntentText(message);
+  if (_intentHasAnyToken(normalized, ['urgent', 'asap', 'critical', 'blocker', 'p0', 'p1']) || _intentHasPhrase(normalized, 'high priority')) return 'high';
+  if (_intentHasPhrase(normalized, 'low priority') || _intentHasPhrase(normalized, 'when you can') || _intentHasAnyToken(normalized, ['whenever'])) return 'low';
+  return 'medium';
+}
+
+function _inferDelegationActionFromMessage(message, { source = 'command-center', filePath = null, title = null, answerText = '', toolUses = [] } = {}) {
+  if (_messageRequestsDirectHandling(message)) return null;
+  const explicit = _messageHasDelegationIntent(message);
+  const mediumLarge = _messageHasMediumLargeWorkIntent(message, { source });
+  const toolCount = Array.isArray(toolUses) ? toolUses.length : 0;
+  if (!explicit && !mediumLarge && toolCount < 4) return null;
+
+  const workType = _inferDelegatedWorkType(message);
+  const inferredProject = source === 'doc-chat' && filePath && typeof _inferDocChatProject === 'function'
+    ? _inferDocChatProject(filePath)
+    : null;
+  const context = [];
+  context.push(`${source === 'doc-chat' ? 'Doc-chat' : 'Command Center'} detected ${explicit ? 'an explicit dispatch/delegation request' : (toolCount >= 4 ? 'a medium-sized tool-using request' : 'a medium/large work request')} and routed it through the engine.`);
+  if (filePath) context.push(`Document: ${filePath}`);
+  if (title && title !== filePath) context.push(`Title: ${title}`);
+  if (answerText && String(answerText).trim()) context.push(`Assistant draft before delegation:\n${String(answerText).trim().slice(0, 1200)}`);
+  context.push(`Original request:\n${String(message || '').trim()}`);
+
+  return {
+    type: 'dispatch',
+    title: _delegatedWorkTitle(message, workType),
+    workType,
+    priority: _priorityFromDelegationMessage(message),
+    description: context.join('\n\n'),
+    ...(inferredProject ? { project: inferredProject } : {}),
+    _autoDelegated: true,
+  };
+}
+
+function _ensureDelegationForIntent(actions, opts = {}) {
+  const list = Array.isArray(actions) ? actions.map(normalizeCCAction) : [];
+  if (_messageRequestsDirectHandling(opts.message)) return list.filter(a => normalizeCCAction(a)?.type !== 'dispatch');
+  if (list.some(a => normalizeCCAction(a)?.type === 'dispatch')) return list;
+  if (list.length > 0) return list;
+  const inferred = _inferDelegationActionFromMessage(opts.message, opts);
+  return inferred ? [...list, inferred] : list;
+}
+
 function stripCCActionSyntax(text) {
   if (!text) return '';
   let displayText = text;
@@ -2414,9 +2749,10 @@ function createPipelineFromAction(action) {
 // before `try` to avoid filling `results` with cryptic per-handler error messages.
 function _ccValidateAction(action) {
   if (!action || typeof action !== 'object' || !action.type) return 'action is missing required field: type';
-  switch (action.type) {
-    case 'dispatch': case 'fix': case 'explore': case 'review': case 'test':
-      if (!action.title || typeof action.title !== 'string' || !action.title.trim()) return `${action.type} action missing required field: title`;
+  const normalized = normalizeCCAction(action);
+  switch (normalized.type) {
+    case 'dispatch':
+      if (!normalized.title || typeof normalized.title !== 'string' || !normalized.title.trim()) return `${action.type} action missing required field: title`;
       return null;
     case 'implement':
       return 'Unsupported action type "implement"; use type="dispatch" with workType="implement".';
@@ -2760,7 +3096,7 @@ async function executeCCActions(actions, { source = 'command-center', inferredPr
     }
     try {
       switch (action.type) {
-        case 'dispatch': case 'fix': case 'explore': case 'review': case 'test': {
+        case 'dispatch': {
           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 || '';
@@ -2773,22 +3109,22 @@ async function executeCCActions(actions, { source = 'command-center', inferredPr
           // projects → root-level work-items.json (orchestration system standalone use).
           let targetProject = null;
           if (project) {
-            targetProject = PROJECTS.find(p => p.name?.toLowerCase() === project.toLowerCase());
-            if (!targetProject) {
-              const known = PROJECTS.map(p => p.name).join(', ') || '(none configured)';
-              results.push({ type: action.type, error: `Project "${project}" not found. Known projects: ${known}` });
+            const target = resolveProjectSourceTarget(project, PROJECTS, { allowCentral: false });
+            targetProject = target.project;
+            if (target.error) {
+              results.push({ type: action.type, error: target.error });
               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;
+              targetProject = resolveProjectSourceTarget(linkedPr._project, PROJECTS, { allowCentral: false }).project || null;
             }
           } else if (inferredProject) {
             // Doc-chat fallback: filePath-derived project when the LLM omits the field. Validated against
             // PROJECTS upstream by _inferDocChatProject — a stale lookup would just yield null here.
-            targetProject = PROJECTS.find(p => p.name?.toLowerCase() === inferredProject.toLowerCase()) || null;
+            targetProject = resolveProjectSourceTarget(inferredProject, PROJECTS, { allowCentral: false }).project || null;
           }
           if (!targetProject) {
             if (PROJECTS.length > 1) {
@@ -2809,7 +3145,7 @@ async function executeCCActions(actions, { source = 'command-center', inferredPr
             break;
           }
 
-          const wiPath = targetProject ? shared.projectWorkItemsPath(targetProject) : path.join(MINIONS_DIR, 'work-items.json');
+          const wiPath = targetProject ? shared.projectWorkItemsPath(targetProject) : shared.centralWorkItemsPath(MINIONS_DIR);
 
           // Promote `agent` (singular) → `agents` (array). Models emit either shape and the prior code
           // only read `action.agents`, silently dropping `agent: "lambert"` style hints.
@@ -2827,7 +3163,7 @@ async function executeCCActions(actions, { source = 'command-center', inferredPr
 
           // Issue #1772: CC review/explore/test are human-initiated one-offs.
           // Mark oneShot so any discovered PR is tagged _contextOnly (skips eval loop).
-          const ccOneShotTypes = new Set(['review', 'explore', 'test']);
+          const ccOneShotTypes = new Set([WORK_TYPE.REVIEW, WORK_TYPE.EXPLORE, WORK_TYPE.TEST, WORK_TYPE.ASK, WORK_TYPE.VERIFY]);
           const isOneShot = action.oneShot === true || (action.oneShot !== false && ccOneShotTypes.has(workType));
           const item = {
             id, title: action.title.trim(), type: workType,
@@ -2872,7 +3208,7 @@ async function executeCCActions(actions, { source = 'command-center', inferredPr
           // unresolved → error so build-and-test can't accidentally run against the wrong repo.
           const projectName = action.project || pr._project || null;
           const project = projectName
-            ? PROJECTS.find(p => p.name?.toLowerCase() === String(projectName).toLowerCase())
+            ? resolveProjectSourceTarget(projectName, PROJECTS, { allowCentral: false }).project
             : null;
           if (!project) {
             results.push({ type: 'build-and-test', error: `Project not found for PR ${pr.id}: ${projectName || '(none)'}` });
@@ -2933,14 +3269,14 @@ async function executeCCActions(actions, { source = 'command-center', inferredPr
           const project = action.project || '';
           let targetProject = null;
           if (project) {
-            targetProject = PROJECTS.find(p => p.name?.toLowerCase() === project.toLowerCase());
-            if (!targetProject) {
-              const known = PROJECTS.map(p => p.name).join(', ') || '(none configured)';
-              results.push({ type: 'reopen-work-item', id: action.id, error: `Project "${project}" not found. Known projects: ${known}` });
+            const target = resolveProjectSourceTarget(project, PROJECTS, { allowCentral: false });
+            targetProject = target.project;
+            if (target.error) {
+              results.push({ type: 'reopen-work-item', id: action.id, error: target.error });
               break;
             }
           } else if (inferredProject) {
-            targetProject = PROJECTS.find(p => p.name?.toLowerCase() === inferredProject.toLowerCase()) || null;
+            targetProject = resolveProjectSourceTarget(inferredProject, PROJECTS, { allowCentral: false }).project || null;
           }
           if (!targetProject) {
             if (PROJECTS.length > 1) {
@@ -2949,7 +3285,7 @@ async function executeCCActions(actions, { source = 'command-center', inferredPr
             }
             if (PROJECTS.length === 1) targetProject = PROJECTS[0];
           }
-          const wiPath = targetProject ? shared.projectWorkItemsPath(targetProject) : path.join(MINIONS_DIR, 'work-items.json');
+          const wiPath = targetProject ? shared.projectWorkItemsPath(targetProject) : shared.centralWorkItemsPath(MINIONS_DIR);
           let reopenResult = null;
           mutateJsonFileLocked(wiPath, items => {
             if (!Array.isArray(items)) items = [];
@@ -3054,7 +3390,7 @@ async function executeDocChatActions(actions, { filePath = null } = {}) {
   return executeCCActions(actions, { source: 'doc-chat', inferredProject: _inferDocChatProject(filePath) });
 }
 
-const DOC_CHAT_WORK_ITEM_ACTION_TYPES = new Set(['dispatch', 'fix', 'explore', 'review', 'test']);
+const DOC_CHAT_WORK_ITEM_ACTION_TYPES = new Set(['dispatch', 'fix', 'implement', 'implement:large', 'explore', 'review', 'test', 'ask', 'verify']);
 
 function _buildDocChatActionFeedback(actions, actionResults) {
   if (!Array.isArray(actions) || !Array.isArray(actionResults)) return [];
@@ -3529,7 +3865,7 @@ function _inferDocChatProject(filePath) {
   if (!filePath) return null;
   const m = String(filePath).replace(/\\/g, '/').match(/^projects\/([^/]+)\//);
   if (!m) return null;
-  const inferred = PROJECTS.find(p => p.name?.toLowerCase() === m[1].toLowerCase());
+  const inferred = resolveProjectSourceTarget(m[1], PROJECTS, { allowCentral: false }).project;
   return inferred?.name || null;
 }
 
@@ -3855,8 +4191,9 @@ async function ccDocCall({ message, document, title, filePath, selection, canEdi
       timeout: DOC_CHAT_TIMEOUT_MS,
       // Match Command Center's full tool surface and turn budget so doc-chat
       // can take action (read/write/edit/dispatch) instead of being limited
-      // to Q&A. The doc-chat sysprompt still scopes orchestration to explicit
-      // requests, and ---DOCUMENT--- remains the only document edit channel.
+      // to Q&A. The doc-chat sysprompt scopes orchestration to human message
+      // intent (explicit dispatch or medium/larger work), and ---DOCUMENT---
+      // remains the only whole-file document edit channel.
       allowedTools: 'Bash,Read,Write,Edit,Glob,Grep,WebFetch,WebSearch',
       systemPrompt: DOC_CHAT_SYSTEM_PROMPT,
       transcript,
@@ -4215,14 +4552,14 @@ const server = http.createServer(async (req, res) => {
       }
 
       const config = queries.getConfig();
-      const project = PROJECTS.find(p => {
-        // safeJsonNoRestore — never resurrect an archived PRD's .backup
-        // sidecar during project resolution (W-mouptdh1000h9f39). The
-        // active-from-archive write above (mutateJsonFileLocked) already
-        // created activePath when needed.
-        const plan = safeJsonNoRestore(activePath) || safeJsonNoRestore(prdPath);
-        return plan && p.name?.toLowerCase() === (plan.project || '').toLowerCase();
-      }) || PROJECTS[0] || null;
+      // safeJsonNoRestore — never resurrect an archived PRD's .backup sidecar
+      // during project resolution (W-mouptdh1000h9f39). The active-from-archive
+      // write above (mutateJsonFileLocked) already created activePath when needed.
+      const projectPlan = safeJsonNoRestore(activePath) || safeJsonNoRestore(prdPath);
+      const projectTarget = projectPlan?.project
+        ? resolveProjectSourceTarget(projectPlan.project, PROJECTS, { allowCentral: false })
+        : null;
+      const project = projectTarget?.project || (PROJECTS.length === 1 ? PROJECTS[0] : null);
 
       // Check for existing verify WI — reset to pending if already done (re-verify)
       if (project) {
@@ -4276,25 +4613,9 @@ const server = http.createServer(async (req, res) => {
       if (!id) return jsonReply(res, 400, { error: 'id required' });
 
       // Find the right file — check source first, then search all project files
-      let wiPath;
-      if (source && source !== 'central') {
-        const proj = PROJECTS.find(p => p.name === source);
-        if (proj) wiPath = shared.projectWorkItemsPath(proj);
-      }
-      if (!wiPath) {
-        // Search central first, then all projects
-        const centralPath = path.join(MINIONS_DIR, 'work-items.json');
-        const centralItems = shared.safeJson(centralPath) || [];
-        if (centralItems.some(i => i.id === id)) {
-          wiPath = centralPath;
-        } else {
-          for (const proj of PROJECTS) {
-            const projPath = shared.projectWorkItemsPath(proj);
-            const projItems = shared.safeJson(projPath) || [];
-            if (projItems.some(i => i.id === id)) { wiPath = projPath; break; }
-          }
-        }
-      }
+      let resolvedTarget = findWorkItemsTargetById(id, source, PROJECTS);
+      if (resolvedTarget.error) return jsonReply(res, 404, { error: resolvedTarget.error });
+      let wiPath = resolvedTarget.found ? resolvedTarget.wiPath : null;
       // If no work item found, attempt to re-materialize from PRD item definition
       if (!wiPath) {
         const prdFile = body.prdFile;
@@ -4313,8 +4634,9 @@ const server = http.createServer(async (req, res) => {
 
         // Determine target work-items file (project from PRD item or plan, fallback to central)
         const projName = prdItem.project || plan.project || prdFile.replace(/-\d{4}-\d{2}-\d{2}\.json$/, '');
-        const proj = PROJECTS.find(p => p.name?.toLowerCase() === projName.toLowerCase());
-        const targetWiPath = proj ? shared.projectWorkItemsPath(proj) : path.join(MINIONS_DIR, 'work-items.json');
+        const prdTarget = resolveProjectSourceTarget(projName, PROJECTS, { allowCentral: false });
+        const proj = prdTarget.project;
+        const targetWiPath = proj ? shared.projectWorkItemsPath(proj) : shared.centralWorkItemsPath(MINIONS_DIR);
 
         // Create new work item from PRD item definition (same logic as materializePlansAsWorkItems)
         const complexity = prdItem.estimated_complexity || 'medium';
@@ -4346,8 +4668,7 @@ const server = http.createServer(async (req, res) => {
 
         // Clear dispatch history and cooldowns for this item
         const dispatchPath = path.join(MINIONS_DIR, 'engine', 'dispatch.json');
-        const sourcePrefix = proj ? `work-${proj.name}-` : 'central-work-';
-        const dispatchKey = sourcePrefix + id;
+        const dispatchKey = (proj ? `work-${proj.name}-` : 'central-work-') + id;
         try {
           mutateJsonFileLocked(dispatchPath, (dispatch) => {
             dispatch.completed = Array.isArray(dispatch.completed) ? dispatch.completed : [];
@@ -4392,8 +4713,7 @@ const server = http.createServer(async (req, res) => {
 
       // Clear completed dispatch entries so the engine doesn't dedup this item
       const dispatchPath = path.join(MINIONS_DIR, 'engine', 'dispatch.json');
-      const sourcePrefix = (!source || source === 'central') ? 'central-work-' : `work-${source}-`;
-      const dispatchKey = sourcePrefix + id;
+      const dispatchKey = dispatchPrefixForResolvedSource(resolvedTarget) + id;
       try {
         mutateJsonFileLocked(dispatchPath, (dispatch) => {
           dispatch.completed = Array.isArray(dispatch.completed) ? dispatch.completed : [];
@@ -4421,17 +4741,9 @@ const server = http.createServer(async (req, res) => {
       const { id, source } = body;
       if (!id) return jsonReply(res, 400, { error: 'id required' });
 
-      // Find the right work-items file
-      let wiPath;
-      if (!source || source === 'central') {
-        wiPath = path.join(MINIONS_DIR, 'work-items.json');
-      } else {
-        const proj = PROJECTS.find(p => p.name === source);
-        if (proj) {
-          wiPath = shared.projectWorkItemsPath(proj);
-        }
-      }
-      if (!wiPath) return jsonReply(res, 404, { error: 'source not found' });
+      const target = resolveProjectSourceTarget(source, PROJECTS);
+      if (target.error) return jsonReply(res, 404, { error: target.error });
+      const wiPath = target.wiPath;
 
       let item = null;
       let found = false;
@@ -4481,15 +4793,9 @@ const server = http.createServer(async (req, res) => {
       const { id, source, reason } = body;
       if (!id) return jsonReply(res, 400, { error: 'id required' });
 
-      // Find the right work-items file
-      let wiPath;
-      if (!source || source === 'central') {
-        wiPath = path.join(MINIONS_DIR, 'work-items.json');
-      } else {
-        const proj = PROJECTS.find(p => p.name === source);
-        if (proj) wiPath = shared.projectWorkItemsPath(proj);
-      }
-      if (!wiPath) return jsonReply(res, 404, { error: 'source not found' });
+      const target = resolveProjectSourceTarget(source, PROJECTS);
+      if (target.error) return jsonReply(res, 404, { error: target.error });
+      const wiPath = target.wiPath;
 
       let result = null;
       mutateJsonFileLocked(wiPath, (items) => {
@@ -4537,16 +4843,9 @@ const server = http.createServer(async (req, res) => {
       const { id, source } = body;
       if (!id) return jsonReply(res, 400, { error: 'id required' });
 
-      let wiPath;
-      if (!source || source === 'central') {
-        wiPath = path.join(MINIONS_DIR, 'work-items.json');
-      } else {
-        const proj = PROJECTS.find(p => p.name === source);
-        if (proj) {
-          wiPath = shared.projectWorkItemsPath(proj);
-        }
-      }
-      if (!wiPath) return jsonReply(res, 404, { error: 'source not found' });
+      const target = resolveProjectSourceTarget(source, PROJECTS);
+      if (target.error) return jsonReply(res, 404, { error: target.error });
+      const wiPath = target.wiPath;
 
       let archivedItem = null;
       mutateJsonFileLocked(wiPath, (items) => {
@@ -4568,7 +4867,7 @@ const server = http.createServer(async (req, res) => {
       }, { defaultValue: [] });
 
       // Clean dispatch entries for archived item
-      const sourcePrefix = (!source || source === 'central') ? 'central-work-' : `work-${source}-`;
+      const sourcePrefix = dispatchPrefixForResolvedSource(target);
       cleanDispatchEntries(d =>
         d.meta?.dispatchKey === sourcePrefix + id ||
         d.meta?.item?.id === id
@@ -4594,15 +4893,9 @@ const server = http.createServer(async (req, res) => {
       const project = body.project || body.source;
       if (!id) return jsonReply(res, 400, { error: 'id required' });
 
-      // Find the right work-items file
-      let wiPath;
-      if (!project || project === 'central') {
-        wiPath = path.join(MINIONS_DIR, 'work-items.json');
-      } else {
-        const proj = PROJECTS.find(p => p.name === project);
-        if (proj) wiPath = shared.projectWorkItemsPath(proj);
-      }
-      if (!wiPath) return jsonReply(res, 404, { error: 'project not found' });
+      const target = resolveProjectSourceTarget(project, PROJECTS);
+      if (target.error) return jsonReply(res, 404, { error: target.error });
+      const wiPath = target.wiPath;
 
       let result = null;
       mutateJsonFileLocked(wiPath, (items) => {
@@ -4622,8 +4915,7 @@ const server = http.createServer(async (req, res) => {
       if (result.code !== 200) return jsonReply(res, result.code, result.body);
 
       // Clear dispatch history and cooldowns outside lock
-      const sourcePrefix = (!project || project === 'central') ? 'central-work-' : `work-${project}-`;
-      const dispatchKey = sourcePrefix + id;
+      const dispatchKey = dispatchPrefixForResolvedSource(target) + id;
       try {
         const dispatchPath = path.join(MINIONS_DIR, 'engine', 'dispatch.json');
         mutateJsonFileLocked(dispatchPath, (dispatch) => {
@@ -4689,16 +4981,9 @@ const server = http.createServer(async (req, res) => {
       const { id, source, title, description, type, priority, agent } = body;
       if (!id) return jsonReply(res, 400, { error: 'id required' });
 
-      let wiPath;
-      if (!source || source === 'central') {
-        wiPath = path.join(MINIONS_DIR, 'work-items.json');
-      } else {
-        const proj = PROJECTS.find(p => p.name === source);
-        if (proj) {
-          wiPath = shared.projectWorkItemsPath(proj);
-        }
-      }
-      if (!wiPath) return jsonReply(res, 404, { error: 'source not found' });
+      const target = resolveProjectSourceTarget(source, PROJECTS);
+      if (target.error) return jsonReply(res, 404, { error: target.error });
+      const wiPath = target.wiPath;
 
       let result = null;
       let agentChanged = false;
@@ -4750,6 +5035,8 @@ 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 });
       // 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();
@@ -4759,7 +5046,7 @@ const server = http.createServer(async (req, res) => {
         status: WI_STATUS.PENDING, created: new Date().toISOString(), createdBy: 'dashboard',
         branchStrategy: body.branch_strategy || body.branchStrategy || 'parallel',
       };
-      if (body.project) item.project = body.project;
+      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 || '' });
@@ -4770,6 +5057,8 @@ 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 });
 
       if (!fs.existsSync(PRD_DIR)) fs.mkdirSync(PRD_DIR, { recursive: true });
 
@@ -4777,7 +5066,7 @@ const server = http.createServer(async (req, res) => {
       const planFile = 'manual-' + shared.uid() + '.json';
       const plan = {
         version: 'manual-' + new Date().toISOString().slice(0, 10),
-        project: body.project || (PROJECTS.length > 0 ? PROJECTS[0].name : 'Unknown'),
+        project: target.project?.name || 'Unknown',
         generated_by: 'dashboard',
         generated_at: new Date().toISOString().slice(0, 10),
         plan_summary: body.name,
@@ -5524,7 +5813,8 @@ const server = http.createServer(async (req, res) => {
         }).join('\n');
 
         const projectName = plan.project || body.file.replace(/-\d{4}-\d{2}-\d{2}\.json$/, '');
-        const targetProject = PROJECTS.find(p => p.name?.toLowerCase() === projectName.toLowerCase()) || PROJECTS[0];
+        const projectTarget = resolveProjectSourceTarget(projectName, PROJECTS, { allowCentral: false });
+        const targetProject = projectTarget.project || (PROJECTS.length === 1 ? PROJECTS[0] : null);
         if (targetProject) {
           diffAwareQueued = shared.queuePlanToPrd({
             planFile: plan.source_plan, prdFile: body.file,
@@ -6088,15 +6378,17 @@ What would you like to discuss or change? When you're happy, say "approve" and I
         transcript: body.transcript,
         onAbortReady: (abort) => { _docAbort = abort; },
       });
-      actions = _actionsWithIntentFallback(actions, { message: body.message, source: 'doc-chat' });
-      const actionResults = await executeDocChatActions(actions, { filePath: body.filePath });
-      const actionFeedback = _buildDocChatActionFeedback(actions, actionResults);
+      const delegatedActions = _ensureDelegationForIntent(actions, {
+        message: body.message, source: 'doc-chat', filePath: body.filePath, title: body.title, answerText: answer, toolUses,
+      });
+      const actionResults = await executeDocChatActions(delegatedActions, { filePath: body.filePath });
+      const actionFeedback = _buildDocChatActionFeedback(delegatedActions, actionResults);
       const finalize = _finalizeDocChatEdit({
         filePath: body.filePath, fullPath, isJson, canEdit,
         originalContent: currentContent, delimiterContent: content,
       });
       const payload = _buildDocChatResponsePayload({
-        answer, actions, actionResults, actionFeedback, actionParseError, ccError, partial, warning, toolUses, finalize,
+        answer, actions: delegatedActions, actionResults, actionFeedback, actionParseError, ccError, partial, warning, toolUses, finalize,
       });
       _docDone = true;
       return jsonReply(res, 200, payload);
@@ -6184,15 +6476,17 @@ What would you like to discuss or change? When you're happy, say "approve" and I
           onToolUse: (name, input) => { writeDocEvent({ type: 'tool', name, input: _lightToolInput(input) }); },
           onRetry: (attempt) => { writeDocEvent({ type: 'progress', attempt }); },
         });
-        actions = _actionsWithIntentFallback(actions, { message: body.message, source: 'doc-chat' });
-        const actionResults = await executeDocChatActions(actions, { filePath: body.filePath });
-        const actionFeedback = _buildDocChatActionFeedback(actions, actionResults);
+        const delegatedActions = _ensureDelegationForIntent(actions, {
+          message: body.message, source: 'doc-chat', filePath: body.filePath, title: body.title, answerText: answer, toolUses,
+        });
+        const actionResults = await executeDocChatActions(delegatedActions, { filePath: body.filePath });
+        const actionFeedback = _buildDocChatActionFeedback(delegatedActions, actionResults);
         const finalize = _finalizeDocChatEdit({
           filePath: body.filePath, fullPath, isJson, canEdit,
           originalContent: currentContent, delimiterContent: content,
         });
         const payload = _buildDocChatResponsePayload({
-          answer, actions, actionResults, actionFeedback, actionParseError, ccError, partial, warning, toolUses, finalize,
+          answer, actions: delegatedActions, actionResults, actionFeedback, actionParseError, ccError, partial, warning, toolUses, finalize,
         });
         const { answer: finalAnswer, ...donePayload } = payload;
         writeDocEvent({
@@ -6484,7 +6778,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       let alreadyLinked = false;
       mutateDashboardConfig(config => {
         if (!Array.isArray(config.projects)) config.projects = [];
-        alreadyLinked = config.projects.some(p => path.resolve(p.localPath) === target);
+        alreadyLinked = config.projects.some(p => shared.sameResolvedPath(p.localPath, target));
         return config;
       });
       if (alreadyLinked) {
@@ -6529,7 +6823,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       let duplicate = false;
       mutateDashboardConfig(config => {
         if (!Array.isArray(config.projects)) config.projects = [];
-        if (config.projects.some(p => path.resolve(p.localPath) === target)) {
+        if (config.projects.some(p => shared.sameResolvedPath(p.localPath, target))) {
           duplicate = true;
           return config;
         }
@@ -6713,13 +7007,8 @@ What would you like to discuss or change? When you're happy, say "approve" and I
           });
         }
 
-        const parsed = parseCCActions(result.text);
-        parsed.actions = _actionsWithIntentFallback(parsed.actions, {
-          message: body.message,
-          intentMetadata: body.intentMetadata,
-          source: 'command-center',
-        });
         const toolUses = Array.isArray(result.toolUses) ? result.toolUses : _extractToolUsesFromRaw(result.raw);
+        const parsed = parseCCActions(result.text);
         // Safety net: detect /loop invocation and convert to create-watch
         const _loopWatch = _detectLoopInvocation(parsed.text, parsed.actions, toolUses, body.message);
         if (_loopWatch) {
@@ -6727,7 +7016,10 @@ What would you like to discuss or change? When you're happy, say "approve" and I
           console.warn('[CC] /loop invocation detected — converted to create-watch');
           try { shared.log('warn', '/loop invocation detected in CC response — auto-converted to create-watch'); } catch {}
         }
-        parsed.actions = _filterImplicitPostDispatchActions(parsed.actions, body.message);
+        parsed.actions = _actionsWithIntentFallback(
+          _filterImplicitPostDispatchActions(parsed.actions, body.message),
+          { message: body.message, intentMetadata: body.intentMetadata, source: 'command-center', answerText: parsed.text, toolUses }
+        );
         if (parsed.actions.length > 0) {
           parsed.actionResults = await executeCCActions(parsed.actions);
         }
@@ -7048,11 +7340,6 @@ What would you like to discuss or change? When you're happy, say "approve" and I
 
         // Send final result with actions — execute server-side first
         let { text: displayText, actions, _actionParseError } = parseCCActions(result.text);
-        actions = _actionsWithIntentFallback(actions, {
-          message: body.message,
-          intentMetadata: body.intentMetadata,
-          source: 'command-center',
-        });
         // Safety net: detect /loop invocation and convert to create-watch
         const _loopWatch = _detectLoopInvocation(displayText, actions, toolUses, body.message);
         if (_loopWatch) {
@@ -7060,7 +7347,10 @@ What would you like to discuss or change? When you're happy, say "approve" and I
           console.warn('[CC] /loop invocation detected — converted to create-watch');
           try { shared.log('warn', '/loop invocation detected in CC response — auto-converted to create-watch'); } catch {}
         }
-        actions = _filterImplicitPostDispatchActions(actions, body.message);
+        actions = _actionsWithIntentFallback(
+          _filterImplicitPostDispatchActions(actions, body.message),
+          { message: body.message, intentMetadata: body.intentMetadata, source: 'command-center', answerText: displayText, toolUses }
+        );
         let actionResults;
         if (actions.length > 0) {
           actionResults = await executeCCActions(actions);
@@ -7124,6 +7414,9 @@ 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);
+    if (projectTarget.error) return jsonReply(res, 400, { error: projectTarget.error });
+    project = projectTarget.project?.name || null;
 
     // Auto-generate ID from title if not provided
     if (!id) {
@@ -7156,8 +7449,13 @@ What would you like to discuss or change? When you're happy, say "approve" and I
 
   async function handleSchedulesUpdate(req, res) {
     const body = await readBody(req);
-    const { id, cron, title, type, project, agent, description, priority, enabled } = body;
+    let { id, cron, title, type, project, agent, description, priority, enabled } = body;
     if (!id) return jsonReply(res, 400, { error: 'id required' });
+    if (project !== undefined) {
+      const projectTarget = shared.resolveConfiguredProject(project, PROJECTS);
+      if (projectTarget.error) return jsonReply(res, 400, { error: projectTarget.error });
+      project = projectTarget.project?.name || null;
+    }
 
     let missingSchedules = false;
     let sched = null;
@@ -7218,6 +7516,11 @@ 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 schedulerMod = require('./engine/scheduler');
     let item;
@@ -7675,7 +7978,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       if (body.projects && Array.isArray(body.projects)) {
         if (!config.projects) config.projects = [];
         for (const update of body.projects) {
-          const proj = config.projects.find(p => p.name === update.name);
+          const proj = shared.findProjectByName(config.projects, update.name);
           if (!proj) continue;
           if (!proj.workSources) proj.workSources = {};
           if (update.workSources?.pullRequests !== undefined) {
@@ -8325,8 +8628,12 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       const { savePipeline, getPipeline } = require('./engine/pipeline');
       if (getPipeline(body.id)) return jsonReply(res, 409, { error: 'Pipeline already exists' });
       const pipeline = { id: body.id, title: body.title, stages: body.stages, trigger: body.trigger || {}, enabled: body.enabled !== false };
+      if (body.project !== undefined) pipeline.project = body.project;
+      if (Array.isArray(body.projects)) pipeline.projects = body.projects;
       if (body.stopWhen) pipeline.stopWhen = body.stopWhen;
       if (Array.isArray(body.monitoredResources) && body.monitoredResources.length > 0) pipeline.monitoredResources = body.monitoredResources;
+      const projectError = validatePipelineProjects(pipeline);
+      if (projectError) return jsonReply(res, 400, { error: projectError });
       savePipeline(pipeline);
       invalidateStatusCache();
       return jsonReply(res, 200, { ok: true, id: pipeline.id });
@@ -8341,8 +8648,12 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       if (body.stages !== undefined) pipeline.stages = body.stages;
       if (body.trigger !== undefined) pipeline.trigger = body.trigger;
       if (body.enabled !== undefined) pipeline.enabled = body.enabled;
+      if (body.project !== undefined) pipeline.project = body.project;
+      if (body.projects !== undefined) pipeline.projects = body.projects;
       if (body.monitoredResources !== undefined) pipeline.monitoredResources = body.monitoredResources;
       if (body.stopWhen !== undefined) pipeline.stopWhen = body.stopWhen;
+      const projectError = validatePipelineProjects(pipeline);
+      if (projectError) return jsonReply(res, 400, { error: projectError });
       savePipeline(pipeline);
       invalidateStatusCache();
       return jsonReply(res, 200, { ok: true });
@@ -8686,6 +8997,11 @@ module.exports = {
   _shouldSuppressDocChatPostPatchError,
   _buildDocChatResponsePayload,
   _inferDocChatProject,
+  _messageHasDelegationIntent,
+  _messageRequestsDirectHandling,
+  _messageHasMediumLargeWorkIntent,
+  _inferDelegationActionFromMessage,
+  _ensureDelegationForIntent,
   _linkPullRequestForTracking: linkPullRequestForTracking,
   _resolveSkillReadPath,
   DOC_CHAT_DOCUMENT_DELIMITER,