aios-core 4.2.3 → 4.2.4

package/.aios-core/infrastructure/scripts/ide-sync/index.js

@@ -24,11 +24,11 @@ const yaml = require('js-yaml');
 const { parseAllAgents } = require('./agent-parser');
 const { generateAllRedirects, writeRedirects } = require('./redirect-generator');
 const { validateAllIdes, formatValidationReport } = require('./validator');
+const { syncGeminiCommands, buildGeminiCommandFiles } = require('./gemini-commands');
 
 // Transformers
 const claudeCodeTransformer = require('./transformers/claude-code');
 const cursorTransformer = require('./transformers/cursor');
-const windsurfTransformer = require('./transformers/windsurf');
 const antigravityTransformer = require('./transformers/antigravity');
 
 // ANSI colors for output
@@ -66,16 +66,21 @@ function loadConfig(projectRoot) {
         path: '.codex/agents',
         format: 'full-markdown-yaml',
       },
+      gemini: {
+        enabled: true,
+        path: '.gemini/rules/AIOS/agents',
+        format: 'full-markdown-yaml',
+      },
+      'github-copilot': {
+        enabled: true,
+        path: '.github/agents',
+        format: 'full-markdown-yaml',
+      },
       cursor: {
         enabled: true,
         path: '.cursor/rules/agents',
         format: 'condensed-rules',
       },
