@yemi33/minions 0.1.2424 → 0.1.2426

package/engine/plan-prd-validation.js

@@ -0,0 +1,745 @@
+'use strict';
+
+const path = require('path');
+const api = require('./api-validation');
+const shared = require('./shared');
+
+const COMPLEXITY_VALUES = Object.freeze(['small', 'medium', 'large']);
+const BRANCH_STRATEGY_VALUES = Object.freeze(['parallel', 'shared-branch']);
+const PLAN_STATUS_VALUES = Object.freeze(Object.values(shared.PLAN_STATUS));
+const PRD_ITEM_STATUS_VALUES = Object.freeze(Object.values(shared.PRD_ITEM_STATUS));
+const WORK_TYPE_VALUES = Object.freeze([...shared.VALID_WORK_TYPES]);
+
+const PLAN_ACTION_STATUSES = Object.freeze({
+  approve: new Set([
+    shared.PLAN_STATUS.ACTIVE,
+    shared.PLAN_STATUS.AWAITING_APPROVAL,
+    shared.PLAN_STATUS.APPROVED,
+    shared.PLAN_STATUS.PAUSED,
+    shared.PLAN_STATUS.COMPLETED,
+  ]),
+  pause: new Set([shared.PLAN_STATUS.ACTIVE, shared.PLAN_STATUS.APPROVED]),
+  reject: new Set([
+    shared.PLAN_STATUS.ACTIVE,
+    shared.PLAN_STATUS.AWAITING_APPROVAL,
+    shared.PLAN_STATUS.APPROVED,
+    shared.PLAN_STATUS.PAUSED,
+    shared.PLAN_STATUS.REVISION_REQUESTED,
+  ]),
+  regenerate: new Set([
+    shared.PLAN_STATUS.ACTIVE,
+    shared.PLAN_STATUS.APPROVED,
+    shared.PLAN_STATUS.PAUSED,
+    shared.PLAN_STATUS.COMPLETED,
+  ]),
+  revise: new Set([
+    shared.PLAN_STATUS.ACTIVE,
+    shared.PLAN_STATUS.AWAITING_APPROVAL,
+    shared.PLAN_STATUS.APPROVED,
+    shared.PLAN_STATUS.PAUSED,
+  ]),
+  discuss: new Set([
+    shared.PLAN_STATUS.AWAITING_APPROVAL,
+    shared.PLAN_STATUS.REVISION_REQUESTED,
+  ]),
+  'trigger-verify': new Set([shared.PLAN_STATUS.COMPLETED]),
+  'item-mutate': new Set([
+    shared.PLAN_STATUS.ACTIVE,
+    shared.PLAN_STATUS.AWAITING_APPROVAL,
+    shared.PLAN_STATUS.APPROVED,
+    shared.PLAN_STATUS.PAUSED,
+    shared.PLAN_STATUS.COMPLETED,
+    shared.PLAN_STATUS.REVISION_REQUESTED,
+  ]),
+});
+
+function inputError(message, options = {}) {
+  throw new api.ApiInputError(message, options);
+}
+
+function validateBody(body) {
+  return api.validatePlainObject(body, {
+    field: 'body',
+    path: 'body',
+    message: 'Request body must be a JSON object',
+  });
+}
+
+function validateNoQuery(req) {
+  const parsed = new URL(req?.url || '/', 'http://localhost');
+  const names = [...new Set(parsed.searchParams.keys())];
+  if (names.length > 0) {
+    inputError(`This endpoint does not accept query parameters: ${names.join(', ')}`, {
+      code: 'unexpected-query',
+      field: names[0],
+      path: `query.${names[0]}`,
+      rejectedValue: parsed.search,
+    });
+  }
+}
+
+function fullyDecode(value, field) {
+  let decoded = value;
+  for (let depth = 0; depth < 8; depth += 1) {
+    let next;
+    try {
+      next = decodeURIComponent(decoded);
+    } catch (cause) {
+      inputError(`${field} contains malformed percent encoding`, {
+        code: 'invalid-artifact-name',
+        field,
+        path: field,
+        rejectedValue: value,
+        cause,
+      });
+    }
+    if (next === decoded) return decoded;
+    decoded = next;
+  }
+  inputError(`${field} contains excessive nested percent encoding`, {
+    code: 'invalid-artifact-name',
+    field,
+    path: field,
+    rejectedValue: value,
+  });
+}
+
+function unsafeBasename(value) {
+  return value === '.' || value === '..'
+    || value.includes('..')
+    || value.includes('/')
+    || value.includes('\\')
+    || value.includes('\0')
+    || value.includes(':')
+    || path.basename(value) !== value;
+}
+
+function validateArtifactName(value, options = {}) {
+  const field = options.field || 'file';
+  const raw = api.validateString(value, {
+    field,
+    path: field,
+    allowEmpty: false,
+    maxLength: 255,
+    message: `${field} must be a non-empty artifact basename`,
+  });
+  if (raw !== raw.trim()) {
+    inputError(`${field} must not contain leading or trailing whitespace`, {
+      code: 'invalid-artifact-name',
+      field,
+      path: field,
+      rejectedValue: value,
+    });
+  }
+  const decoded = fullyDecode(raw, field);
+  if (unsafeBasename(decoded) || unsafeBasename(raw)) {
+    inputError(`${field} must be a safe basename without traversal or path separators`, {
+      code: 'invalid-artifact-name',
+      field,
+      path: field,
+      rejectedValue: value,
+    });
+  }
+  const result = options.decode === true ? decoded : raw;
+  const extensions = Array.isArray(options.extensions) ? options.extensions : [];
+  if (extensions.length > 0 && !extensions.some(extension => result.endsWith(extension))) {
+    inputError(`${field} must end with ${extensions.join(' or ')}`, {
+      code: 'invalid-artifact-extension',
+      field,
+      path: field,
+      rejectedValue: value,
+      allowedValues: extensions,
+    });
+  }
+  return result;
+}
+
+function validatePrdFilename(value, options = {}) {
+  return validateArtifactName(value, {
+    ...options,
+    extensions: ['.json'],
+  });
+}
+
+function validatePlanFilename(value, options = {}) {
+  return validateArtifactName(value, {
+    ...options,
+    extensions: ['.md'],
+  });
+}
+
+function validatePlanArtifactFilename(value, options = {}) {
+  return validateArtifactName(value, {
+    ...options,
+    extensions: ['.md', '.json'],
+  });
+}
+
+function validateItemIdentifier(value, options = {}) {
+  const field = options.field || 'itemId';
+  const normalized = api.validateIdentifier(value, {
+    field,
+    path: field,
+    trim: true,
+    maxLength: 128,
+    pattern: /^[A-Za-z0-9][A-Za-z0-9._:-]*$/,
+    optional: options.optional === true,
+    message: `${field} must be a safe item identifier`,
+  });
+  if (normalized !== undefined && normalized.includes('..')) {
+    inputError(`${field} must not contain traversal segments`, {
+      code: 'invalid-identifier',
+      field,
+      path: field,
+      rejectedValue: value,
+    });
+  }
+  return normalized;
+}
+
+function validateOptionalString(value, field, options = {}) {
+  return api.validateString(value, {
+    field,
+    path: field,
+    optional: true,
+    trim: options.trim === true,
+    allowEmpty: options.allowEmpty !== false,
+    maxLength: options.maxLength || 100000,
+    message: `${field} must be a string`,
+  });
+}
+
+function validateRequiredString(value, field, options = {}) {
+  return api.validateString(value, {
+    field,
+    path: field,
+    trim: options.trim !== false,
+    allowEmpty: false,
+    maxLength: options.maxLength || 100000,
+    message: `${field} is required and must be a non-empty string`,
+  });
+}
+
+function validateOptionalBoolean(value, field) {
+  return api.validateBoolean(value, {
+    field,
+    path: field,
+    optional: true,
+  });
+}
+
+function validatePriority(value) {
+  const error = shared.validateWorkItemPriority(value);
+  if (!error) return value;
+  inputError(error.error, {
+    code: error.code,
+    field: 'priority',
+    path: 'priority',
+    rejectedValue: error.rejectedValue,
+    allowedValues: error.allowedValues,
+  });
+}
+
+function resolveProject(value, projects, options = {}) {
+  const field = options.field || 'project';
+  const projectValue = validateRequiredString(value, field, { maxLength: 512 });
+  const resolved = shared.resolveProjectSource(projectValue, projects, {
+    allowCentral: false,
+    minionsDir: options.minionsDir,
+  });
+  if (!resolved.project || resolved.error) {
+    inputError(resolved.error || `Project "${projectValue}" is not configured`, {
+      code: 'invalid-project',
+      field,
+      path: field,
+      rejectedValue: value,
+    });
+  }
+  return resolved.project.name;
+}
+
+function normalizeProjectSelection(value, projects, options = {}) {
+  const field = options.field || 'project';
+  if (value === undefined || value === null || value === '') return [];
+  const rawValues = Array.isArray(value) ? value : [value];
+  if (Array.isArray(value) && options.allowArray === false) {
+    inputError(`${field} must be a project string`, {
+      code: 'invalid-project',
+      field,
+      path: field,
+      rejectedValue: value,
+      expected: 'string',
+    });
+  }
+  const names = [];
+  rawValues.forEach((entry, index) => {
+    if (typeof entry !== 'string' || !entry.trim()) {
+      inputError(`${field}[${index}] must be a non-empty project string`, {
+        code: 'invalid-project',
+        field,
+        path: [field, index],
+        rejectedValue: entry,
+      });
+    }
+    const name = resolveProject(entry, projects, {
+      field: Array.isArray(value) ? `${field}[${index}]` : field,
+      minionsDir: options.minionsDir,
+    });
+    if (!names.includes(name)) names.push(name);
+  });
+  return names;
+}
+
+function parseProjectList(raw, label, projects, options = {}) {
+  const parts = String(raw).split(/[,|;]/);
+  if (parts.length < 2 || parts.some(part => !part.trim())) {
+    inputError(`${label} must declare at least two non-empty projects`, {
+      code: 'invalid-project-declaration',
+      field: label,
+      path: label,
+      rejectedValue: raw,
+    });
+  }
+  const names = normalizeProjectSelection(
+    parts.map(part => part.trim().replace(/^["'`]+|["'`]+$/g, '').trim()),
+    projects,
+    { field: label, allowArray: true, minionsDir: options.minionsDir },
+  );
+  if (names.length < 2) {
+    inputError(`${label} must resolve to at least two distinct projects`, {
+      code: 'invalid-project-declaration',
+      field: label,
+      path: label,
+      rejectedValue: raw,
+    });
+  }
+  return names;
+}
+
+function sameList(left, right) {
+  return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+
+function validatePlanProjectDeclarations(content, projects, options = {}) {
+  const text = api.validateString(content, {
+    field: options.field || 'content',
+    path: options.field || 'content',
+    allowEmpty: false,
+    maxLength: 1000000,
+  });
+  const markerTokens = text.match(/minions:targetProjects/gi) || [];
+  const markerMatches = [...text.matchAll(/<!--\s*minions:targetProjects\s*=\s*([^>]*?)\s*-->/gi)];
+  if (markerTokens.length !== markerMatches.length || markerMatches.length > 1) {
+    inputError('Plan contains a malformed or duplicate minions:targetProjects declaration', {
+      code: 'invalid-project-declaration',
+      field: 'targetProjects',
+      path: 'content.targetProjects',
+    });
+  }
+
+  const headerLines = text.split(/\r?\n/).slice(0, 80).map(line => (
+    line.replace(/^\s*[-*]\s+/, '').replace(/\*\*/g, '').trim()
+  ));
+  const pluralMatches = headerLines
+    .map(line => line.match(/^Projects\s*:\s*(.*)$/i))
+    .filter(Boolean);
+  const singularMatches = headerLines
+    .map(line => line.match(/^Project\s*:\s*(.*)$/i))
+    .filter(Boolean);
+  if (pluralMatches.length > 1 || singularMatches.length > 1) {
+    inputError('Plan contains duplicate project declarations', {
+      code: 'invalid-project-declaration',
+      field: 'project',
+      path: 'content.project',
+    });
+  }
+
+  const markerProjects = markerMatches.length
+    ? parseProjectList(markerMatches[0][1], 'targetProjects', projects, options)
+    : [];
+  const pluralProjects = pluralMatches.length
+    ? parseProjectList(pluralMatches[0][1].replace(/\s+#.*$/, '').trim(), 'projects', projects, options)
+    : [];
+  if (markerProjects.length && pluralProjects.length && !sameList(markerProjects, pluralProjects)) {
+    inputError('Plan targetProjects marker and Projects header must declare the same projects in the same order', {
+      code: 'conflicting-project-declaration',
+      field: 'project',
+      path: 'content.project',
+    });
+  }
+  const targetProjects = markerProjects.length ? markerProjects : pluralProjects;
+
+  let declaredProject = '';
+  if (singularMatches.length) {
+    const raw = singularMatches[0][1].replace(/\s+#.*$/, '').trim()
+      .replace(/^["'`]+|["'`]+$/g, '').trim();
+    if (!raw) {
+      inputError('Project declaration must name a configured project', {
+        code: 'invalid-project-declaration',
+        field: 'project',
+        path: 'content.project',
+      });
+    }
+    declaredProject = resolveProject(raw, projects, {
+      field: 'project',
+      minionsDir: options.minionsDir,
+    });
+  }
+  if (declaredProject && targetProjects.length) {
+    inputError('Plan cannot contain both singular Project and cross-repo Projects declarations', {
+      code: 'conflicting-project-declaration',
+      field: 'project',
+      path: 'content.project',
+    });
+  }
+  return { declaredProject, targetProjects };
+}
+
+function validateProjectSelectionAgreement(selection, declarations) {
+  if (!selection.length) return;
+  const declared = declarations.targetProjects.length
+    ? declarations.targetProjects
+    : (declarations.declaredProject ? [declarations.declaredProject] : []);
+  if (declared.length && !sameList(selection, declared)) {
+    inputError('Request project selection conflicts with the project declaration in plan content', {
+      code: 'conflicting-project-declaration',
+      field: 'project',
+      path: 'project',
+      rejectedValue: selection,
+      allowedValues: declared,
+    });
+  }
+}
+
+function validateAgent(value, agents) {
+  if (value === undefined || value === null || value === '') return '';
+  const agent = validateRequiredString(value, 'agent', { maxLength: 128 });
+  if (!agents || !Object.prototype.hasOwnProperty.call(agents, agent)) {
+    inputError(`Unknown agent "${agent}"`, {
+      code: 'invalid-agent',
+      field: 'agent',
+      path: 'agent',
+      rejectedValue: value,
+      allowedValues: Object.keys(agents || {}),
+    });
+  }
+  return agent;
+}
+
+function validateBranchStrategy(body) {
+  const snake = body.branch_strategy;
+  const camel = body.branchStrategy;
+  if (snake !== undefined && camel !== undefined && snake !== camel) {
+    inputError('branch_strategy and branchStrategy must match when both are supplied', {
+      code: 'conflicting-aliases',
+      field: 'branchStrategy',
+      path: 'branchStrategy',
+    });
+  }
+  const value = snake !== undefined ? snake : camel;
+  if (value === undefined) return undefined;
+  return api.validateEnum(value, {
+    field: 'branchStrategy',
+    path: snake !== undefined ? 'branch_strategy' : 'branchStrategy',
+    values: [...BRANCH_STRATEGY_VALUES],
+  });
+}
+
+function validatePlanWorkItemRequest(body, options = {}) {
+  validateBody(body);
+  const title = validateRequiredString(body.title, 'title', { maxLength: 500 });
+  const description = validateOptionalString(body.description, 'description');
+  validatePriority(body.priority);
+  const projectNames = normalizeProjectSelection(body.project, options.projects || [], {
+    field: 'project',
+    minionsDir: options.minionsDir,
+  });
+  const agent = validateAgent(body.agent, options.agents || {});
+  const branchStrategy = validateBranchStrategy(body);
+  return {
+    ...body,
+    title,
+    ...(description !== undefined ? { description } : {}),
+    project: Array.isArray(body.project) ? projectNames : (projectNames[0] || ''),
+    ...(agent ? { agent } : {}),
+    ...(branchStrategy ? { branchStrategy, branch_strategy: branchStrategy } : {}),
+  };
+}
+
+function validatePlanFileCreateRequest(body, options = {}) {
+  validateBody(body);
+  const title = validateRequiredString(body.title, 'title', { maxLength: 500 });
+  const content = validateRequiredString(body.content, 'content', {
+    trim: false,
+    maxLength: 1000000,
+  });
+  const meetingId = validateItemIdentifier(body.meetingId, {
+    field: 'meetingId',
+    optional: true,
+  });
+  const projectNames = normalizeProjectSelection(body.project, options.projects || [], {
+    field: 'project',
+    minionsDir: options.minionsDir,
+  });
+  const declarations = validatePlanProjectDeclarations(content, options.projects || [], options);
+  validateProjectSelectionAgreement(projectNames, declarations);
+  return {
+    ...body,
+    title,
+    content,
+    projectNames,
+    declarations,
+    ...(meetingId ? { meetingId } : {}),
+  };
+}
+
+function validatePlanExecuteRequest(body, options = {}) {
+  validateBody(body);
+  const file = validatePlanFilename(body.file);
+  const feedback = validateOptionalString(body.feedback, 'feedback', {
+    trim: true,
+    maxLength: 100000,
+  });
+  const projectNames = normalizeProjectSelection(body.project, options.projects || [], {
+    field: 'project',
+    allowArray: false,
+    minionsDir: options.minionsDir,
+  });
+  return {
+    ...body,
+    file,
+    feedback: feedback || '',
+    project: projectNames[0] || '',
+  };
+}
+
+function validatePlanActionRequest(body, options = {}) {
+  validateBody(body);
+  const field = options.field || 'file';
+  let file;
+  if (options.extension === '.md') {
+    file = validatePlanFilename(body[field], { field });
+  } else if (options.extension === '.json') {
+    file = validatePrdFilename(body[field], { field });
+  } else {
+    file = validatePlanArtifactFilename(body[field], { field });
+  }
+  const normalized = { ...body, [field]: file };
+  for (const stringField of options.optionalStrings || []) {
+    const value = validateOptionalString(body[stringField], stringField, {
+      trim: options.trimStrings?.includes(stringField),
+      maxLength: 100000,
+    });
+    if (value !== undefined) normalized[stringField] = value;
+  }
+  for (const booleanField of options.optionalBooleans || []) {
+    const value = validateOptionalBoolean(body[booleanField], booleanField);
+    if (value !== undefined) normalized[booleanField] = value;
+  }
+  if (normalized.forceRegen === true && normalized.skipRegen === true) {
+    inputError('forceRegen and skipRegen cannot both be true', {
+      code: 'incompatible-options',
+      field: 'forceRegen',
+      path: 'forceRegen',
+    });
+  }
+  return normalized;
+}
+
+function explicitWorkType(body) {
+  const fields = ['type', 'workType', 'work_type'].filter(field => body[field] !== undefined);
+  if (fields.length === 0) return undefined;
+  const values = fields.map(field => validateRequiredString(body[field], field, { maxLength: 64 }));
+  if (!values.every(value => value === values[0])) {
+    inputError('type, workType, and work_type must match when multiple aliases are supplied', {
+      code: 'conflicting-aliases',
+      field: 'type',
+      path: 'type',
+    });
+  }
+  const candidate = values[0];
+  const resolved = shared.resolveWorkItemTypeFromPrdItem({ type: candidate });
+  if (!shared.VALID_WORK_TYPES.has(candidate) || resolved !== candidate) {
+    inputError(`type must be one of: ${WORK_TYPE_VALUES.join(', ')}`, {
+      code: 'invalid-work-type',
+      field: 'type',
+      path: fields[0],
+      rejectedValue: candidate,
+      allowedValues: [...WORK_TYPE_VALUES],
+    });
+  }
+  return resolved;
+}
+
+function validatePrdItemRequest(body, options = {}) {
+  validateBody(body);
+  const mode = options.mode || 'create';
+  const normalized = { ...body };
+  if (mode === 'create') {
+    normalized.name = validateRequiredString(body.name, 'name', { maxLength: 500 });
+    normalized.id = validateItemIdentifier(body.id, { field: 'id', optional: true });
+    if (body.source !== undefined) normalized.source = validatePrdFilename(body.source, { field: 'source' });
+  } else {
+    normalized.source = validatePrdFilename(body.source, { field: 'source' });
+    normalized.itemId = validateItemIdentifier(body.itemId, { field: 'itemId' });
+    if (mode === 'update' && body.name !== undefined) {
+      normalized.name = validateRequiredString(body.name, 'name', { maxLength: 500 });
+    }
+  }
+  if (body.description !== undefined) {
+    normalized.description = validateOptionalString(body.description, 'description');
+  }
+  validatePriority(body.priority);
+  if (body.estimated_complexity !== undefined) {
+    normalized.estimated_complexity = api.validateEnum(body.estimated_complexity, {
+      field: 'estimated_complexity',
+      path: 'estimated_complexity',
+      values: [...COMPLEXITY_VALUES],
+    });
+  }
+  if (body.status !== undefined) {
+    normalized.status = api.validateEnum(body.status, {
+      field: 'status',
+      path: 'status',
+      values: [...PRD_ITEM_STATUS_VALUES],
+    });
+  }
+  const type = explicitWorkType(body);
+  if (type !== undefined) normalized.type = type;
+
+  if (body.project !== undefined) {
+    const names = normalizeProjectSelection(body.project, options.projects || [], {
+      field: 'project',
+      allowArray: false,
+      minionsDir: options.minionsDir,
+    });
+    normalized.project = names[0] || '';
+  }
+  const itemProjectValue = body.item_project !== undefined ? body.item_project : body.itemProject;
+  if (mode !== 'create' && itemProjectValue !== undefined) {
+    inputError('item_project is only supported when creating a PRD item', {
+      code: 'unsupported-field',
+      field: body.item_project !== undefined ? 'item_project' : 'itemProject',
+      path: body.item_project !== undefined ? 'item_project' : 'itemProject',
+      rejectedValue: itemProjectValue,
+    });
+  }
+  if (body.item_project !== undefined && body.itemProject !== undefined
+      && body.item_project !== body.itemProject) {
+    inputError('item_project and itemProject must match when both are supplied', {
+      code: 'conflicting-aliases',
+      field: 'itemProject',
+      path: 'itemProject',
+    });
+  }
+  if (itemProjectValue !== undefined) {
+    const names = normalizeProjectSelection(itemProjectValue, options.projects || [], {
+      field: 'item_project',
+      allowArray: false,
+      minionsDir: options.minionsDir,
+    });
+    normalized.item_project = names[0] || '';
+    normalized.itemProject = names[0] || '';
+  }
+  return normalized;
+}
+
+function effectivePlanStatus(plan, options = {}) {
+  if (!plan || typeof plan !== 'object' || Array.isArray(plan)) {
+    inputError('PRD record is malformed', {
+      code: 'invalid-plan-state',
+      statusCode: 409,
+    });
+  }
+  if (options.physicallyArchived || shared.isPrdArchived(plan)) return 'archived';
+  const status = plan.status || (
+    plan.requires_approval && !plan.approvedAt
+      ? shared.PLAN_STATUS.AWAITING_APPROVAL
+      : shared.PLAN_STATUS.ACTIVE
+  );
+  if (!PLAN_STATUS_VALUES.includes(status)) {
+    inputError(`PRD has invalid status "${status}"`, {
+      code: 'invalid-plan-state',
+      statusCode: 409,
+      field: 'status',
+      path: 'status',
+      rejectedValue: status,
+      allowedValues: [...PLAN_STATUS_VALUES],
+    });
+  }
+  return status;
+}
+
+function assertPlanAction(plan, action, options = {}) {
+  const status = effectivePlanStatus(plan, options);
+  if (action === 'archive') {
+    if (status !== 'archived') return status;
+  } else if (action === 'unarchive') {
+    if (status === 'archived') return status;
+  } else {
+    const allowed = PLAN_ACTION_STATUSES[action];
+    if (!allowed) throw new TypeError(`Unknown plan action: ${action}`);
+    if (allowed.has(status)) return status;
+  }
+  inputError(`Cannot ${action} a PRD in "${status}" state`, {
+    code: 'invalid-plan-transition',
+    statusCode: 409,
+    field: 'status',
+    path: 'status',
+    rejectedValue: status,
+    allowedValues: action === 'unarchive' ? ['archived'] : [...(PLAN_ACTION_STATUSES[action] || [])],
+  });
+}
+
+function validatePrdProjects(plan, projects, options = {}) {
+  const references = [];
+  if (plan?.project) references.push({ value: plan.project, path: 'project' });
+  for (let index = 0; index < (Array.isArray(plan?.missing_features) ? plan.missing_features.length : 0); index += 1) {
+    const project = plan.missing_features[index]?.project;
+    if (project) references.push({ value: project, path: `missing_features[${index}].project` });
+  }
+  const names = [];
+  for (const reference of references) {
+    const name = resolveProject(reference.value, projects, {
+      field: reference.path,
+      minionsDir: options.minionsDir,
+    });
+    if (!names.includes(name)) names.push(name);
+  }
+  return names;
+}
+
+function validateSourcePlanName(plan) {
+  if (!plan?.source_plan) return '';
+  return validatePlanFilename(shared.sourcePlanKey(plan.source_plan), {
+    field: 'source_plan',
+  });
+}
+
+module.exports = {
+  COMPLEXITY_VALUES,
+  BRANCH_STRATEGY_VALUES,
+  PLAN_STATUS_VALUES,
+  PRD_ITEM_STATUS_VALUES,
+  WORK_TYPE_VALUES,
+  validateBody,
+  validateNoQuery,
+  validateArtifactName,
+  validatePrdFilename,
+  validatePlanFilename,
+  validatePlanArtifactFilename,
+  validateItemIdentifier,
+  validatePriority,
+  normalizeProjectSelection,
+  validatePlanProjectDeclarations,
+  validateProjectSelectionAgreement,
+  validatePlanWorkItemRequest,
+  validatePlanFileCreateRequest,
+  validatePlanExecuteRequest,
+  validatePlanActionRequest,
+  validatePrdItemRequest,
+  effectivePlanStatus,
+  assertPlanAction,
+  validatePrdProjects,
+  validateSourcePlanName,
+};