qa-flowkit 0.4.0-alpha.0

package/.qa-ai/scripts/validate-features.mjs

@@ -0,0 +1,277 @@
+#!/usr/bin/env node
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import {
+  getConfigValue,
+  listFilesRecursive,
+  loadQaAiConfig,
+  logHeader,
+  parseArgs,
+  relativeTo,
+  resolveRepoPath
+} from './lib/utils.mjs';
+
+const cwd = process.cwd();
+const args = parseArgs(process.argv);
+const rfPattern = /\bRF[-_ ]?[A-Z0-9]+\b/i;
+const idPattern = /\b(?:RF|TC|TEST|QA)[-_ ]?[A-Z0-9]+\b/gi;
+const caseIdPattern = /\b(?:TC|TEST|QA)[-_ ]?[A-Z0-9]+\b/gi;
+
+function printHelp() {
+  console.log(`Usage: node .qa-ai/scripts/validate-features.mjs [options]
+
+Options:
+  --path <dir>   Override the configured feature root
+  --gherkin-language <en|es> Override the configured Gherkin language
+  --allow-empty  Return success when no .feature files exist
+  --no-duplicates Skip cross-file duplicate ID validation
+  --help         Show this help
+`);
+}
+
+function requiredTagName(tag) {
+  const normalized = String(tag).trim();
+  if (!normalized) return '';
+  const withPrefix = normalized.startsWith('@') ? normalized : `@${normalized}`;
+  return withPrefix.replace(/:$/, '');
+}
+
+function findLine(content, prefix) {
+  return content.split(/\r?\n/).find((line) => line.trim().toLowerCase().startsWith(prefix.toLowerCase())) || '';
+}
+
+function normalizeLanguage(value) {
+  const normalized = String(value || '').trim().toLowerCase();
+  if (['es', 'esp', 'spa', 'spanish', 'espanol', 'espa\u00f1ol'].includes(normalized)) return 'es';
+  return 'en';
+}
+
+function languageRules(language) {
+  if (language === 'es') {
+    return {
+      code: 'es',
+      featurePattern: /^(?:Caracter\u00edstica|Caracteristica):/i,
+      scenarioPattern: /^(?:Escenario|Esquema del escenario):/i,
+      featurePrefixes: ['Caracter\u00edstica:', 'Caracteristica:'],
+      scenarioPrefixes: ['Escenario:', 'Esquema del escenario:'],
+      acceptancePattern: /^Criterios de aceptaci\u00f3n:/i,
+      acceptanceLabel: 'Criterios de aceptaci\u00f3n'
+    };
+  }
+  return {
+    code: 'en',
+    featurePattern: /^Feature:/i,
+    scenarioPattern: /^Scenario(?: Outline)?:/i,
+    featurePrefixes: ['Feature:'],
+    scenarioPrefixes: ['Scenario:', 'Scenario Outline:'],
+    acceptancePattern: /^Acceptance Criteria:/i,
+    acceptanceLabel: 'Acceptance Criteria'
+  };
+}
+
+function findAnyLine(content, prefixes) {
+  for (const prefix of prefixes) {
+    const line = findLine(content, prefix);
+    if (line) return line;
+  }
+  return '';
+}
+
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function hasRequiredTag(content, tagName) {
+  const pattern = new RegExp(`(?:^|\\s)${escapeRegExp(tagName)}:[^\\s]+`, 'm');
+  return pattern.test(content);
+}
+
+function normalizeId(value) {
+  return String(value || '').replace(/\s+/g, '-').toUpperCase();
+}
+
+function idsFromText(value) {
+  return [...String(value || '').matchAll(idPattern)].map((match) => normalizeId(match[0]));
+}
+
+function caseIdsFromText(value) {
+  return [...String(value || '').matchAll(caseIdPattern)].map((match) => normalizeId(match[0]));
+}
+
+function caseIdsFromTags(model) {
+  const caseTagPattern = /^@(?:id|test|case|testrail):(.+)$/i;
+  return model.tags
+    .map(({ tag }) => tag.match(caseTagPattern)?.[1])
+    .filter(Boolean)
+    .map(normalizeId);
+}
+
+function parseFeature(content, language) {
+  const rules = languageRules(language);
+  const model = {
+    languageLine: '',
+    featureLines: [],
+    scenarioLines: [],
+    acceptanceLines: [],
+    tags: []
+  };
+
+  const lines = content.split(/\r?\n/);
+  for (let index = 0; index < lines.length; index += 1) {
+    const trimmed = lines[index].trim();
+    if (!trimmed) continue;
+    const line = index + 1;
+
+    if (trimmed.toLowerCase().startsWith('# language:')) {
+      model.languageLine = trimmed;
+      continue;
+    }
+    if (trimmed.startsWith('@')) {
+      for (const tag of trimmed.split(/\s+/).filter(Boolean)) model.tags.push({ line, tag });
+      continue;
+    }
+    if (rules.featurePattern.test(trimmed)) {
+      model.featureLines.push({ line, text: trimmed });
+      continue;
+    }
+    if (rules.scenarioPattern.test(trimmed)) {
+      model.scenarioLines.push({ line, text: trimmed });
+      continue;
+    }
+    if (rules.acceptancePattern.test(trimmed)) {
+      model.acceptanceLines.push({ line, text: trimmed });
+    }
+  }
+
+  return model;
+}
+
+function hasRequiredParsedTag(model, tagName) {
+  const prefix = `${tagName}:`;
+  return model.tags.some(({ tag }) => tag.toLowerCase().startsWith(prefix.toLowerCase()) && tag.length > prefix.length);
+}
+
+function validate(content, file, requiredTags, language) {
+  const errors = [];
+  const rules = languageRules(language);
+  const parsed = parseFeature(content, language);
+  const featureLine = parsed.featureLines[0]?.text || findAnyLine(content, rules.featurePrefixes);
+  const scenarioLine = parsed.scenarioLines[0]?.text || findAnyLine(content, rules.scenarioPrefixes);
+  const languageLine = parsed.languageLine || findLine(content, '# language:');
+
+  if (languageLine && !new RegExp(`#\\s*language:\\s*${rules.code}\\b`, 'i').test(languageLine)) {
+    errors.push(`Feature declares a Gherkin language that does not match configured language "${rules.code}".`);
+  }
+  if (rules.code === 'es' && !languageLine) {
+    errors.push('Spanish Gherkin files must declare "# language: es".');
+  }
+  if (parsed.featureLines.length !== 1) errors.push(`Expected exactly one Feature title, found ${parsed.featureLines.length}.`);
+  if (parsed.scenarioLines.length !== 1) errors.push(`Expected exactly one Scenario, found ${parsed.scenarioLines.length}.`);
+  if (parsed.acceptanceLines.length === 0) errors.push(`Missing ${rules.acceptanceLabel}.`);
+
+  for (const tag of requiredTags.map(requiredTagName).filter(Boolean)) {
+    if (!hasRequiredParsedTag(parsed, tag) && !hasRequiredTag(content, tag)) {
+      errors.push(`Missing required tag value ${tag}:<value>`);
+    }
+  }
+
+  if (featureLine && !rfPattern.test(featureLine)) errors.push('Feature title does not contain an RF-like ID.');
+  if (scenarioLine && !rfPattern.test(scenarioLine)) errors.push('Scenario title does not contain an RF-like ID.');
+  if (!rfPattern.test(path.basename(file))) errors.push('Feature filename does not contain an RF-like ID.');
+
+  return {
+    errors,
+    ids: [...new Set([
+      ...idsFromText(path.basename(file, '.feature')),
+      ...idsFromText(featureLine),
+      ...idsFromText(scenarioLine)
+    ])].sort(),
+    caseIds: [...new Set([
+      ...caseIdsFromText(path.basename(file, '.feature')),
+      ...caseIdsFromTags(parsed)
+    ])].sort()
+  };
+}
+
+function duplicateIdErrors(results) {
+  const byId = new Map();
+  for (const result of results) {
+    for (const id of result.caseIds) {
+      const current = byId.get(id) || [];
+      current.push(result.file);
+      byId.set(id, current);
+    }
+  }
+
+  const errors = [];
+  for (const [id, files] of byId.entries()) {
+    const uniqueFiles = [...new Set(files)];
+    if (uniqueFiles.length > 1) {
+      errors.push(`Duplicate test case identifier ${id} appears in: ${uniqueFiles.map((file) => relativeTo(cwd, file)).join(', ')}`);
+    }
+  }
+  return errors;
+}
+
+async function main() {
+  if (args.help) {
+    printHelp();
+    return;
+  }
+
+  logHeader('QA AI feature validator');
+  const configInfo = await loadQaAiConfig(cwd);
+  const featureRoot = args.path || getConfigValue(configInfo.data, 'gherkin.featurePath', 'features');
+  const language = normalizeLanguage(args['gherkin-language'] || args.gherkinLanguage || args.gherkin || getConfigValue(configInfo.data, 'gherkin.language', 'en'));
+  const requiredTags = getConfigValue(configInfo.data, 'gherkin.tags.required', ['priority', 'type', 'manual']);
+  const tagNames = Array.isArray(requiredTags) && requiredTags.length > 0 ? requiredTags : ['priority', 'type', 'manual'];
+  const featureRootPath = resolveRepoPath(cwd, featureRoot, { label: 'feature root' });
+  const files = await listFilesRecursive(featureRootPath, (filePath) => filePath.endsWith('.feature'));
+
+  if (files.length === 0) {
+    console.log(`No .feature files found under ${featureRoot}.`);
+    if (!args['allow-empty']) {
+      console.log('\nFAILED - no feature files found. Pass --allow-empty when this is expected.');
+      process.exit(1);
+    }
+    return;
+  }
+
+  let totalErrors = 0;
+  const results = [];
+  for (const file of files) {
+    const content = await fs.readFile(file, 'utf8');
+    const result = {
+      file,
+      ...validate(content, file, tagNames, language)
+    };
+    results.push(result);
+    if (result.errors.length === 0) {
+      console.log(`[PASS] ${relativeTo(cwd, file)}`);
+    } else {
+      totalErrors += result.errors.length;
+      console.log(`[FAIL] ${relativeTo(cwd, file)}`);
+      for (const error of result.errors) console.log(`  - ${error}`);
+    }
+  }
+
+  if (!args['no-duplicates']) {
+    const duplicateErrors = duplicateIdErrors(results);
+    if (duplicateErrors.length > 0) {
+      totalErrors += duplicateErrors.length;
+      console.log('[FAIL] Duplicate identifier validation');
+      for (const error of duplicateErrors) console.log(`  - ${error}`);
+    }
+  }
+
+  if (totalErrors > 0) {
+    console.log(`\nFAILED - ${totalErrors} validation errors.`);
+    process.exit(1);
+  }
+  console.log('\nVALID - all feature files passed.');
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/.qa-ai/scripts/validate-release-gate.mjs

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+import path from 'node:path';
+import { validateReleaseGateData } from './lib/release-gate.mjs';
+import {
+  getConfigValue,
+  loadQaAiConfig,
+  logHeader,
+  parseArgs,
+  parseSimpleYaml,
+  pathExists,
+  readText,
+  resolveRepoPath
+} from './lib/utils.mjs';
+
+const cwd = process.cwd();
+const args = parseArgs(process.argv);
+
+function printHelp() {
+  console.log(`Usage: node .qa-ai/scripts/validate-release-gate.mjs [options]
+
+Options:
+  --path <file>       Override release gate file path
+  --allow-missing     Return success when the gate file is missing
+  --allow-pending     Allow decision: PENDING (draft gates only)
+  --help              Show this help
+
+Validates qa-ai-output/release-gate.yaml shape and decision rules.
+`);
+}
+
+export async function validateReleaseGateFile(cwd, filePath, options = {}) {
+  const gatePath = resolveRepoPath(cwd, filePath, { label: 'release gate' });
+  if (!await pathExists(gatePath)) {
+    if (options.allowMissing) {
+      return { ok: true, skipped: true, path: filePath };
+    }
+    return { ok: false, errors: [`Release gate not found at ${filePath}.`] };
+  }
+
+  let data;
+  try {
+    data = parseSimpleYaml(await readText(gatePath));
+  } catch (error) {
+    return { ok: false, errors: [`${filePath} is not valid YAML: ${error.message}`] };
+  }
+
+  const result = validateReleaseGateData(data, {
+    source: filePath,
+    allowPending: Boolean(options.allowPending)
+  });
+  const errors = [...result.errors];
+
+  for (const relPath of result.evidence || []) {
+    if (!relPath || relPath.includes('..')) {
+      errors.push(`${filePath}: invalid evidence_paths entry "${relPath}".`);
+      continue;
+    }
+    if (!await pathExists(resolveRepoPath(cwd, relPath, { label: 'evidence path' }))) {
+      errors.push(`${filePath}: evidence_paths entry not found: ${relPath}`);
+    }
+  }
+
+  return {
+    ok: errors.length === 0,
+    skipped: false,
+    path: filePath,
+    decision: result.decision,
+    errors
+  };
+}
+
+async function main() {
+  if (args.help) {
+    printHelp();
+    return;
+  }
+
+  logHeader('QA AI release gate validator');
+  const configInfo = await loadQaAiConfig(cwd);
+  const gatePath = args.path
+    || getConfigValue(configInfo.data, 'release.gatePath', 'qa-ai-output/release-gate.yaml');
+
+  const result = await validateReleaseGateFile(cwd, gatePath, {
+    allowMissing: Boolean(args['allow-missing']),
+    allowPending: Boolean(args['allow-pending'])
+  });
+
+  if (result.skipped) {
+    console.log(`Release gate not found at ${gatePath}.`);
+    return;
+  }
+
+  if (!result.ok) {
+    for (const error of result.errors) console.log(`[FAIL] ${error}`);
+    console.log(`\nFAILED - ${result.errors.length} release gate validation error(s).`);
+    process.exit(1);
+  }
+
+  console.log(`[PASS] ${gatePath} decision=${result.decision}`);
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/.qa-ai/scripts/validate-sync-plan.mjs

@@ -0,0 +1,186 @@
+#!/usr/bin/env node
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { normalizeColumn, parseMarkdownTable } from './lib/markdown-table.mjs';
+import { validateTestManagementMapping } from './lib/test-management-mapping.mjs';
+import {
+  getConfigValue,
+  listFilesRecursive,
+  loadQaAiConfig,
+  logHeader,
+  parseArgs,
+  pathExists,
+  readText,
+  relativeTo,
+  resolveRepoPath
+} from './lib/utils.mjs';
+
+const cwd = process.cwd();
+const args = parseArgs(process.argv);
+const idPattern = /\b(?:RF|TC|TEST|QA)[-_ ]?[A-Z0-9]+\b/gi;
+const writeClaimPattern = /\b(?:created|updated|deleted|synced|archived|creado|actualizado|eliminado|sincronizado|archivado)\s+(?:in|to|from|en|a|de)\s+(?:testrail|zephyr|xray|jira)\b/i;
+const requiredColumns = ['ID', 'Proposed action', 'Approval status'];
+const proposalPattern = /\b(?:propose|proposed|proposal|pending|review|approve|approval|required|draft|plan|planned|proponer|propuesto|pendiente|revisar|aprobar|aprobaci[o\u00f3]n|requerida|borrador|planificado)\b/i;
+const approvalPattern = /\b(?:approval|approve|pending approval|requires approval|aprobaci[o\u00f3]n|aprobar|pendiente|requiere aprobaci[o\u00f3]n)\b/i;
+
+function printHelp() {
+  console.log(`Usage: node .qa-ai/scripts/validate-sync-plan.mjs [options]
+
+Options:
+  --path <file>     Override sync plan path
+  --features <dir>  Override configured feature root
+  --allow-empty     Return success when no .feature files exist
+  --allow-missing   Return success when the sync plan is missing
+  --help            Show this help
+
+Validates proposal-first language, feature identifier coverage, sync-plan table shape and duplicate plan IDs.
+`);
+}
+
+function normalizeId(value) {
+  return String(value || '').replace(/\s+/g, '-').toUpperCase();
+}
+
+function idsFromText(value) {
+  return [...String(value || '').matchAll(idPattern)].map((match) => normalizeId(match[0]));
+}
+
+function parseSyncPlanTable(content) {
+  const table = parseMarkdownTable(content, {
+    label: 'Sync plan table',
+    requiredColumns
+  });
+  const errors = [...table.errors];
+  const rows = [];
+  for (const row of table.rows) {
+    const ids = [...new Set(idsFromText(row.cells.join(' ')))].sort();
+    const proposedAction = row.values[normalizeColumn('Proposed action')] || '';
+    const approvalStatus = row.values[normalizeColumn('Approval status')] || '';
+
+    if (ids.length === 0) errors.push(`Line ${row.line}: row must include at least one RF/test identifier.`);
+    if (proposedAction && !proposalPattern.test(proposedAction)) {
+      errors.push(`Line ${row.line}: proposed action must stay proposal-first.`);
+    }
+    if (approvalStatus && !approvalPattern.test(approvalStatus)) {
+      errors.push(`Line ${row.line}: approval status must clearly require or wait for approval.`);
+    }
+    if (writeClaimPattern.test(row.cells.join(' '))) {
+      errors.push(`Line ${row.line}: row appears to claim an external write happened; sync plans must stay proposal-first.`);
+    }
+
+    rows.push({ ...row, ids });
+  }
+
+  return { errors, rows, header: table.header };
+}
+
+function duplicatePlanErrors(rows) {
+  const byId = new Map();
+  const errors = [];
+
+  for (const row of rows) {
+    for (const id of row.ids) {
+      const current = byId.get(id) || [];
+      current.push(row.line);
+      byId.set(id, current);
+    }
+  }
+
+  for (const [id, lines] of byId.entries()) {
+    if (lines.length > 1) errors.push(`Identifier ${id} appears in multiple sync plan rows: ${lines.join(', ')}.`);
+  }
+
+  return errors;
+}
+
+async function collectFeatureIds(featureRootPath) {
+  const files = await listFilesRecursive(featureRootPath, (filePath) => filePath.endsWith('.feature'));
+  const entries = [];
+  for (const file of files) {
+    const content = await fs.readFile(file, 'utf8');
+    entries.push({
+      file,
+      ids: [...new Set([...idsFromText(path.basename(file, '.feature')), ...idsFromText(content)])].sort()
+    });
+  }
+  return entries;
+}
+
+async function validateMappingFile(config, errors) {
+  const mappingFile = getConfigValue(config, 'testrail.mappingFile', '');
+  if (!mappingFile) return;
+  const mappingPath = resolveRepoPath(cwd, mappingFile, { label: 'test management mapping file' });
+  if (!await pathExists(mappingPath)) return;
+  try {
+    const parsed = JSON.parse(await readText(mappingPath));
+    errors.push(...validateTestManagementMapping(parsed, { source: mappingFile }));
+  } catch (error) {
+    errors.push(`${mappingFile} is not valid JSON: ${error.message}`);
+  }
+}
+
+async function main() {
+  if (args.help) {
+    printHelp();
+    return;
+  }
+
+  logHeader('QA AI sync plan validator');
+  const configInfo = await loadQaAiConfig(cwd);
+  const featureRoot = args.features || getConfigValue(configInfo.data, 'gherkin.featurePath', 'features');
+  const syncPlanPath = args.path || getConfigValue(configInfo.data, 'testrail.syncPlanPath', 'qa-ai-output/testrail-sync-plan.md');
+  const featureRootPath = resolveRepoPath(cwd, featureRoot, { label: 'feature root' });
+  const syncPlanFilePath = resolveRepoPath(cwd, syncPlanPath, { label: 'sync plan' });
+  const features = await collectFeatureIds(featureRootPath);
+
+  if (features.length === 0) {
+    console.log(`No .feature files found under ${featureRoot}.`);
+    if (args['allow-empty']) return;
+    console.log('\nFAILED - no feature files found. Pass --allow-empty when this is expected.');
+    process.exit(1);
+  }
+
+  if (!await pathExists(syncPlanFilePath)) {
+    console.log(`Sync plan not found at ${syncPlanPath}.`);
+    if (args['allow-missing']) return;
+    console.log('\nFAILED - create the sync plan or pass --allow-missing.');
+    process.exit(1);
+  }
+
+  const content = await readText(syncPlanFilePath);
+  const normalizedContent = normalizeId(content);
+  const syncPlan = parseSyncPlanTable(content);
+  const errors = [];
+  errors.push(...syncPlan.errors);
+  errors.push(...duplicatePlanErrors(syncPlan.rows));
+
+  if (writeClaimPattern.test(content)) {
+    errors.push(`${syncPlanPath} appears to claim an external write happened; MVP sync plans must stay proposal-first.`);
+  }
+  if (!/\b(?:approval|approve|aprobaci[o\u00f3]n|aprobar)\b/i.test(content)) {
+    errors.push(`${syncPlanPath} must mention required approval before external writes.`);
+  }
+
+  for (const feature of features) {
+    for (const id of feature.ids) {
+      if (!normalizedContent.includes(id)) {
+        errors.push(`${relativeTo(cwd, feature.file)} identifier ${id} is missing from ${syncPlanPath}.`);
+      }
+    }
+  }
+
+  await validateMappingFile(configInfo.data, errors);
+
+  if (errors.length > 0) {
+    for (const error of errors) console.log(`[FAIL] ${error}`);
+    console.log(`\nFAILED - ${errors.length} sync plan validation error(s).`);
+    process.exit(1);
+  }
+
+  console.log(`[PASS] ${syncPlanPath} is proposal-first and covers ${features.length} feature file(s).`);
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/.qa-ai/scripts/validate-target.mjs

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+import { normalizeQaTrack } from './lib/qa-next-steps.mjs';
+import { getConfigValue, loadQaAiConfig, logHeader, parseArgs } from './lib/utils.mjs';
+
+const args = parseArgs(process.argv);
+
+function printHelp() {
+  console.log(`Usage: node .qa-ai/scripts/validate-target.mjs [options]
+
+Options:
+  --allow-empty       Pass --allow-empty to feature, traceability and sync-plan validators
+  --allow-missing     Pass --allow-missing to traceability, sync-plan, active-specialist and release-gate validators
+  --no-strict-doctor  Run doctor without --strict
+  --skip-release-gate Skip release gate validation (enterprise track only)
+  --skip-test-design   Skip test design markdown validation
+  --allow-pending     Pass --allow-pending to release gate validator
+  --help              Show this help
+
+Runs the target-repository validation pipeline:
+  doctor --strict
+  validate-features
+  validate-traceability
+  validate-sync-plan
+  validate-active-specialists
+  validate-release-gate (enterprise track only)
+  validate-test-design (standard and enterprise tracks)
+`);
+}
+
+function command(label, script, extraArgs = []) {
+  return { label, args: [script, ...extraArgs] };
+}
+
+function run(commandSpec) {
+  console.log(`\n--- ${commandSpec.label} ---`);
+  const result = spawnSync(process.execPath, commandSpec.args, {
+    cwd: process.cwd(),
+    encoding: 'utf8',
+    stdio: 'inherit',
+    shell: false
+  });
+  return result.status ?? 1;
+}
+
+async function main() {
+  if (args.help) {
+    printHelp();
+    return;
+  }
+
+  logHeader('QA AI target repository validator');
+  const allowEmpty = Boolean(args['allow-empty']);
+  const allowMissing = Boolean(args['allow-missing']);
+  const strictDoctor = !args['no-strict-doctor'];
+  const configInfo = await loadQaAiConfig(process.cwd());
+  const track = normalizeQaTrack(getConfigValue(configInfo.data, 'project.qaTrack', 'standard'));
+
+  const featureArgs = allowEmpty ? ['--allow-empty'] : [];
+  const artifactArgs = [
+    ...(allowEmpty ? ['--allow-empty'] : []),
+    ...(allowMissing ? ['--allow-missing'] : [])
+  ];
+  const activeSpecialistArgs = allowMissing ? ['--allow-missing'] : [];
+
+  const commands = [
+    command('doctor', '.qa-ai/scripts/doctor.mjs', strictDoctor ? ['--strict'] : []),
+    command('feature validation', '.qa-ai/scripts/validate-features.mjs', featureArgs),
+    command('traceability validation', '.qa-ai/scripts/validate-traceability.mjs', artifactArgs),
+    command('active specialist validation', '.qa-ai/scripts/validate-active-specialists.mjs', activeSpecialistArgs)
+  ];
+
+  if (track !== 'quick') {
+    commands.splice(3, 0, command('sync plan validation', '.qa-ai/scripts/validate-sync-plan.mjs', artifactArgs));
+  }
+
+  if (track === 'enterprise' && !args['skip-release-gate']) {
+    const gateArgs = [
+      ...(allowMissing ? ['--allow-missing'] : []),
+      ...(args['allow-pending'] ? ['--allow-pending'] : [])
+    ];
+    commands.push(command('release gate validation', '.qa-ai/scripts/validate-release-gate.mjs', gateArgs));
+  }
+
+  if (['standard', 'enterprise'].includes(track) && !args['skip-test-design']) {
+    const designArgs = allowMissing ? ['--allow-missing'] : [];
+    commands.push(command('test design validation', '.qa-ai/scripts/validate-test-design.mjs', designArgs));
+  }
+
+  for (const commandSpec of commands) {
+    const exitCode = run(commandSpec);
+    if (exitCode !== 0) {
+      console.log(`\nFAILED - ${commandSpec.label} failed.`);
+      process.exit(exitCode);
+    }
+  }
+
+  console.log('\nVALID - target repository validation passed.');
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});