-      windsurf: {
-        enabled: false, // Disabled - consolidating to core IDEs (v3.10.0)
-        path: '.windsurf/rules/agents',
-        format: 'xml-tagged-markdown',
-      },
       antigravity: {
         enabled: true,
         path: '.antigravity/rules/agents',
@@ -120,7 +125,6 @@ function getTransformer(format) {
   const transformers = {
     'full-markdown-yaml': claudeCodeTransformer,
     'condensed-rules': cursorTransformer,
-    'xml-tagged-markdown': windsurfTransformer,
     'cursor-style': antigravityTransformer,
   };
 
@@ -258,6 +262,15 @@ async function commandSync(options) {
     }
 
     const result = syncIde(agents, ideConfig, ideName, projectRoot, options);
+
+    // Gemini CLI: also sync slash launcher command files (.gemini/commands/*.toml)
+    if (ideName === 'gemini') {
+      const geminiCommands = syncGeminiCommands(agents, projectRoot, options);
+      result.commandFiles = geminiCommands.files;
+    } else {
+      result.commandFiles = [];
+    }
+
     results.push(result);
 
     // Generate redirects for this IDE
@@ -269,6 +282,7 @@ async function commandSync(options) {
     }
 
     const agentCount = result.files.length;
+    const commandCount = (result.commandFiles || []).length;
     const redirectCount = redirectResult.written.length;
     const errorCount = result.errors.length;
 
@@ -279,7 +293,7 @@ async function commandSync(options) {
       }
 
       console.log(
-        `   ${status} ${agentCount} agents, ${redirectCount} redirects${errorCount > 0 ? `, ${errorCount} errors` : ''}`
+        `   ${status} ${agentCount} agents${commandCount > 0 ? `, ${commandCount} commands` : ''}, ${redirectCount} redirects${errorCount > 0 ? `, ${errorCount} errors` : ''}`
       );
 
       if (options.verbose && result.errors.length > 0) {
@@ -291,7 +305,7 @@ async function commandSync(options) {
   }
 
   // Summary
-  const totalFiles = results.reduce((sum, r) => sum + r.files.length, 0);
+  const totalFiles = results.reduce((sum, r) => sum + r.files.length + (r.commandFiles || []).length, 0);
   const totalRedirects =
     Object.keys(config.redirects).length * targetIdes.filter(([, c]) => c.enabled).length;
   const totalErrors = results.reduce((sum, r) => sum + r.errors.length, 0);
@@ -337,9 +351,18 @@ async function commandValidate(options) {
 
   // Build expected files for each IDE
   const ideConfigs = {};
+  let targetIdes = Object.entries(config.targets).filter(([, ideConfig]) => ideConfig.enabled);
 
-  for (const [ideName, ideConfig] of Object.entries(config.targets)) {
-    if (!ideConfig.enabled) continue;
+  // Filter IDEs if --ide flag specified
+  if (options.ide) {
+    targetIdes = targetIdes.filter(([name]) => name === options.ide);
+    if (targetIdes.length === 0) {
+      console.error(`${colors.red}Error: IDE '${options.ide}' not found in config${colors.reset}`);
+      process.exit(1);
+    }
+  }
+
+  for (const [ideName, ideConfig] of targetIdes) {
 
     const transformer = getTransformer(ideConfig.format);
     const expectedFiles = [];
@@ -374,6 +397,18 @@ async function commandValidate(options) {
       expectedFiles,
       targetDir: path.join(projectRoot, ideConfig.path),
     };
+
+    // Gemini CLI command launcher files are synced under .gemini/commands/*.toml
+    if (ideName === 'gemini') {
+      const commandFiles = buildGeminiCommandFiles(agents).map((entry) => ({
+        filename: entry.filename,
+        content: entry.content,
+      }));
+      ideConfigs['gemini-commands'] = {
+        expectedFiles: commandFiles,
+        targetDir: path.join(projectRoot, '.gemini', 'commands'),
+      };
+    }
   }
 
   // Validate
@@ -450,7 +485,9 @@ ${colors.bright}Options:${colors.reset}
 ${colors.bright}Examples:${colors.reset}
   node ide-sync/index.js sync
   node ide-sync/index.js sync --ide codex
+  node ide-sync/index.js sync --ide gemini
   node ide-sync/index.js sync --ide cursor
+  node ide-sync/index.js validate --ide gemini --strict
   node ide-sync/index.js validate --strict
   node ide-sync/index.js sync --dry-run --verbose
 `);

package/.aios-core/infrastructure/scripts/ide-sync/redirect-generator.js

@@ -55,7 +55,7 @@ ${baseContent.instruction}
 `;
 
     case 'xml-tagged-markdown':
-      // Windsurf format
+      // Generic markdown format
       return `${baseContent.header}
 
 <redirect>

package/.aios-core/infrastructure/scripts/test-utilities.js

@@ -27,7 +27,7 @@ async function countIntegrationReferences(utilityName) {
   const searchDirs = [
     '.aios-core/agents',
     '.aios-core/tasks',
-    'expansion-packs',
+    'squads',
   ];
 
   let totalCount = 0;

package/.aios-core/infrastructure/scripts/tool-resolver.js

@@ -48,7 +48,7 @@ class ToolResolver {
     // 2. Build search paths (squad → core priority)
     const searchPaths = [];
     if (context.expansionPack) {
-      searchPaths.push(`expansion-packs/${context.expansionPack}/tools`);
+      searchPaths.push(`squads/${context.expansionPack}/tools`);
     }
     searchPaths.push(...this.basePaths);
 
@@ -304,7 +304,7 @@ class ToolResolver {
   async toolExists(toolName, context = {}) {
     const searchPaths = [];
     if (context.expansionPack) {
-      searchPaths.push(`expansion-packs/${context.expansionPack}/tools`);
+      searchPaths.push(`squads/${context.expansionPack}/tools`);
     }
     searchPaths.push(...this.basePaths);
 

package/.aios-core/infrastructure/scripts/validate-claude-integration.js

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function parseArgs(argv = process.argv.slice(2)) {
+  const args = new Set(argv);
+  return {
+    quiet: args.has('--quiet') || args.has('-q'),
+    json: args.has('--json'),
+  };
+}
+
+function countMarkdownFiles(dirPath) {
+  if (!fs.existsSync(dirPath)) return 0;
+  return fs.readdirSync(dirPath).filter((f) => f.endsWith('.md')).length;
+}
+
+function validateClaudeIntegration(options = {}) {
+  const projectRoot = options.projectRoot || process.cwd();
+  const rulesFile = options.rulesFile || path.join(projectRoot, '.claude', 'CLAUDE.md');
+  const agentsDir = options.agentsDir || path.join(projectRoot, '.claude', 'commands', 'AIOS', 'agents');
+  const hooksDir = options.hooksDir || path.join(projectRoot, '.claude', 'hooks');
+  const sourceAgentsDir =
+    options.sourceAgentsDir || path.join(projectRoot, '.aios-core', 'development', 'agents');
+
+  const errors = [];
+  const warnings = [];
+
+  if (!fs.existsSync(agentsDir)) {
+    errors.push(`Missing Claude agents dir: ${path.relative(projectRoot, agentsDir)}`);
+  }
+  if (!fs.existsSync(rulesFile)) {
+    warnings.push(`Claude rules file not found yet: ${path.relative(projectRoot, rulesFile)}`);
+  }
+  if (!fs.existsSync(hooksDir)) {
+    warnings.push(`Claude hooks dir not found yet: ${path.relative(projectRoot, hooksDir)}`);
+  }
+
+  const sourceCount = countMarkdownFiles(sourceAgentsDir);
+  const claudeCount = countMarkdownFiles(agentsDir);
+  if (sourceCount > 0 && claudeCount !== sourceCount) {
+    warnings.push(`Claude agent count differs from source (${claudeCount}/${sourceCount})`);
+  }
+
+  return {
+    ok: errors.length === 0,
+    errors,
+    warnings,
+    metrics: {
+      sourceAgents: sourceCount,
+      claudeAgents: claudeCount,
+    },
+  };
+}
+
+function formatHumanReport(result) {
+  if (result.ok) {
+    const lines = [`✅ Claude integration validation passed (agents: ${result.metrics.claudeAgents})`];
+    if (result.warnings.length > 0) {
+      lines.push(...result.warnings.map((w) => `⚠️ ${w}`));
+    }
+    return lines.join('\n');
+  }
+  const lines = [
+    `❌ Claude integration validation failed (${result.errors.length} issue(s))`,
+    ...result.errors.map((e) => `- ${e}`),
+  ];
+  if (result.warnings.length > 0) {
+    lines.push(...result.warnings.map((w) => `⚠️ ${w}`));
+  }
+  return lines.join('\n');
+}
+
+function main() {
+  const args = parseArgs();
+  const result = validateClaudeIntegration(args);
+
+  if (!args.quiet) {
+    if (args.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log(formatHumanReport(result));
+    }
+  }
+
+  if (!result.ok) {
+    process.exitCode = 1;
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  validateClaudeIntegration,
+  parseArgs,
+  countMarkdownFiles,
+};

package/.aios-core/infrastructure/scripts/validate-codex-integration.js

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function getDefaultOptions() {
+  const projectRoot = process.cwd();
+  return {
+    projectRoot,
+    instructionsFile: path.join(projectRoot, 'AGENTS.md'),
+    agentsDir: path.join(projectRoot, '.codex', 'agents'),
+    skillsDir: path.join(projectRoot, '.codex', 'skills'),
+    sourceAgentsDir: path.join(projectRoot, '.aios-core', 'development', 'agents'),
+    quiet: false,
+    json: false,
+  };
+}
+
+function parseArgs(argv = process.argv.slice(2)) {
+  const args = new Set(argv);
+  return {
+    quiet: args.has('--quiet') || args.has('-q'),
+    json: args.has('--json'),
+  };
+}
+
+function countMarkdownFiles(dirPath) {
+  if (!fs.existsSync(dirPath)) return 0;
+  return fs.readdirSync(dirPath).filter((f) => f.endsWith('.md')).length;
+}
+
+function countSkillFiles(skillsDir) {
+  if (!fs.existsSync(skillsDir)) return 0;
+  const entries = fs.readdirSync(skillsDir, { withFileTypes: true });
+  return entries
+    .filter((entry) => entry.isDirectory() && entry.name.startsWith('aios-'))
+    .filter((entry) => fs.existsSync(path.join(skillsDir, entry.name, 'SKILL.md')))
+    .length;
+}
+
+function validateCodexIntegration(options = {}) {
+  const projectRoot = options.projectRoot || process.cwd();
+  const resolved = {
+    ...getDefaultOptions(),
+    ...options,
+    projectRoot,
+    instructionsFile: options.instructionsFile || path.join(projectRoot, 'AGENTS.md'),
+    agentsDir: options.agentsDir || path.join(projectRoot, '.codex', 'agents'),
+    skillsDir: options.skillsDir || path.join(projectRoot, '.codex', 'skills'),
+    sourceAgentsDir: options.sourceAgentsDir || path.join(projectRoot, '.aios-core', 'development', 'agents'),
+  };
+  const errors = [];
+  const warnings = [];
+
+  if (!fs.existsSync(resolved.instructionsFile)) {
+    warnings.push(
+      `Codex instructions file not found yet: ${path.relative(resolved.projectRoot, resolved.instructionsFile)}`,
+    );
+  }
+
+  if (!fs.existsSync(resolved.agentsDir)) {
+    errors.push(`Missing Codex agents dir: ${path.relative(resolved.projectRoot, resolved.agentsDir)}`);
+  }
+
+  if (!fs.existsSync(resolved.skillsDir)) {
+    errors.push(`Missing Codex skills dir: ${path.relative(resolved.projectRoot, resolved.skillsDir)}`);
+  }
+
+  const sourceCount = countMarkdownFiles(resolved.sourceAgentsDir);
+  const codexAgentsCount = countMarkdownFiles(resolved.agentsDir);
+  const codexSkillsCount = countSkillFiles(resolved.skillsDir);
+
+  if (sourceCount > 0 && codexAgentsCount !== sourceCount) {
+    warnings.push(`Codex agent count differs from source (${codexAgentsCount}/${sourceCount})`);
+  }
+
+  if (sourceCount > 0 && codexSkillsCount !== sourceCount) {
+    warnings.push(`Codex skill count differs from source (${codexSkillsCount}/${sourceCount})`);
+  }
+
+  return {
+    ok: errors.length === 0,
+    errors,
+    warnings,
+    metrics: {
+      sourceAgents: sourceCount,
+      codexAgents: codexAgentsCount,
+      codexSkills: codexSkillsCount,
+    },
+  };
+}
+
+function formatHumanReport(result) {
+  if (result.ok) {
+    const lines = [
+      `✅ Codex integration validation passed (agents: ${result.metrics.codexAgents}, skills: ${result.metrics.codexSkills})`,
+    ];
+    if (result.warnings.length > 0) {
+      lines.push(...result.warnings.map((w) => `⚠️ ${w}`));
+    }
+    return lines.join('\n');
+  }
+  const lines = [
+    `❌ Codex integration validation failed (${result.errors.length} issue(s))`,
+    ...result.errors.map((e) => `- ${e}`),
+  ];
+  if (result.warnings.length > 0) {
+    lines.push(...result.warnings.map((w) => `⚠️ ${w}`));
+  }
+  return lines.join('\n');
+}
+
+function main() {
+  const args = parseArgs();
+  const result = validateCodexIntegration(args);
+
+  if (!args.quiet) {
+    if (args.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log(formatHumanReport(result));
+    }
+  }
+
+  if (!result.ok) {
+    process.exitCode = 1;
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  validateCodexIntegration,
+  parseArgs,
+  getDefaultOptions,
+  countMarkdownFiles,
+  countSkillFiles,
+};

package/.aios-core/infrastructure/scripts/validate-gemini-integration.js

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function getDefaultOptions() {
+  const projectRoot = process.cwd();
+  return {
+    projectRoot,
+    rulesFile: path.join(projectRoot, '.gemini', 'rules.md'),
+    agentsDir: path.join(projectRoot, '.gemini', 'rules', 'AIOS', 'agents'),
+    commandsDir: path.join(projectRoot, '.gemini', 'commands'),
+    extensionDir: path.join(projectRoot, 'packages', 'gemini-aios-extension'),
+    sourceAgentsDir: path.join(projectRoot, '.aios-core', 'development', 'agents'),
+    quiet: false,
+    json: false,
+  };
+}
+
+function parseArgs(argv = process.argv.slice(2)) {
+  const args = new Set(argv);
+  return {
+    quiet: args.has('--quiet') || args.has('-q'),
+    json: args.has('--json'),
+  };
+}
+
+function countMarkdownFiles(dirPath) {
+  if (!fs.existsSync(dirPath)) return 0;
+  return fs.readdirSync(dirPath).filter((f) => f.endsWith('.md')).length;
+}
+
+function validateGeminiIntegration(options = {}) {
+  const projectRoot = options.projectRoot || process.cwd();
+  const resolved = {
+    ...getDefaultOptions(),
+    ...options,
+    projectRoot,
+    rulesFile: options.rulesFile || path.join(projectRoot, '.gemini', 'rules.md'),
+    agentsDir: options.agentsDir || path.join(projectRoot, '.gemini', 'rules', 'AIOS', 'agents'),
+    commandsDir: options.commandsDir || path.join(projectRoot, '.gemini', 'commands'),
+    extensionDir: options.extensionDir || path.join(projectRoot, 'packages', 'gemini-aios-extension'),
+    sourceAgentsDir: options.sourceAgentsDir || path.join(projectRoot, '.aios-core', 'development', 'agents'),
+  };
+  const errors = [];
+  const warnings = [];
+
+  if (!fs.existsSync(resolved.rulesFile)) {
+    warnings.push(`Gemini rules file not found yet: ${path.relative(resolved.projectRoot, resolved.rulesFile)}`);
+  }
+
+  if (!fs.existsSync(resolved.agentsDir)) {
+    errors.push(`Missing Gemini agents dir: ${path.relative(resolved.projectRoot, resolved.agentsDir)}`);
+  }
+  if (!fs.existsSync(resolved.commandsDir)) {
+    errors.push(`Missing Gemini commands dir: ${path.relative(resolved.projectRoot, resolved.commandsDir)}`);
+  }
+
+  const sourceCount = countMarkdownFiles(resolved.sourceAgentsDir);
+  const geminiCount = countMarkdownFiles(resolved.agentsDir);
+  const commandFiles = fs.existsSync(resolved.commandsDir)
+    ? fs.readdirSync(resolved.commandsDir).filter((f) => f.endsWith('.toml'))
+    : [];
+  const expectedCommandCount = sourceCount > 0 ? sourceCount + 1 : 0;
+
+  if (sourceCount > 0 && commandFiles.length !== expectedCommandCount) {
+    warnings.push(`Gemini command count differs from source (${commandFiles.length}/${expectedCommandCount})`);
+  }
+  if (!commandFiles.includes('aios-menu.toml')) {
+    errors.push(`Missing Gemini command file: ${path.relative(resolved.projectRoot, path.join(resolved.commandsDir, 'aios-menu.toml'))}`);
+  }
+  if (sourceCount > 0 && geminiCount !== sourceCount) {
+    warnings.push(`Gemini agent count differs from source (${geminiCount}/${sourceCount})`);
+  }
+
+  const requiredExtensionFiles = [
+    'extension.json',
+    'README.md',
+    path.join('commands', 'aios-status.js'),
+    path.join('commands', 'aios-agents.js'),
+    path.join('commands', 'aios-validate.js'),
+    path.join('hooks', 'hooks.json'),
+  ];
+
+  for (const rel of requiredExtensionFiles) {
+    const abs = path.join(resolved.extensionDir, rel);
+    if (!fs.existsSync(abs)) {
+      errors.push(`Missing Gemini extension file: ${path.relative(resolved.projectRoot, abs)}`);
+    }
+  }
+
+  return {
+    ok: errors.length === 0,
+    errors,
+    warnings,
+    metrics: {
+      sourceAgents: sourceCount,
+      geminiAgents: geminiCount,
+      geminiCommands: commandFiles.length,
+    },
+  };
+}
+
+function formatHumanReport(result) {
+  if (result.ok) {
+    const lines = [
+      `✅ Gemini integration validation passed (agents: ${result.metrics.geminiAgents}, commands: ${result.metrics.geminiCommands})`,
+    ];
+    if (result.warnings.length > 0) {
+      lines.push(...result.warnings.map((w) => `⚠️ ${w}`));
+    }
+    return lines.join('\n');
+  }
+  const lines = [
+    `❌ Gemini integration validation failed (${result.errors.length} issue(s))`,
+    ...result.errors.map((e) => `- ${e}`),
+  ];
+  if (result.warnings.length > 0) {
+    lines.push(...result.warnings.map((w) => `⚠️ ${w}`));
+  }
+  return lines.join('\n');
+}
+
+function main() {
+  const args = parseArgs();
+  const result = validateGeminiIntegration(args);
+
+  if (!args.quiet) {
+    if (args.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log(formatHumanReport(result));
+    }
+  }
+
+  if (!result.ok) {
+    process.exitCode = 1;
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  validateGeminiIntegration,
+  parseArgs,
+  getDefaultOptions,
+  countMarkdownFiles,
+};

package/.aios-core/infrastructure/scripts/validate-parity.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+'use strict';
+
+const path = require('path');
+const { spawnSync } = require('child_process');
+const { validateClaudeIntegration } = require('./validate-claude-integration');
+const { validateCodexIntegration } = require('./validate-codex-integration');
+const { validateGeminiIntegration } = require('./validate-gemini-integration');
+const { validateCodexSkills } = require('./codex-skills-sync/validate');
+const { validatePaths } = require('./validate-paths');
+
+function parseArgs(argv = process.argv.slice(2)) {
+  const args = new Set(argv);
+  return {
+    quiet: args.has('--quiet') || args.has('-q'),
+    json: args.has('--json'),
+  };
+}
+
+function runSyncValidate(ide, projectRoot) {
+  const script = path.join('.aios-core', 'infrastructure', 'scripts', 'ide-sync', 'index.js');
+  const result = spawnSync('node', [script, 'validate', '--ide', ide, '--strict'], {
+    cwd: projectRoot,
+    encoding: 'utf8',
+  });
+  return {
+    ok: result.status === 0,
+    errors: result.status === 0 ? [] : [`Sync validation failed for ${ide}`],
+    warnings: [],
+    raw: result.stdout || result.stderr || '',
+  };
+}
+
+function normalizeResult(input) {
+  if (!input || typeof input !== 'object') {
+    return { ok: false, errors: ['Validator returned invalid result'], warnings: [] };
+  }
+  return {
+    ok: Boolean(input.ok),
+    errors: Array.isArray(input.errors) ? input.errors : [],
+    warnings: Array.isArray(input.warnings) ? input.warnings : [],
+    metrics: input.metrics || {},
+  };
+}
+
+function runParityValidation(options = {}, deps = {}) {
+  const projectRoot = options.projectRoot || process.cwd();
+  const runSync = deps.runSyncValidate || runSyncValidate;
+  const runClaudeIntegration = deps.validateClaudeIntegration || validateClaudeIntegration;
+  const runCodexIntegration = deps.validateCodexIntegration || validateCodexIntegration;
+  const runGeminiIntegration = deps.validateGeminiIntegration || validateGeminiIntegration;
+  const runCodexSkills = deps.validateCodexSkills || validateCodexSkills;
+  const runPaths = deps.validatePaths || validatePaths;
+  const checks = [
+    { id: 'claude-sync', exec: () => runSync('claude-code', projectRoot) },
+    { id: 'claude-integration', exec: () => runClaudeIntegration({ projectRoot }) },
+    { id: 'codex-sync', exec: () => runSync('codex', projectRoot) },
+    { id: 'codex-integration', exec: () => runCodexIntegration({ projectRoot }) },
+    { id: 'gemini-sync', exec: () => runSync('gemini', projectRoot) },
+    { id: 'gemini-integration', exec: () => runGeminiIntegration({ projectRoot }) },
+    { id: 'codex-skills', exec: () => runCodexSkills({ projectRoot, strict: true, quiet: true }) },
+    { id: 'paths', exec: () => runPaths({ projectRoot }) },
+  ];
+
+  const results = checks.map((check) => {
+    const normalized = normalizeResult(check.exec());
+    return { id: check.id, ...normalized };
+  });
+
+  return {
+    ok: results.every((r) => r.ok),
+    checks: results,
+  };
+}
+
+function formatHumanReport(result) {
+  const lines = [];
+  for (const check of result.checks) {
+    lines.push(`${check.ok ? '✅' : '❌'} ${check.id}`);
+    if (check.errors.length > 0) {
+      lines.push(...check.errors.map((e) => `- ${e}`));
+    }
+    if (check.warnings.length > 0) {
+      lines.push(...check.warnings.map((w) => `⚠️ ${w}`));
+    }
+  }
+  lines.push('');
+  lines.push(result.ok ? '✅ Parity validation passed' : '❌ Parity validation failed');
+  return lines.join('\n');
+}
+
+function main() {
+  const args = parseArgs();
+  const result = runParityValidation(args);
+
+  if (!args.quiet) {
+    if (args.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log(formatHumanReport(result));
+    }
+  }
+
+  if (!result.ok) {
+    process.exitCode = 1;
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  parseArgs,
+  runSyncValidate,
+  runParityValidation,
+  normalizeResult,
+  formatHumanReport,
+};