@yemi33/minions 0.1.1809 → 0.1.1810

package/dashboard.js

@@ -369,14 +369,11 @@ 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) {
@@ -394,6 +391,47 @@ function resolveWorkItemsCreateTarget(projectName, projects = PROJECTS) {
   };
 }
 
+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;
+}
+
 /**
  * Aggregate archived work items from the central archive plus every project
  * archive. Each item is tagged with `_source` (`'central'` or the project name)
@@ -425,12 +463,17 @@ 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);
+  let targetProject = explicitProjectName ? findProjectByName(projects, explicitProjectName) : null;
   if (explicitProjectName && !targetProject) {
     const err = new Error(formatUnknownProjectError(explicitProjectName, projects));
     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 prPath = targetProject ? shared.projectPrPath(targetProject) : path.join(MINIONS_DIR, 'pull-requests.json');
 
   const prNumMatch = url.match(/\/pull\/(\d+)|pullrequest\/(\d+)/);
@@ -1814,8 +1857,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 +1873,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 +1906,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 +1936,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 +2001,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 +2097,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 +2728,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 +3075,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 || '';
@@ -2827,7 +3142,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,
@@ -3054,7 +3369,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 [];
@@ -3855,8 +4170,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,
@@ -4750,6 +5066,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 +5077,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 +5088,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 +5097,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 || (PROJECTS.length > 0 ? PROJECTS[0].name : 'Unknown'),
         generated_by: 'dashboard',
         generated_at: new Date().toISOString().slice(0, 10),
         plan_summary: body.name,
@@ -6088,15 +6408,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 +6506,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({
@@ -6713,13 +7037,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 +7046,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 +7370,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 +7377,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 +7444,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 +7479,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 +7546,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;
@@ -8325,8 +8658,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 +8678,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 +9027,11 @@ module.exports = {
   _shouldSuppressDocChatPostPatchError,
   _buildDocChatResponsePayload,
   _inferDocChatProject,
+  _messageHasDelegationIntent,
+  _messageRequestsDirectHandling,
+  _messageHasMediumLargeWorkIntent,
+  _inferDelegationActionFromMessage,
+  _ensureDelegationForIntent,
   _linkPullRequestForTracking: linkPullRequestForTracking,
   _resolveSkillReadPath,
   DOC_CHAT_DOCUMENT_DELIMITER,