aios-core 2.1.0

package/.aios-core/infrastructure/scripts/_archived/phase3-tools-scripts-validation.js

@@ -0,0 +1,381 @@
+#!/usr/bin/env node
+
+/**
+ * Phase 3: Tools/Scripts/Validation Logic Resolution Script
+ * Story 6.1.7.1 - Task Content Completion
+ * 
+ * Purpose: Resolve ~1,375 TODOs for:
+ * - Task 3.1: Tools descriptions (~685 TODOs)
+ * - Task 3.2: Scripts descriptions (~690 TODOs)
+ * - Task 3.3: Pre/Post-condition validation logic (~690 TODOs)
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const TASKS_DIR = path.join(process.cwd(), '.aios-core', 'tasks');
+const REPORT_FILE = path.join(process.cwd(), '.ai', 'task-3.1-3.2-3.3-phase3-report.json');
+
+// Tools templates by task category
+const TOOLS_BY_CATEGORY = {
+  CREATE: [
+    { tool: 'component-generator', purpose: 'Generate new components from templates', source: '.aios-core/scripts/component-generator.js' },
+    { tool: 'file-system', purpose: 'File creation and validation', source: 'Node.js fs module' },
+  ],
+  MODIFY: [
+    { tool: 'file-system', purpose: 'File reading, modification, and backup', source: 'Node.js fs module' },
+    { tool: 'ast-parser', purpose: 'Parse and modify code safely', source: '.aios-core/utils/ast-parser.js' },
+  ],
+  ANALYZE: [
+    { tool: 'code-analyzer', purpose: 'Static code analysis and metrics', source: '.aios-core/utils/code-analyzer.js' },
+    { tool: 'file-system', purpose: 'Recursive directory traversal', source: 'Node.js fs module' },
+  ],
+  VALIDATE: [
+    { tool: 'validation-engine', purpose: 'Rule-based validation and reporting', source: '.aios-core/utils/validation-engine.js' },
+    { tool: 'schema-validator', purpose: 'JSON/YAML schema validation', source: 'ajv or similar' },
+  ],
+  EXECUTE: [
+    { tool: 'task-runner', purpose: 'Task execution and orchestration', source: '.aios-core/core/task-runner.js' },
+    { tool: 'logger', purpose: 'Execution logging and error tracking', source: '.aios-core/utils/logger.js' },
+  ],
+  DATABASE: [
+    { tool: 'neo4j-driver', purpose: 'Neo4j database connection and query execution', source: 'npm: neo4j-driver' },
+    { tool: 'query-validator', purpose: 'Cypher query syntax validation', source: '.aios-core/utils/db-query-validator.js' },
+  ],
+  DOCUMENTATION: [
+    { tool: 'markdown-renderer', purpose: 'Markdown parsing and rendering', source: 'npm: marked or similar' },
+    { tool: 'template-engine', purpose: 'Document template processing', source: '.aios-core/product/templates/' },
+  ],
+  SECURITY: [
+    { tool: 'security-scanner', purpose: 'Static security analysis and vulnerability detection', source: 'npm: eslint-plugin-security or similar' },
+    { tool: 'dependency-checker', purpose: 'Check for vulnerable dependencies', source: 'npm audit or snyk' },
+  ],
+  INIT: [
+    { tool: 'project-scaffolder', purpose: 'Generate project structure and config', source: '.aios-core/scripts/project-scaffolder.js' },
+    { tool: 'config-manager', purpose: 'Initialize configuration files', source: '.aios-core/utils/config-manager.js' },
+  ],
+  ROLLBACK: [
+    { tool: 'backup-manager', purpose: 'Backup and restore operations', source: '.aios-core/utils/backup-manager.js' },
+    { tool: 'version-control', purpose: 'Git operations for rollback', source: 'npm: simple-git' },
+  ],
+};
+
+// Scripts templates by task category
+const SCRIPTS_BY_CATEGORY = {
+  CREATE: [
+    { script: 'create-component.js', purpose: 'Component creation workflow', language: 'JavaScript', location: '.aios-core/scripts/create-component.js' },
+  ],
+  MODIFY: [
+    { script: 'modify-file.js', purpose: 'Safe file modification with backup', language: 'JavaScript', location: '.aios-core/scripts/modify-file.js' },
+  ],
+  ANALYZE: [
+    { script: 'analyze-codebase.js', purpose: 'Codebase analysis and reporting', language: 'JavaScript', location: '.aios-core/scripts/analyze-codebase.js' },
+  ],
+  VALIDATE: [
+    { script: 'run-validation.js', purpose: 'Execute validation rules and generate report', language: 'JavaScript', location: '.aios-core/scripts/run-validation.js' },
+  ],
+  EXECUTE: [
+    { script: 'execute-task.js', purpose: 'Generic task execution wrapper', language: 'JavaScript', location: '.aios-core/scripts/execute-task.js' },
+  ],
+  DATABASE: [
+    { script: 'db-query.js', purpose: 'Execute Neo4j queries with error handling', language: 'JavaScript', location: '.aios-core/scripts/db-query.js' },
+  ],
+  DOCUMENTATION: [
+    { script: 'generate-docs.js', purpose: 'Documentation generation from templates', language: 'JavaScript', location: '.aios-core/scripts/generate-docs.js' },
+  ],
+  SECURITY: [
+    { script: 'security-scan.js', purpose: 'Run security scans and generate reports', language: 'JavaScript', location: '.aios-core/scripts/security-scan.js' },
+  ],
+  INIT: [
+    { script: 'init-project.js', purpose: 'Project initialization workflow', language: 'JavaScript', location: '.aios-core/scripts/init-project.js' },
+  ],
+  ROLLBACK: [
+    { script: 'rollback-changes.js', purpose: 'Rollback to previous state', language: 'JavaScript', location: '.aios-core/scripts/rollback-changes.js' },
+  ],
+};
+
+// Validation logic templates by task category
+const VALIDATION_TEMPLATES = {
+  preCondition: {
+    CREATE: 'Target does not already exist; required inputs provided; permissions granted',
+    MODIFY: 'Target exists; backup created; valid modification parameters',
+    ANALYZE: 'Target exists and is accessible; analysis tools available',
+    VALIDATE: 'Validation rules loaded; target available for validation',
+    EXECUTE: 'Task is registered; required parameters provided; dependencies met',
+    DATABASE: 'Database connection established; query syntax valid',
+    DOCUMENTATION: 'Template exists; source data available',
+    SECURITY: 'Scanner available; target accessible; rules configured',
+    INIT: 'Directory is empty or force flag set; config valid',
+    ROLLBACK: 'Backup exists; rollback target valid',
+  },
+  postCondition: {
+    CREATE: 'Resource created successfully; validation passed; no errors logged',
+    MODIFY: 'Modification applied; backup preserved; integrity verified',
+    ANALYZE: 'Analysis complete; report generated; no critical issues',
+    VALIDATE: 'Validation executed; results accurate; report generated',
+    EXECUTE: 'Task completed; exit code 0; expected outputs created',
+    DATABASE: 'Query executed; results returned; transaction committed',
+    DOCUMENTATION: 'Documentation generated; format valid; links working',
+    SECURITY: 'Scan completed; vulnerabilities reported; no scan errors',
+    INIT: 'Project initialized; config files created; structure valid',
+    ROLLBACK: 'State restored; integrity verified; no data loss',
+  },
+  acceptanceCriterion: {
+    CREATE: 'Resource exists and is valid; no duplicate resources created',
+    MODIFY: 'Changes applied correctly; original backed up; rollback possible',
+    ANALYZE: 'Analysis accurate; all targets covered; report complete',
+    VALIDATE: 'Validation rules applied; pass/fail accurate; actionable feedback',
+    EXECUTE: 'Task completed as expected; side effects documented',
+    DATABASE: 'Data persisted correctly; constraints respected; no orphaned data',
+    DOCUMENTATION: 'Documentation readable; examples work; links valid',
+    SECURITY: 'No critical vulnerabilities; all checks passed',
+    INIT: 'Project structure correct; all config files valid',
+    ROLLBACK: 'Original state restored; no residual changes',
+  },
+};
+
+// Determine task category from filename
+function getTaskCategory(filename) {
+  const categories = {
+    CREATE: ['create-', 'compose-', 'build-', 'generate-'],
+    MODIFY: ['modify-', 'update-', 'extend-', 'edit-'],
+    ANALYZE: ['analyze-', 'audit-', 'review-', 'risk-'],
+    VALIDATE: ['validate-', 'qa-', 'gate-', 'check-'],
+    EXECUTE: ['execute-', 'run-', 'apply-', 'deploy-'],
+    DATABASE: ['db-'],
+    DOCUMENTATION: ['doc-', 'index-'],
+    SECURITY: ['security-'],
+    INIT: ['init-', 'setup-'],
+    ROLLBACK: ['undo-', 'rollback-'],
+  };
+  
+  for (const [category, prefixes] of Object.entries(categories)) {
+    for (const prefix of prefixes) {
+      if (filename.startsWith(prefix)) {
+        return category;
+      }
+    }
+  }
+  return 'EXECUTE'; // Default
+}
+
+// Format Tools section
+function formatToolsSection(tools) {
+  if (tools.length === 0) {
+    return `- **Tool:** N/A
+  - **Purpose:** No external tools required
+  - **Source:** N/A`;
+  }
+  
+  return tools.map(t => `- **Tool:** ${t.tool}
+  - **Purpose:** ${t.purpose}
+  - **Source:** ${t.source}`).join('\n\n');
+}
+
+// Format Scripts section
+function formatScriptsSection(scripts) {
+  if (scripts.length === 0) {
+    return `- **Script:** N/A
+  - **Purpose:** No agent-specific scripts
+  - **Language:** N/A
+  - **Location:** N/A`;
+  }
+  
+  return scripts.map(s => `- **Script:** ${s.script}
+  - **Purpose:** ${s.purpose}
+  - **Language:** ${s.language}
+  - **Location:** ${s.location}`).join('\n\n');
+}
+
+// Process single task file
+function processTaskFile(filename) {
+  const filePath = path.join(TASKS_DIR, filename);
+  
+  // Skip backup files
+  if (filename.includes('.pre-task-id-fix') || filename.includes('.v1-backup')) {
+    return { skipped: true, reason: 'backup file' };
+  }
+  
+  let content = fs.readFileSync(filePath, 'utf8');
+  let modified = false;
+  const todosResolved = { tools: 0, scripts: 0, validation: 0 };
+  
+  // Determine task category
+  const category = getTaskCategory(filename);
+  const tools = TOOLS_BY_CATEGORY[category] || [];
+  const scripts = SCRIPTS_BY_CATEGORY[category] || [];
+  
+  // Task 3.1: Resolve Tools section
+  const toolsPattern = /- \*\*Tool:\*\* N\/A\n {2}- \*\*Purpose:\*\* \{TODO: what this tool does\}\n {2}- \*\*Source:\*\* \{TODO: where to find it\}/;
+  if (toolsPattern.test(content)) {
+    content = content.replace(toolsPattern, formatToolsSection(tools));
+    modified = true;
+    todosResolved.tools += 2; // Purpose + Source
+  }
+  
+  // Task 3.2: Resolve Scripts section
+  const scriptsPattern = /- \*\*Script:\*\* N\/A\n {2}- \*\*Purpose:\*\* \{TODO: what this script does\}\n {2}- \*\*Language:\*\* \{TODO: JavaScript \| Python \| Bash\}\n {2}- \*\*Location:\*\* \{TODO: file path\}/;
+  if (scriptsPattern.test(content)) {
+    content = content.replace(scriptsPattern, formatScriptsSection(scripts));
+    modified = true;
+    todosResolved.scripts += 3; // Purpose + Language + Location
+  }
+  
+  // Task 3.3: Resolve Pre-Conditions validation
+  const preCondPattern = /- \[ \] \{TODO: condition description\}\n {4}tipo: pre-condition\n {4}blocker: true\n {4}validação: \|\n {6}\{TODO: validation logic\}\n {4}error_message: "\{TODO: error message\}"/g;
+  const preCondValidation = VALIDATION_TEMPLATES.preCondition[category] || 'Prerequisites validated';
+  const preCondReplacement = `- [ ] ${preCondValidation}
+    tipo: pre-condition
+    blocker: true
+    validação: |
+      Check ${preCondValidation.toLowerCase()}
+    error_message: "Pre-condition failed: ${preCondValidation}"`;
+  
+  const preCondMatches = content.match(preCondPattern);
+  if (preCondMatches) {
+    content = content.replace(preCondPattern, preCondReplacement);
+    modified = true;
+    todosResolved.validation += preCondMatches.length * 3; // condition + validation + error_message
+  }
+  
+  // Task 3.3: Resolve Post-Conditions validation
+  const postCondPattern = /- \[ \] \{TODO: verification step\}\n {4}tipo: post-condition\n {4}blocker: true\n {4}validação: \|\n {6}\{TODO: validation logic\}\n {4}error_message: "\{TODO: error message\}"/g;
+  const postCondValidation = VALIDATION_TEMPLATES.postCondition[category] || 'Task completed successfully';
+  const postCondReplacement = `- [ ] ${postCondValidation}
+    tipo: post-condition
+    blocker: true
+    validação: |
+      Verify ${postCondValidation.toLowerCase()}
+    error_message: "Post-condition failed: ${postCondValidation}"`;
+  
+  const postCondMatches = content.match(postCondPattern);
+  if (postCondMatches) {
+    content = content.replace(postCondPattern, postCondReplacement);
+    modified = true;
+    todosResolved.validation += postCondMatches.length * 3;
+  }
+  
+  // Task 3.3: Resolve Acceptance Criteria validation
+  const acceptancePattern = /- \[ \] \{TODO: acceptance criterion\}\n {4}tipo: acceptance-criterion\n {4}blocker: true\n {4}validação: \|\n {6}\{TODO: validation logic\}\n {4}error_message: "\{TODO: error message\}"/g;
+  const acceptanceValidation = VALIDATION_TEMPLATES.acceptanceCriterion[category] || 'Acceptance criteria met';
+  const acceptanceReplacement = `- [ ] ${acceptanceValidation}
+    tipo: acceptance-criterion
+    blocker: true
+    validação: |
+      Assert ${acceptanceValidation.toLowerCase()}
+    error_message: "Acceptance criterion not met: ${acceptanceValidation}"`;
+  
+  const acceptanceMatches = content.match(acceptancePattern);
+  if (acceptanceMatches) {
+    content = content.replace(acceptancePattern, acceptanceReplacement);
+    modified = true;
+    todosResolved.validation += acceptanceMatches.length * 3;
+  }
+  
+  // Write back if modified
+  if (modified) {
+    fs.writeFileSync(filePath, content, 'utf8');
+  }
+  
+  return {
+    skipped: false,
+    modified,
+    category,
+    todosResolved,
+  };
+}
+
+// Main execution
+function main() {
+  console.log('🚀 Phase 3: Tools/Scripts/Validation Resolution');
+  console.log('=================================================\n');
+  
+  // Ensure report directory exists
+  const reportDir = path.dirname(REPORT_FILE);
+  if (!fs.existsSync(reportDir)) {
+    fs.mkdirSync(reportDir, { recursive: true });
+  }
+  
+  // Get all task files
+  const files = fs.readdirSync(TASKS_DIR).filter(f => f.endsWith('.md'));
+  console.log(`📁 Found ${files.length} task files\n`);
+  
+  const results = {
+    timestamp: new Date().toISOString(),
+    totalFiles: files.length,
+    processed: 0,
+    skipped: 0,
+    modified: 0,
+    todosCounts: {
+      tools: 0,
+      scripts: 0,
+      validation: 0,
+      total: 0,
+    },
+    tasksByCategory: {},
+    details: [],
+  };
+  
+  // Process each file
+  files.forEach((filename, index) => {
+    const result = processTaskFile(filename);
+    
+    if (result.skipped) {
+      results.skipped++;
+      console.log(`⏭️  [${index + 1}/${files.length}] Skipped: ${filename} (${result.reason})`);
+    } else {
+      results.processed++;
+      if (result.modified) {
+        results.modified++;
+        const totalTodos = result.todosResolved.tools + result.todosResolved.scripts + result.todosResolved.validation;
+        results.todosCounts.tools += result.todosResolved.tools;
+        results.todosCounts.scripts += result.todosResolved.scripts;
+        results.todosCounts.validation += result.todosResolved.validation;
+        results.todosCounts.total += totalTodos;
+        
+        // Track by category
+        if (!results.tasksByCategory[result.category]) {
+          results.tasksByCategory[result.category] = 0;
+        }
+        results.tasksByCategory[result.category]++;
+        
+        console.log(`✅ [${index + 1}/${files.length}] ${filename} (${result.category}): ${totalTodos} TODOs resolved`);
+      } else {
+        console.log(`⚪ [${index + 1}/${files.length}] ${filename}: No changes needed`);
+      }
+      
+      results.details.push({
+        filename,
+        ...result,
+      });
+    }
+  });
+  
+  // Summary
+  console.log('\n📊 Summary:');
+  console.log('===========');
+  console.log(`Total files: ${results.totalFiles}`);
+  console.log(`Processed: ${results.processed}`);
+  console.log(`Skipped: ${results.skipped}`);
+  console.log(`Modified: ${results.modified}`);
+  console.log('\nTODOs Resolved:');
+  console.log(`  Tools descriptions: ${results.todosCounts.tools}`);
+  console.log(`  Scripts descriptions: ${results.todosCounts.scripts}`);
+  console.log(`  Validation logic: ${results.todosCounts.validation}`);
+  console.log(`  TOTAL: ${results.todosCounts.total}`);
+  console.log('\nTasks by Category:');
+  Object.entries(results.tasksByCategory).forEach(([cat, count]) => {
+    console.log(`  ${cat}: ${count} tasks`);
+  });
+  
+  // Write report
+  fs.writeFileSync(REPORT_FILE, JSON.stringify(results, null, 2));
+  console.log(`\n✅ Report saved: ${REPORT_FILE}`);
+  
+  // Exit with success
+  process.exit(0);
+}
+
+// Run
+main();
+

package/.aios-core/infrastructure/scripts/_archived/phase4-metadata-performance.js

@@ -0,0 +1,203 @@
+#!/usr/bin/env node
+
+/**
+ * Phase 4: Metadata & Performance TODOs Resolution Script
+ * Story 6.1.7.1 - Task Content Completion
+ * 
+ * Resolves remaining TODOs in:
+ * - Performance section (token_usage, optimization notes)
+ * - Metadata section (story, dependencies, tags)
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const TASKS_DIR = path.join(process.cwd(), '.aios-core', 'tasks');
+const REPORT_FILE = path.join(process.cwd(), '.ai', 'task-phase4-metadata-performance-report.json');
+
+// Performance token usage by atomic layer
+const TOKEN_USAGE_BY_LAYER = {
+  Atom: '~500-1,000 tokens',
+  Molecule: '~1,000-3,000 tokens',
+  Organism: '~3,000-10,000 tokens',
+  Template: '~1,500-5,000 tokens',
+  Strategy: '~2,000-8,000 tokens',
+  Config: '~800-2,500 tokens',
+};
+
+// Optimization notes by atomic layer
+const OPTIMIZATION_NOTES_BY_LAYER = {
+  Atom: 'Minimize external dependencies; cache results if reusable; validate inputs early',
+  Molecule: 'Parallelize independent operations; reuse atom results; implement early exits',
+  Organism: 'Break into smaller workflows; implement checkpointing; use async processing where possible',
+  Template: 'Cache template compilation; minimize data transformations; lazy load resources',
+  Strategy: 'Iterative analysis with depth limits; cache intermediate results; batch similar operations',
+  Config: 'Validate configuration early; use atomic writes; implement rollback checkpoints',
+};
+
+// Process single task file
+function processTaskFile(filename) {
+  const filePath = path.join(TASKS_DIR, filename);
+  
+  // Skip backup files
+  if (filename.includes('.pre-task-id-fix') || filename.includes('.v1-backup')) {
+    return { skipped: true, reason: 'backup file' };
+  }
+  
+  let content = fs.readFileSync(filePath, 'utf8');
+  let modified = false;
+  let todosResolved = 0;
+  
+  // Extract atomic_layer for context
+  const atomicLayerMatch = content.match(/atomic_layer: (\w+)/);
+  const atomicLayer = atomicLayerMatch ? atomicLayerMatch[1] : 'Organism';
+  
+  const tokenUsage = TOKEN_USAGE_BY_LAYER[atomicLayer] || '~2,000-5,000 tokens';
+  const optimizationNotes = OPTIMIZATION_NOTES_BY_LAYER[atomicLayer] || 'Optimize based on task requirements';
+  
+  // Resolve token_usage TODO
+  const tokenPattern = /token_usage: \{TODO: ~X tokens\}/g;
+  if (tokenPattern.test(content)) {
+    content = content.replace(tokenPattern, `token_usage: ${tokenUsage}`);
+    modified = true;
+    todosResolved++;
+  }
+  
+  // Resolve optimization notes TODO
+  const optimizationPattern = /- \{TODO: performance tips\}/g;
+  if (optimizationPattern.test(content)) {
+    content = content.replace(optimizationPattern, `- ${optimizationNotes}`);
+    modified = true;
+    todosResolved++;
+  }
+  
+  // Resolve story TODO (N/A for now, will be filled when tasks are used in stories)
+  const storyPattern = /story: \{TODO: Story ID or N\/A\}/g;
+  if (storyPattern.test(content)) {
+    content = content.replace(storyPattern, 'story: N/A');
+    modified = true;
+    todosResolved++;
+  }
+  
+  // Resolve dependencies TODO
+  const dependenciesPattern = / {2}- \{TODO: dependency file or N\/A\}/g;
+  if (dependenciesPattern.test(content)) {
+    content = content.replace(dependenciesPattern, '  - N/A');
+    modified = true;
+    todosResolved++;
+  }
+  
+  // Resolve tags TODO
+  const tag1Pattern = / {2}- \{TODO: tag1\}/g;
+  const tag2Pattern = / {2}- \{TODO: tag2\}/g;
+  
+  // Determine appropriate tags based on task category
+  const tags = [];
+  if (filename.startsWith('dev-')) tags.push('development', 'code');
+  else if (filename.startsWith('qa-')) tags.push('quality-assurance', 'testing');
+  else if (filename.startsWith('po-')) tags.push('product-management', 'planning');
+  else if (filename.startsWith('db-')) tags.push('database', 'infrastructure');
+  else if (filename.startsWith('security-')) tags.push('security', 'audit');
+  else if (filename.includes('create-')) tags.push('creation', 'setup');
+  else if (filename.includes('analyze-')) tags.push('analysis', 'metrics');
+  else if (filename.includes('modify-')) tags.push('modification', 'update');
+  else tags.push('automation', 'workflow');
+  
+  if (tag1Pattern.test(content)) {
+    content = content.replace(tag1Pattern, `  - ${tags[0] || 'automation'}`);
+    modified = true;
+    todosResolved++;
+  }
+  
+  if (tag2Pattern.test(content)) {
+    content = content.replace(tag2Pattern, `  - ${tags[1] || 'workflow'}`);
+    modified = true;
+    todosResolved++;
+  }
+  
+  // Write back if modified
+  if (modified) {
+    fs.writeFileSync(filePath, content, 'utf8');
+  }
+  
+  return {
+    skipped: false,
+    modified,
+    atomicLayer,
+    todosResolved,
+  };
+}
+
+// Main execution
+function main() {
+  console.log('🚀 Phase 4: Metadata & Performance Resolution');
+  console.log('==============================================\n');
+  
+  // Ensure report directory exists
+  const reportDir = path.dirname(REPORT_FILE);
+  if (!fs.existsSync(reportDir)) {
+    fs.mkdirSync(reportDir, { recursive: true });
+  }
+  
+  // Get all task files
+  const files = fs.readdirSync(TASKS_DIR).filter(f => f.endsWith('.md'));
+  console.log(`📁 Found ${files.length} task files\n`);
+  
+  const results = {
+    timestamp: new Date().toISOString(),
+    totalFiles: files.length,
+    processed: 0,
+    skipped: 0,
+    modified: 0,
+    todosResolved: 0,
+    details: [],
+  };
+  
+  // Process each file
+  files.forEach((filename, index) => {
+    const result = processTaskFile(filename);
+    
+    if (result.skipped) {
+      results.skipped++;
+      if (index < 10) {
+        console.log(`⏭️  [${index + 1}/${files.length}] Skipped: ${filename} (${result.reason})`);
+      }
+    } else {
+      results.processed++;
+      if (result.modified) {
+        results.modified++;
+        results.todosResolved += result.todosResolved;
+        console.log(`✅ [${index + 1}/${files.length}] ${filename}: ${result.todosResolved} TODOs resolved`);
+      } else {
+        if (index < 10) {
+          console.log(`⚪ [${index + 1}/${files.length}] ${filename}: No changes needed`);
+        }
+      }
+      
+      results.details.push({
+        filename,
+        ...result,
+      });
+    }
+  });
+  
+  // Summary
+  console.log('\n📊 Summary:');
+  console.log('===========');
+  console.log(`Total files: ${results.totalFiles}`);
+  console.log(`Processed: ${results.processed}`);
+  console.log(`Skipped: ${results.skipped}`);
+  console.log(`Modified: ${results.modified}`);
+  console.log(`TODOs Resolved: ${results.todosResolved}`);
+  
+  // Write report
+  fs.writeFileSync(REPORT_FILE, JSON.stringify(results, null, 2));
+  console.log(`\n✅ Report saved: ${REPORT_FILE}`);
+  
+  // Exit with success
+  process.exit(0);
+}
+
+// Run
+main();
+

package/.aios-core/infrastructure/scripts/_archived/test-yaml-parsing.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const yaml = require('js-yaml');
+const path = require('path');
+
+const agentPath = path.join(__dirname, '..', 'agents', 'po.md');
+const content = fs.readFileSync(agentPath, 'utf8');
+const yamlMatch = content.match(/```yaml([\s\S]*?)```/);
+
+if (yamlMatch) {
+  try {
+    const agent = yaml.load(yamlMatch[1]);
+    console.log('✅ YAML parsed successfully!');
+    console.log('Agent:', agent.agent.name);
+    console.log('STEP 3 type:', typeof agent['activation-instructions'][2]);
+    console.log('STEP 3 preview:', agent['activation-instructions'][2].substring(0, 150) + '...');
+  } catch (error) {
+    console.log('❌ YAML parsing failed:', error.message);
+    process.exit(1);
+  }
+} else {
+  console.log('❌ No YAML block found');
+  process.exit(1);
+}

package/.aios-core/infrastructure/scripts/_archived/verify-yaml-fix.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const yaml = require('js-yaml');
+const path = require('path');
+
+console.log('🔍 Verifying YAML Fix\n');
+
+const AGENTS = [
+  'dev.md', 'qa.md', 'po.md', 'sm.md', 'pm.md',
+  'architect.md', 'analyst.md', 'data-engineer.md',
+  'devops.md', 'aios-master.md', 'ux-design-expert.md',
+];
+
+let passCount = 0;
+let failCount = 0;
+
+for (const agentFile of AGENTS) {
+  const agentPath = path.join(__dirname, '..', 'agents', agentFile);
+  const content = fs.readFileSync(agentPath, 'utf8');
+  const yamlMatch = content.match(/```yaml([\s\S]*?)```/);
+
+  try {
+    const agent = yaml.load(yamlMatch[1]);
+    const step3 = agent['activation-instructions'][2];
+
+    // STEP 3 should now be an object with "STEP 3" key containing multi-line string
+    if (typeof step3 === 'object' && step3['STEP 3']) {
+      console.log(`✅ ${agentFile.padEnd(25)} - YAML valid, pipe syntax working`);
+      passCount++;
+    } else if (typeof step3 === 'string' && step3.includes('Build intelligent greeting')) {
+      console.log(`✅ ${agentFile.padEnd(25)} - YAML valid`);
+      passCount++;
+    } else {
+      console.log(`⚠️  ${agentFile.padEnd(25)} - Unexpected format: ${typeof step3}`);
+      failCount++;
+    }
+  } catch (error) {
+    console.log(`❌ ${agentFile.padEnd(25)} - Parse error: ${error.message.substring(0, 50)}`);
+    failCount++;
+  }
+}
+
+console.log(`\n📊 Results: ${passCount}/${AGENTS.length} agents valid`);
+
+if (failCount === 0) {
+  console.log('✅ All agents have valid YAML!');
+  process.exit(0);
+} else {
+  console.log(`❌ ${failCount} agents have issues`);
+  process.exit(1);
+}