@jaimevalasek/aioson 1.3.0

package/src/commands/squad-status.js

@@ -0,0 +1,424 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { flattenGenomeBindings, mergeGenomeBindings } = require('../genomes/bindings');
+
+const SQUADS_DIR = '.aioson/squads';
+const AGENTS_ROOT = 'agents';
+const OUTPUT_ROOT = 'output';
+const LOGS_ROOT = 'aios-logs';
+const SKIP_FILES = new Set(['memory.md', '.gitkeep']);
+const SESSION_HTML_RE = /\.html?$/i;
+
+function extractField(content, ...labels) {
+  for (const label of labels) {
+    const regex = new RegExp(`^(?:${label}):\\s*(.+)$`, 'im');
+    const match = String(content || '').match(regex);
+    if (match) return String(match[1]).trim();
+  }
+  return null;
+}
+
+function parseListSection(content, heading) {
+  const lines = String(content || '').split(/\r?\n/);
+  const startIndex = lines.findIndex((line) => line.trim() === `${heading}:`);
+  if (startIndex === -1) return [];
+
+  const values = [];
+  for (let i = startIndex + 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (/^\S.+:$/.test(line.trim())) break;
+    const match = line.match(/^\s*-\s+(.+?)\s*$/);
+    if (match) values.push(match[1].trim());
+  }
+  return values;
+}
+
+function normalizeRel(relPath) {
+  return String(relPath || '')
+    .replace(/\\/g, '/')
+    .replace(/^\.\//, '')
+    .replace(/\/+$/, '');
+}
+
+async function pathExists(targetPath) {
+  try {
+    await fs.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function readDirNames(targetPath) {
+  try {
+    return await fs.readdir(targetPath);
+  } catch {
+    return [];
+  }
+}
+
+async function getLatestHtml(outputDirAbs) {
+  const latestAlias = path.join(outputDirAbs, 'latest.html');
+  if (await pathExists(latestAlias)) {
+    const stat = await fs.stat(latestAlias).catch(() => null);
+    return { absPath: latestAlias, mtime: stat?.mtime || null };
+  }
+
+  const sessionEntries = await readDirNames(outputDirAbs);
+  const candidates = [];
+
+  for (const file of sessionEntries) {
+    if (file === 'latest.html') continue;
+    if (!SESSION_HTML_RE.test(file)) continue;
+    const absPath = path.join(outputDirAbs, file);
+    const stat = await fs.stat(absPath).catch(() => null);
+    if (!stat?.isFile()) continue;
+    candidates.push({ absPath, mtime: stat.mtime });
+  }
+
+  const legacySession = path.join(outputDirAbs, 'session.html');
+  if (await pathExists(legacySession)) {
+    const stat = await fs.stat(legacySession).catch(() => null);
+    candidates.push({ absPath: legacySession, mtime: stat?.mtime || null });
+  }
+
+  candidates.sort((a, b) => {
+    if (!a.mtime) return 1;
+    if (!b.mtime) return -1;
+    return b.mtime - a.mtime;
+  });
+
+  return candidates[0] || null;
+}
+
+async function collectDirStats(targetDir, relDir, options = {}) {
+  const normalized = normalizeRel(relDir);
+  if (!normalized) {
+    return { relDir: normalized, absDir: null, exists: false, entries: [] };
+  }
+
+  const absDir = path.join(targetDir, normalized);
+  const entries = await readDirNames(absDir);
+  const files = [];
+
+  for (const entry of entries) {
+    if (SKIP_FILES.has(entry)) continue;
+    const absPath = path.join(absDir, entry);
+    const stat = await fs.stat(absPath).catch(() => null);
+    if (!stat) continue;
+    const match = typeof options.filter === 'function' ? options.filter(entry, stat) : true;
+    if (!match) continue;
+    files.push({ name: entry, absPath, stat });
+  }
+
+  return {
+    relDir: normalized,
+    absDir,
+    exists: files.length > 0 || (await pathExists(absDir)),
+    entries: files
+  };
+}
+
+async function buildSquadRecordFromMetadata(targetDir, file) {
+  const squadsDir = path.join(targetDir, SQUADS_DIR);
+  const filePath = path.join(squadsDir, file);
+  const content = await fs.readFile(filePath, 'utf8').catch(() => null);
+  if (!content) return null;
+
+  const trimmed = content.trim();
+  if (!trimmed || trimmed.startsWith('<!--')) return null;
+
+  const slug = file.replace(/\.md$/, '');
+  const squadName =
+    extractField(content, 'Squad', 'Squad Ativo', 'Squad Activo', 'Squad Actif') || slug;
+  const mode = extractField(content, 'Mode', 'Modo') || '—';
+  const goal = extractField(content, 'Goal', 'Objetivo', 'Objectif') || '—';
+  const agentsDir = normalizeRel(extractField(content, 'Agents', 'AgentsDir') || `${AGENTS_ROOT}/${slug}`);
+  const outputDir = normalizeRel(extractField(content, 'Output', 'OutputDir') || `${OUTPUT_ROOT}/${slug}`);
+  const logsDir = normalizeRel(
+    extractField(content, 'Logs', 'LogsDir') || `${normalizeRel(LOGS_ROOT)}/${slug}`
+  );
+  const genomes = parseListSection(content, 'Genomes');
+  const agentGenomes = parseListSection(content, 'AgentGenomes');
+  const latestSession = normalizeRel(
+    extractField(content, 'LatestSession', 'Latest Session', 'UltimaSessao', 'DerniereSession')
+  );
+
+  const agents = await collectDirStats(targetDir, agentsDir, {
+    filter: (entry, stat) => stat.isFile() && entry.endsWith('.md')
+  });
+  const specialists = agents.entries.filter((entry) => entry.name !== 'orquestrador.md');
+
+  const sessions = await collectDirStats(targetDir, outputDir, {
+    filter: (entry, stat) => stat.isFile() && SESSION_HTML_RE.test(entry) && entry !== 'latest.html'
+  });
+  const logs = await collectDirStats(targetDir, logsDir, {
+    filter: (entry, stat) => stat.isFile()
+  });
+  const outputExists = await pathExists(path.join(targetDir, outputDir));
+  const latestHtml = latestSession
+    ? {
+        absPath: path.join(targetDir, latestSession),
+        mtime: (await fs.stat(path.join(targetDir, latestSession)).catch(() => null))?.mtime || null
+      }
+    : await getLatestHtml(path.join(targetDir, outputDir));
+
+  const metaStat = await fs.stat(filePath).catch(() => null);
+
+  return {
+    slug,
+    file,
+    metadataPath: filePath,
+    squadName,
+    mode,
+    goal,
+    agentsDir,
+    outputDir,
+    logsDir,
+    genomes,
+    agentGenomes,
+    latestSession,
+    agentCount: agents.entries.length,
+    specialistCount: specialists.length,
+    sessionCount: sessions.entries.length,
+    logCount: logs.entries.length,
+    latestHtml: latestHtml
+      ? normalizeRel(path.relative(targetDir, latestHtml.absPath))
+      : outputExists && (await pathExists(path.join(targetDir, outputDir, 'session.html')))
+        ? normalizeRel(path.join(outputDir, 'session.html'))
+        : '—',
+    mtime: latestHtml?.mtime || metaStat?.mtime || null
+  };
+}
+
+async function buildSquadRecordFromPackageDir(targetDir, slug) {
+  const packageDir = path.join(targetDir, SQUADS_DIR, slug);
+  const manifestPath = path.join(packageDir, 'squad.manifest.json');
+  const summaryPath = path.join(packageDir, 'squad.md');
+  const manifestRaw = await fs.readFile(manifestPath, 'utf8').catch(() => null);
+  if (!manifestRaw) return null;
+
+  let manifest = null;
+  try {
+    manifest = JSON.parse(manifestRaw);
+  } catch {
+    manifest = null;
+  }
+  if (!manifest || typeof manifest !== 'object') return null;
+
+  const summaryContent = await fs.readFile(summaryPath, 'utf8').catch(() => null);
+  const rules = manifest.rules && typeof manifest.rules === 'object' ? manifest.rules : {};
+  const packageInfo = manifest.package && typeof manifest.package === 'object' ? manifest.package : {};
+  const agentsDir = normalizeRel(packageInfo.agentsDir || path.join(SQUADS_DIR, slug, 'agents'));
+  const outputDir = normalizeRel(rules.outputsDir || `${OUTPUT_ROOT}/${slug}`);
+  const logsDir = normalizeRel(rules.logsDir || `${normalizeRel(LOGS_ROOT)}/${slug}`);
+  const latestSession = normalizeRel(
+    extractField(summaryContent || '', 'LatestSession', 'Latest Session', 'UltimaSessao', 'DerniereSession') ||
+      `${OUTPUT_ROOT}/${slug}/latest.html`
+  );
+  const genomeBindings = mergeGenomeBindings({
+    blueprintBindings: manifest.genomeBindings,
+    manifestBindings: manifest.genomeBindings || manifest.genomes,
+    legacyExecutors: manifest.executors
+  });
+  const flattenedBindings = flattenGenomeBindings(genomeBindings);
+  const genomes = flattenedBindings
+    .filter((item) => item.scope === 'squad')
+    .map((item) => item.slug);
+  const agentGenomes = flattenedBindings
+    .filter((item) => item.scope !== 'squad' && item.agentSlug)
+    .map((item) => `${item.agentSlug}: ${item.slug}`);
+  const fallbackGenomes = genomes.length > 0 ? genomes : parseListSection(summaryContent || '', 'Genomes');
+  const fallbackAgentGenomes =
+    agentGenomes.length > 0 ? agentGenomes : parseListSection(summaryContent || '', 'AgentGenomes');
+
+  const agents = await collectDirStats(targetDir, agentsDir, {
+    filter: (entry, stat) => stat.isFile() && entry.endsWith('.md')
+  });
+  const specialists = agents.entries.filter(
+    (entry) => entry.name !== 'orquestrador.md' && entry.name !== 'agents.md'
+  );
+
+  const sessions = await collectDirStats(targetDir, outputDir, {
+    filter: (entry, stat) => stat.isFile() && SESSION_HTML_RE.test(entry) && entry !== 'latest.html'
+  });
+  const logs = await collectDirStats(targetDir, logsDir, {
+    filter: (entry, stat) => stat.isFile()
+  });
+  const outputExists = await pathExists(path.join(targetDir, outputDir));
+  const latestHtml = latestSession
+    ? {
+        absPath: path.join(targetDir, latestSession),
+        mtime: (await fs.stat(path.join(targetDir, latestSession)).catch(() => null))?.mtime || null
+      }
+    : await getLatestHtml(path.join(targetDir, outputDir));
+  const manifestStat = await fs.stat(manifestPath).catch(() => null);
+
+  return {
+    slug,
+    file: `${slug}/squad.manifest.json`,
+    metadataPath: manifestPath,
+    squadName: String(manifest.name || slug),
+    mode: String(manifest.mode || 'content'),
+    goal: String(manifest.goal || '—'),
+    agentsDir,
+    outputDir,
+    logsDir,
+    genomes: fallbackGenomes,
+    agentGenomes: fallbackAgentGenomes,
+    latestSession,
+    agentCount: agents.entries.length,
+    specialistCount: specialists.length,
+    sessionCount: sessions.entries.length,
+    logCount: logs.entries.length,
+    latestHtml: latestHtml
+      ? normalizeRel(path.relative(targetDir, latestHtml.absPath))
+      : outputExists && (await pathExists(path.join(targetDir, outputDir, 'session.html')))
+        ? normalizeRel(path.join(outputDir, 'session.html'))
+        : '—',
+    mtime: latestHtml?.mtime || manifestStat?.mtime || null
+  };
+}
+
+async function buildFallbackSquadRecords(targetDir, metadataSlugs) {
+  const agentsRootAbs = path.join(targetDir, AGENTS_ROOT);
+  const entries = await readDirNames(agentsRootAbs);
+  const squads = [];
+
+  for (const entry of entries) {
+    if (metadataSlugs.has(entry)) continue;
+    const absDir = path.join(agentsRootAbs, entry);
+    const stat = await fs.stat(absDir).catch(() => null);
+    if (!stat?.isDirectory()) continue;
+
+    const agents = await collectDirStats(targetDir, path.join(AGENTS_ROOT, entry), {
+      filter: (name, itemStat) => itemStat.isFile() && name.endsWith('.md')
+    });
+    if (agents.entries.length === 0) continue;
+
+    const sessions = await collectDirStats(targetDir, path.join(OUTPUT_ROOT, entry), {
+      filter: (name, itemStat) => itemStat.isFile() && SESSION_HTML_RE.test(name) && name !== 'latest.html'
+    });
+    const logs = await collectDirStats(targetDir, path.join(LOGS_ROOT, entry), {
+      filter: (name, itemStat) => itemStat.isFile()
+    });
+    const latestHtml = await getLatestHtml(path.join(targetDir, OUTPUT_ROOT, entry));
+
+    squads.push({
+      slug: entry,
+      file: `${entry}.md`,
+      metadataPath: path.join(targetDir, SQUADS_DIR, `${entry}.md`),
+      squadName: entry,
+      mode: '—',
+      goal: '—',
+      agentsDir: `${AGENTS_ROOT}/${entry}`,
+      outputDir: `${OUTPUT_ROOT}/${entry}`,
+      logsDir: `${normalizeRel(LOGS_ROOT)}/${entry}`,
+      genomes: [],
+      agentGenomes: [],
+      latestSession: latestHtml ? normalizeRel(path.relative(targetDir, latestHtml.absPath)) : '—',
+      agentCount: agents.entries.length,
+      specialistCount: agents.entries.filter((item) => item.name !== 'orquestrador.md').length,
+      sessionCount: sessions.entries.length,
+      logCount: logs.entries.length,
+      latestHtml: latestHtml ? normalizeRel(path.relative(targetDir, latestHtml.absPath)) : '—',
+      mtime: latestHtml?.mtime || stat.mtime
+    });
+  }
+
+  return squads;
+}
+
+async function runSquadStatus({ args, logger, t }) {
+  const targetDir = path.resolve(process.cwd(), args[0] || '.');
+  const squadsDir = path.join(targetDir, SQUADS_DIR);
+  const metadataEntries = await fs.readdir(squadsDir, { withFileTypes: true }).catch(() => []);
+  const packageDirs = metadataEntries
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => entry.name)
+    .filter(Boolean);
+  const mdFiles = metadataEntries
+    .filter((entry) => entry.isFile())
+    .map((entry) => entry.name)
+    .filter((file) => file.endsWith('.md') && !SKIP_FILES.has(file));
+
+  const squads = [];
+  for (const slug of packageDirs) {
+    const squad = await buildSquadRecordFromPackageDir(targetDir, slug);
+    if (squad) squads.push(squad);
+  }
+
+  for (const file of mdFiles) {
+    if (packageDirs.includes(file.replace(/\.md$/, ''))) continue;
+    const squad = await buildSquadRecordFromMetadata(targetDir, file);
+    if (squad) squads.push(squad);
+  }
+
+  const fallbackSquads = await buildFallbackSquadRecords(
+    targetDir,
+    new Set(squads.map((item) => item.slug))
+  );
+  squads.push(...fallbackSquads);
+
+  if (squads.length === 0) {
+    logger.log(t('squad_status.no_squad'));
+    logger.log(t('squad_status.hint'));
+    return { ok: true, active: false, squads: [] };
+  }
+
+  squads.sort((a, b) => {
+    if (!a.mtime) return 1;
+    if (!b.mtime) return -1;
+    return b.mtime - a.mtime;
+  });
+
+  logger.log(t('squad_status.squads_found', { count: squads.length }));
+  logger.log('');
+
+  for (let i = 0; i < squads.length; i++) {
+    const squad = squads[i];
+    const marker = i === 0 ? ` ${t('squad_status.most_recent')}` : '';
+    logger.log(t('squad_status.squad_item', { file: squad.file, marker }));
+    logger.log(t('squad_status.name', { value: squad.squadName }));
+    logger.log(t('squad_status.mode', { value: squad.mode }));
+    logger.log(t('squad_status.goal', { value: squad.goal }));
+    logger.log(
+      t('squad_status.agents', {
+        specialists: squad.specialistCount,
+        total: squad.agentCount,
+        path: squad.agentsDir
+      })
+    );
+    logger.log(
+      t('squad_status.sessions', {
+        count: squad.sessionCount,
+        path: squad.outputDir
+      })
+    );
+    logger.log(t('squad_status.latest_html', { value: squad.latestHtml }));
+    logger.log(
+      t('squad_status.logs', {
+        count: squad.logCount,
+        path: squad.logsDir
+      })
+    );
+    logger.log(
+      t('squad_status.genomes', {
+        count: squad.genomes.length,
+        agent_count: squad.agentGenomes.length
+      })
+    );
+    if (i < squads.length - 1) logger.log('');
+  }
+
+  return {
+    ok: true,
+    active: true,
+    squads,
+    count: squads.length
+  };
+}
+
+module.exports = { runSquadStatus };

package/src/commands/squad-validate.js

@@ -0,0 +1,230 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+
+async function pathExists(targetPath) {
+  try { await fs.access(targetPath); return true; } catch { return false; }
+}
+
+async function readJsonIfExists(filePath) {
+  try {
+    const raw = await fs.readFile(filePath, 'utf8');
+    return JSON.parse(raw);
+  } catch { return null; }
+}
+
+function validateManifestFields(manifest) {
+  const errors = [];
+  const warnings = [];
+  const required = ['schemaVersion', 'slug', 'name', 'mode', 'mission', 'goal'];
+
+  for (const field of required) {
+    if (!manifest[field]) {
+      errors.push(`Missing required field: ${field}`);
+    }
+  }
+
+  if (manifest.slug && !/^[a-z0-9][a-z0-9-]*[a-z0-9]$/.test(manifest.slug)) {
+    errors.push(`Invalid slug format: "${manifest.slug}" (must be kebab-case)`);
+  }
+
+  if (manifest.mode && !['content', 'software', 'research', 'mixed'].includes(manifest.mode)) {
+    warnings.push(`Unknown mode: "${manifest.mode}"`);
+  }
+
+  return { errors, warnings };
+}
+
+async function validateStructure(projectDir, slug, manifest) {
+  const errors = [];
+  const warnings = [];
+  const squadDir = path.join(projectDir, '.aioson', 'squads', slug);
+
+  const requiredFiles = [
+    { rel: 'squad.manifest.json', label: 'Manifest' },
+    { rel: 'agents/agents.md', label: 'Agents manifesto' },
+    { rel: 'agents/orquestrador.md', label: 'Orchestrator agent' },
+  ];
+
+  for (const { rel, label } of requiredFiles) {
+    if (!(await pathExists(path.join(squadDir, rel)))) {
+      errors.push(`Missing required file: ${rel} (${label})`);
+    }
+  }
+
+  // Check executor files
+  const executors = Array.isArray(manifest.executors) ? manifest.executors : [];
+  for (const exec of executors) {
+    if (exec.file) {
+      const absPath = path.join(projectDir, exec.file);
+      if (!(await pathExists(absPath))) {
+        errors.push(`Executor "${exec.slug}" file not found: ${exec.file}`);
+      }
+    }
+  }
+
+  // Check output dir (warning only)
+  const outputDir = path.join(projectDir, 'output', slug);
+  if (!(await pathExists(outputDir))) {
+    warnings.push(`Output directory not found: output/${slug}/`);
+  }
+
+  return { errors, warnings };
+}
+
+async function validateSemantics(manifest) {
+  const errors = [];
+  const warnings = [];
+  const executors = Array.isArray(manifest.executors) ? manifest.executors : [];
+
+  // Check for duplicate slugs
+  const slugs = executors.map(e => e.slug);
+  const dupes = slugs.filter((s, i) => slugs.indexOf(s) !== i);
+  if (dupes.length > 0) {
+    errors.push(`Duplicate executor slugs: ${[...new Set(dupes)].join(', ')}`);
+  }
+
+  // Check executors without skills
+  for (const exec of executors) {
+    const skills = Array.isArray(exec.skills) ? exec.skills : [];
+    if (skills.length === 0) {
+      warnings.push(`Executor "${exec.slug}" has no skills declared`);
+    }
+  }
+
+  return { errors, warnings };
+}
+
+async function validateSemanticDeep(projectDir, slug, manifest) {
+  const errors = [];
+  const warnings = [];
+
+  // 1. Slug do manifesto bate com diretório
+  if (manifest.slug && manifest.slug !== slug) {
+    errors.push(`Slug mismatch: manifest says "${manifest.slug}" but directory is "${slug}"`);
+  }
+
+  // 2. Skills referenciadas pelos executores estão declaradas no manifesto
+  const declaredSkills = Array.isArray(manifest.skills) ? manifest.skills.map(s => s.slug) : [];
+  const executors = Array.isArray(manifest.executors) ? manifest.executors : [];
+  for (const exec of executors) {
+    const execSkills = Array.isArray(exec.skills) ? exec.skills : [];
+    for (const skillSlug of execSkills) {
+      if (!declaredSkills.includes(skillSlug)) {
+        warnings.push(`Executor "${exec.slug}" references skill "${skillSlug}" not declared in manifest.skills`);
+      }
+    }
+  }
+
+  // 3. Content blueprints têm sections válidas
+  const blueprints = Array.isArray(manifest.contentBlueprints) ? manifest.contentBlueprints : [];
+  for (const bp of blueprints) {
+    if (!bp.sections || bp.sections.length === 0) {
+      warnings.push(`Content blueprint "${bp.slug}" has no sections defined`);
+    }
+  }
+
+  // 4. CLAUDE.md e AGENTS.md mencionam o squad
+  const claudeMd = path.join(projectDir, 'CLAUDE.md');
+  const agentsMd = path.join(projectDir, 'AGENTS.md');
+  try {
+    const claudeContent = await fs.readFile(claudeMd, 'utf8');
+    if (!claudeContent.includes(slug)) {
+      warnings.push(`CLAUDE.md does not reference squad "${slug}"`);
+    }
+  } catch { warnings.push('CLAUDE.md not found'); }
+
+  try {
+    const agentsContent = await fs.readFile(agentsMd, 'utf8');
+    if (!agentsContent.includes(slug)) {
+      warnings.push(`AGENTS.md does not reference squad "${slug}"`);
+    }
+  } catch { warnings.push('AGENTS.md not found'); }
+
+  // 5. Readiness não contradiz blockers
+  if (manifest.readiness) {
+    for (const [dim, val] of Object.entries(manifest.readiness)) {
+      if (val && val.status === 'ready' && val.blocker) {
+        warnings.push(`Readiness "${dim}" is "ready" but has blocker: "${val.blocker}"`);
+      }
+    }
+  }
+
+  return { errors, warnings };
+}
+
+async function runSquadValidate({ args = [], options = {}, logger = console } = {}) {
+  const projectDir = path.resolve(process.cwd(), args[0] || '.');
+  const slug = options.squad || args[1];
+
+  if (!slug) {
+    logger.error('Usage: aioson squad:validate [path] --squad=<slug>');
+    return { valid: false, errors: ['No slug provided'], warnings: [] };
+  }
+
+  const manifestPath = path.join(projectDir, '.aioson', 'squads', slug, 'squad.manifest.json');
+  const manifest = await readJsonIfExists(manifestPath);
+
+  if (!manifest) {
+    logger.error(`Squad "${slug}" not found or invalid manifest at ${manifestPath}`);
+    return { valid: false, errors: ['Manifest not found or invalid JSON'], warnings: [] };
+  }
+
+  const allErrors = [];
+  const allWarnings = [];
+
+  // Layer 1: Schema
+  const schema = validateManifestFields(manifest);
+  allErrors.push(...schema.errors);
+  allWarnings.push(...schema.warnings);
+
+  // Layer 2: Structure
+  const structure = await validateStructure(projectDir, slug, manifest);
+  allErrors.push(...structure.errors);
+  allWarnings.push(...structure.warnings);
+
+  // Layer 3: Semantics (basic)
+  const semantics = await validateSemantics(manifest);
+  allErrors.push(...semantics.errors);
+  allWarnings.push(...semantics.warnings);
+
+  // Layer 4: Semantic deep
+  const semanticDeep = await validateSemanticDeep(projectDir, slug, manifest);
+  allErrors.push(...semanticDeep.errors);
+  allWarnings.push(...semanticDeep.warnings);
+
+  // Report
+  const valid = allErrors.length === 0;
+  const status = valid
+    ? (allWarnings.length > 0 ? 'VALID (with warnings)' : 'VALID')
+    : 'INVALID';
+
+  logger.log('');
+  logger.log(`\u2550\u2550 Squad Validation: ${slug} \u2550\u2550`);
+  logger.log('');
+  logger.log(`  Schema:         ${schema.errors.length === 0 ? '\u2705 PASS' : '\u274c FAIL'}`);
+  logger.log(`  Structure:      ${structure.errors.length === 0 ? '\u2705 PASS' : '\u274c FAIL'}`);
+  logger.log(`  Semantics:      ${semantics.errors.length === 0 ? (semantics.warnings.length > 0 ? '\u26a0\ufe0f  WARNINGS' : '\u2705 PASS') : '\u274c FAIL'}`);
+  logger.log(`  Semantic deep:  ${semanticDeep.errors.length === 0 ? (semanticDeep.warnings.length > 0 ? '\u26a0\ufe0f  WARNINGS' : '\u2705 PASS') : '\u274c FAIL'}`);
+
+  if (allErrors.length > 0) {
+    logger.log('');
+    logger.log('  Errors:');
+    for (const err of allErrors) logger.log(`    \u274c ${err}`);
+  }
+
+  if (allWarnings.length > 0) {
+    logger.log('');
+    logger.log('  Warnings:');
+    for (const warn of allWarnings) logger.log(`    \u26a0\ufe0f  ${warn}`);
+  }
+
+  logger.log('');
+  logger.log(`  Result: ${status}`);
+  logger.log('');
+
+  return { valid, errors: allErrors, warnings: allWarnings, status };
+}
+
+module.exports = { runSquadValidate };