@girardmedia/bootspring 2.0.22 → 2.0.23

package/intelligence/orchestrator.js

@@ -17,24 +17,24 @@ const fs = require('fs');
 const path = require('path');
 const telemetry = require('../core/telemetry');
 
-// Paths (resolved relative to bootspring package)
-function getPaths() {
-  // Find the bootspring directory
-  let bootspringDir = __dirname;
-  while (!fs.existsSync(path.join(bootspringDir, 'package.json')) && bootspringDir !== '/') {
-    bootspringDir = path.dirname(bootspringDir);
-  }
-
-  const projectRoot = process.cwd();
+// Import from extracted modules
+const {
+  PHASE_AGENTS,
+  TECHNICAL_TRIGGERS,
+  WORKFLOWS,
+  REMEDIATION_PATHS,
+  FAILURE_SIGNATURES,
+  SEVERITY_WEIGHTS,
+  PARALLEL_FAILURE_STRATEGIES
+} = require('./orchestrator/config');
 
-  return {
-    bootspringDir,
-    projectRoot,
-    agentsDir: path.join(bootspringDir, 'agents', 'profiles'),
-    statePath: path.join(projectRoot, '.bootspring', 'orchestrator-state.json'),
-    roadmapPath: path.join(projectRoot, 'ROADMAP.md')
-  };
-}
+const {
+  getPaths,
+  createDefaultState,
+  loadState,
+  saveState,
+  emitWorkflowTelemetry
+} = require('./orchestrator/core');
 
 // Colors
 const c = {
@@ -49,308 +49,8 @@ const c = {
   magenta: '\x1b[35m'
 };
 
-/**
- * Agent lifecycle phase mapping
- * Maps project phases to recommended agents
- */
-const PHASE_AGENTS = {
-  1: {
-    name: 'Foundation',
-    description: 'Initial setup, planning, and architecture decisions',
-    primary: ['architecture-expert', 'database-expert'],
-    supporting: ['security-expert', 'devops-expert']
-  },
-  2: {
-    name: 'Requirements',
-    description: 'Data modeling, research, and specification',
-    primary: ['database-expert', 'api-expert'],
-    supporting: ['testing-expert']
-  },
-  3: {
-    name: 'Design',
-    description: 'UI/UX, database schema, API contracts',
-    primary: ['frontend-expert', 'ui-ux-expert', 'database-expert', 'api-expert'],
-    supporting: ['security-expert']
-  },
-  4: {
-    name: 'Implementation',
-    description: 'Core feature development',
-    primary: ['backend-expert', 'frontend-expert', 'database-expert'],
-    supporting: ['performance-expert', 'code-review-expert']
-  },
-  5: {
-    name: 'Testing',
-    description: 'Quality assurance and security review',
-    primary: ['testing-expert', 'security-expert', 'code-review-expert'],
-    supporting: ['performance-expert']
-  },
-  6: {
-    name: 'Deployment',
-    description: 'CI/CD, infrastructure, and monitoring',
-    primary: ['devops-expert', 'vercel-expert'],
-    supporting: ['security-expert', 'performance-expert']
-  },
-  7: {
-    name: 'Launch',
-    description: 'Go-live and post-launch optimization',
-    primary: ['devops-expert', 'performance-expert'],
-    supporting: ['security-expert']
-  }
-};
 
-/**
- * Technical context triggers
- * Maps keywords to recommended agents
- */
-const TECHNICAL_TRIGGERS = {
-  'api': {
-    agents: ['api-expert', 'backend-expert', 'security-expert'],
-    indicators: ['api', 'endpoint', 'REST', 'GraphQL', 'route', 'handler'],
-    skills: ['api/route-handler', 'api/server-action']
-  },
-  'database': {
-    agents: ['database-expert', 'backend-expert'],
-    indicators: ['database', 'schema', 'prisma', 'migration', 'query', 'model', 'sql'],
-    skills: ['database/prisma']
-  },
-  'frontend': {
-    agents: ['frontend-expert', 'ui-ux-expert'],
-    indicators: ['component', 'react', 'tailwind', 'ui', 'ux', 'page', 'layout', 'css'],
-    skills: []
-  },
-  'authentication': {
-    agents: ['security-expert', 'backend-expert'],
-    indicators: ['auth', 'login', 'signup', 'session', 'clerk', 'jwt', 'oauth', 'password'],
-    skills: ['auth/clerk', 'auth/nextauth']
-  },
-  'security': {
-    agents: ['security-expert'],
-    indicators: ['security', 'vulnerability', 'OWASP', 'xss', 'csrf', 'injection', 'sanitize'],
-    skills: []
-  },
-  'performance': {
-    agents: ['performance-expert', 'database-expert'],
-    indicators: ['performance', 'speed', 'optimization', 'cache', 'slow', 'memory', 'bundle'],
-    skills: []
-  },
-  'deployment': {
-    agents: ['devops-expert', 'vercel-expert'],
-    indicators: ['deploy', 'CI/CD', 'docker', 'kubernetes', 'production', 'vercel', 'hosting'],
-    skills: []
-  },
-  'testing': {
-    agents: ['testing-expert', 'code-review-expert'],
-    indicators: ['test', 'jest', 'vitest', 'playwright', 'coverage', 'spec', 'mock'],
-    skills: ['testing/vitest']
-  },
-  'payments': {
-    agents: ['backend-expert', 'security-expert'],
-    indicators: ['stripe', 'payment', 'subscription', 'checkout', 'billing', 'invoice'],
-    skills: ['payments/stripe']
-  }
-};
 
-/**
- * Predefined workflows for common scenarios
- */
-const WORKFLOWS = {
-  'feature-development': {
-    name: 'Feature Development',
-    description: 'End-to-end feature implementation workflow',
-    tier: 'free',
-    pack: null,
-    outcomes: ['Feature shipped with tests and review complete'],
-    completionSignals: ['PR merged', 'Tests passing in CI', 'Security/perf review completed'],
-    phases: [
-      { name: 'Design', agents: ['ui-ux-expert', 'frontend-expert', 'api-expert'], duration: '1-2 days' },
-      { name: 'Implementation', agents: ['backend-expert', 'frontend-expert', 'database-expert'], duration: '2-5 days' },
-      { name: 'Testing', agents: ['testing-expert', 'code-review-expert'], duration: '1-2 days' },
-      { name: 'Review', agents: ['security-expert', 'performance-expert'], duration: '1 day' }
-    ]
-  },
-  'security-audit': {
-    name: 'Security Audit',
-    description: 'Comprehensive security review',
-    tier: 'free',
-    pack: null,
-    outcomes: ['Critical/high vulnerabilities remediated'],
-    completionSignals: ['Security findings closed', 'Post-fix verification complete'],
-    phases: [
-      { name: 'Code Review', agents: ['code-review-expert', 'security-expert'], duration: '2-3 days' },
-      { name: 'Vulnerability Scan', agents: ['security-expert'], duration: '1 day' },
-      { name: 'Remediation', agents: ['security-expert', 'backend-expert'], duration: '2-5 days' }
-    ]
-  },
-  'performance-optimization': {
-    name: 'Performance Optimization',
-    description: 'Full performance review and optimization',
-    tier: 'free',
-    pack: null,
-    outcomes: ['Performance regressions reduced and hotspots addressed'],
-    completionSignals: ['Baseline captured', 'Improvement report documented'],
-    phases: [
-      { name: 'Analysis', agents: ['performance-expert'], duration: '1-2 days' },
-      { name: 'Database', agents: ['database-expert', 'performance-expert'], duration: '2-3 days' },
-      { name: 'Frontend', agents: ['frontend-expert', 'performance-expert'], duration: '2-3 days' },
-      { name: 'Infrastructure', agents: ['devops-expert'], duration: '1-2 days' }
-    ]
-  },
-  'api-development': {
-    name: 'API Development',
-    description: 'Design and implement new API endpoints',
-    tier: 'free',
-    pack: null,
-    outcomes: ['API endpoints delivered with security and test coverage'],
-    completionSignals: ['Contract approved', 'API tests passing', 'Auth/rate limits verified'],
-    phases: [
-      { name: 'Design', agents: ['api-expert', 'database-expert'], duration: '1 day' },
-      { name: 'Implementation', agents: ['backend-expert', 'api-expert'], duration: '2-3 days' },
-      { name: 'Security', agents: ['security-expert'], duration: '1 day' },
-      { name: 'Testing', agents: ['testing-expert'], duration: '1 day' }
-    ]
-  },
-  'database-migration': {
-    name: 'Database Migration',
-    description: 'Schema changes and data migration',
-    tier: 'free',
-    pack: null,
-    outcomes: ['Migration completed safely with rollback readiness'],
-    completionSignals: ['Migration rehearsed', 'Rollback tested', 'Data integrity checks passing'],
-    phases: [
-      { name: 'Schema Design', agents: ['database-expert'], duration: '1 day' },
-      { name: 'Migration Plan', agents: ['database-expert', 'devops-expert'], duration: '1 day' },
-      { name: 'Implementation', agents: ['database-expert', 'backend-expert'], duration: '2-3 days' },
-      { name: 'Verification', agents: ['testing-expert'], duration: '1 day' }
-    ]
-  },
-  'launch-preparation': {
-    name: 'Launch Preparation',
-    description: 'Pre-launch checklist and deployment',
-    tier: 'free',
-    pack: null,
-    outcomes: ['Launch readiness validated across quality, security, and ops'],
-    completionSignals: ['Release checklist complete', 'Monitoring configured', 'Rollback plan confirmed'],
-    phases: [
-      { name: 'Testing', agents: ['testing-expert', 'performance-expert'], duration: '2-3 days' },
-      { name: 'Security', agents: ['security-expert'], duration: '1-2 days' },
-      { name: 'Deployment', agents: ['devops-expert', 'vercel-expert'], duration: '1 day' },
-      { name: 'Monitoring', agents: ['devops-expert', 'performance-expert'], duration: '1 day' }
-    ]
-  },
-  'launch-pack': {
-    name: 'Launch Pack',
-    description: 'Premium guided launch workflow from freeze to production validation',
-    tier: 'pro',
-    pack: 'launch',
-    outcomes: ['Production launch completed with no P0 regressions in first 48h'],
-    completionSignals: ['Change freeze checklist complete', 'Launch playbook executed', 'Post-launch metrics healthy'],
-    phases: [
-      { name: 'Readiness Gate', agents: ['testing-expert', 'security-expert', 'performance-expert'], duration: '1-2 days' },
-      { name: 'Cutover Plan', agents: ['devops-expert', 'architecture-expert'], duration: '1 day' },
-      { name: 'Go-Live', agents: ['devops-expert', 'vercel-expert'], duration: 'same day' },
-      { name: 'Stabilization', agents: ['performance-expert', 'backend-expert'], duration: '2 days' }
-    ]
-  },
-  'reliability-pack': {
-    name: 'Reliability Pack',
-    description: 'Premium reliability hardening workflow for incidents and regressions',
-    tier: 'pro',
-    pack: 'reliability',
-    outcomes: ['Error budget burn reduced and top incident classes mitigated'],
-    completionSignals: ['SLOs defined', 'Top 3 failure modes mitigated', 'Runbooks verified in drill'],
-    phases: [
-      { name: 'Reliability Baseline', agents: ['performance-expert', 'devops-expert'], duration: '1 day' },
-      { name: 'Failure Mode Audit', agents: ['security-expert', 'backend-expert'], duration: '1-2 days' },
-      { name: 'Resilience Implementation', agents: ['backend-expert', 'database-expert'], duration: '2-4 days' },
-      { name: 'Game Day Validation', agents: ['testing-expert', 'devops-expert'], duration: '1 day' }
-    ]
-  },
-  'growth-pack': {
-    name: 'Growth Pack',
-    description: 'Premium experimentation workflow for activation and conversion improvements',
-    tier: 'pro',
-    pack: 'growth',
-    outcomes: ['Primary growth KPI improved with statistically valid experiment result'],
-    completionSignals: ['North-star metric selected', 'Experiment shipped', 'Readout documented with decision'],
-    phases: [
-      { name: 'Metric Design', agents: ['architecture-expert', 'frontend-expert'], duration: '1 day' },
-      { name: 'Instrumentation', agents: ['backend-expert', 'api-expert'], duration: '1-2 days' },
-      { name: 'Experiment Build', agents: ['frontend-expert', 'backend-expert'], duration: '2-3 days' },
-      { name: 'Analysis & Decision', agents: ['code-review-expert', 'architecture-expert'], duration: '1 day' }
-    ]
-  },
-  'full-stack-parallel': {
-    name: 'Full Stack Parallel Development',
-    description: 'Concurrent frontend and backend development with parallel testing',
-    tier: 'free',
-    pack: null,
-    outcomes: ['Full stack feature delivered with parallel development streams'],
-    completionSignals: ['API contract finalized', 'Frontend and backend complete', 'Integration tests passing'],
-    phases: [
-      { name: 'Design & Contract', agents: ['api-expert', 'ui-ux-expert', 'architecture-expert'], duration: '1-2 days' },
-      { name: 'Backend Development', agents: ['backend-expert', 'database-expert'], duration: '2-4 days', parallel: true },
-      { name: 'Frontend Development', agents: ['frontend-expert', 'ui-ux-expert'], duration: '2-4 days', parallel: true },
-      { name: 'Integration & Testing', agents: ['testing-expert', 'security-expert'], duration: '1-2 days' },
-      { name: 'Review & Deploy', agents: ['code-review-expert', 'devops-expert'], duration: '1 day' }
-    ]
-  },
-  'comprehensive-audit': {
-    name: 'Comprehensive Audit',
-    description: 'Parallel security, performance, and code quality audits',
-    tier: 'free',
-    pack: null,
-    outcomes: ['Complete audit report with prioritized findings'],
-    completionSignals: ['All audits complete', 'Findings documented', 'Remediation plan created'],
-    phases: [
-      { name: 'Preparation', agents: ['architecture-expert'], duration: '0.5 days' },
-      { name: 'Security Audit', agents: ['security-expert'], duration: '1-2 days', parallel: true },
-      { name: 'Performance Audit', agents: ['performance-expert'], duration: '1-2 days', parallel: true },
-      { name: 'Code Quality Audit', agents: ['code-review-expert'], duration: '1-2 days', parallel: true },
-      { name: 'Report & Plan', agents: ['architecture-expert', 'code-review-expert'], duration: '1 day' }
-    ]
-  }
-};
-
-/**
- * Load orchestrator state from project
- */
-function loadState() {
-  const paths = getPaths();
-
-  if (fs.existsSync(paths.statePath)) {
-    try {
-      return JSON.parse(fs.readFileSync(paths.statePath, 'utf8'));
-    } catch {
-      return createDefaultState();
-    }
-  }
-  return createDefaultState();
-}
-
-/**
- * Create default orchestrator state
- */
-function createDefaultState() {
-  return {
-    lastAnalysis: null,
-    currentPhase: 1,
-    activeWorkflow: null,
-    workflowStep: 0,
-    workflowSignals: {},
-    recentAgents: [],
-    suggestions: [],
-    history: []
-  };
-}
-
-function emitWorkflowTelemetry(event, payload = {}) {
-  const paths = getPaths();
-  try {
-    telemetry.emitEvent(event, payload, { projectRoot: paths.projectRoot });
-  } catch {
-    // Telemetry should not block workflow execution.
-  }
-}
 
 function getWorkflowSignalProgress(workflowName, state = null) {
   const workflow = WORKFLOWS[workflowName];
@@ -388,22 +88,6 @@ function resolveSignal(workflow, signalRef, stateSignals = []) {
   return signals.find(signal => signal.toLowerCase().includes(lower)) || null;
 }
 
-/**
- * Save orchestrator state
- */
-function saveState(state) {
-  const paths = getPaths();
-
-  // Ensure .bootspring directory exists
-  const stateDir = path.dirname(paths.statePath);
-  if (!fs.existsSync(stateDir)) {
-    fs.mkdirSync(stateDir, { recursive: true });
-  }
-
-  state.lastUpdated = new Date().toISOString();
-  fs.writeFileSync(paths.statePath, JSON.stringify(state, null, 2));
-}
-
 /**
  * Get current phase from ROADMAP.md
  */
@@ -1098,174 +782,7 @@ if (require.main === module) {
   }
 }
 
-// Export for use as module
-/**
- * Remediation workflows for common failure scenarios
- * Enhanced with severity levels, auto-trigger options, fallback phases, and preventive actions
- */
-const REMEDIATION_PATHS = {
-  'testing-failure': {
-    description: 'Tests failed during workflow',
-    severity: 'high',
-    autoTrigger: true,
-    maxRetries: 3,
-    steps: [
-      { action: 'analyze_failures', agent: 'testing-expert', description: 'Analyze test failures', timeout: 300 },
-      { action: 'fix_issues', agent: 'code-review-expert', description: 'Review and fix failing code', timeout: 600 },
-      { action: 'rerun_tests', agent: 'testing-expert', description: 'Re-run tests', timeout: 300 }
-    ],
-    preventiveActions: [
-      'Run tests locally before committing',
-      'Check for flaky tests in CI history',
-      'Verify test environment configuration'
-    ],
-    fallbackPhase: { name: 'Manual Review', agents: ['code-review-expert'], duration: '1-2 days' }
-  },
-  'security-failure': {
-    description: 'Security issues found during workflow',
-    severity: 'critical',
-    autoTrigger: true,
-    maxRetries: 2,
-    steps: [
-      { action: 'security_audit', agent: 'security-expert', description: 'Full security audit', timeout: 600 },
-      { action: 'remediate', agent: 'security-expert', description: 'Fix security vulnerabilities', timeout: 900 },
-      { action: 'verify', agent: 'security-expert', description: 'Verify fixes', timeout: 300 }
-    ],
-    preventiveActions: [
-      'Run security scans in pre-commit hooks',
-      'Keep dependencies updated',
-      'Review auth/authz changes carefully'
-    ],
-    fallbackPhase: { name: 'Security Escalation', agents: ['security-expert', 'architecture-expert'], duration: '2-3 days' }
-  },
-  'performance-failure': {
-    description: 'Performance issues detected',
-    severity: 'medium',
-    autoTrigger: false,
-    maxRetries: 2,
-    steps: [
-      { action: 'profile', agent: 'performance-expert', description: 'Profile application', timeout: 600 },
-      { action: 'optimize', agent: 'performance-expert', description: 'Implement optimizations', timeout: 900 },
-      { action: 'benchmark', agent: 'performance-expert', description: 'Benchmark improvements', timeout: 300 }
-    ],
-    preventiveActions: [
-      'Set performance budgets',
-      'Monitor bundle sizes',
-      'Profile database queries'
-    ],
-    fallbackPhase: { name: 'Performance Review', agents: ['performance-expert', 'database-expert'], duration: '2-3 days' }
-  },
-  'deployment-failure': {
-    description: 'Deployment failed',
-    severity: 'high',
-    autoTrigger: true,
-    maxRetries: 2,
-    steps: [
-      { action: 'diagnose', agent: 'devops-expert', description: 'Diagnose deployment failure', timeout: 300 },
-      { action: 'fix_config', agent: 'devops-expert', description: 'Fix configuration issues', timeout: 600 },
-      { action: 'retry_deploy', agent: 'devops-expert', description: 'Retry deployment', timeout: 300 }
-    ],
-    preventiveActions: [
-      'Deploy to staging first',
-      'Verify environment variables',
-      'Check resource limits and quotas'
-    ],
-    fallbackPhase: { name: 'Deployment Rollback', agents: ['devops-expert'], duration: '0.5 days' }
-  },
-  'database-failure': {
-    description: 'Database issues detected',
-    severity: 'high',
-    autoTrigger: true,
-    maxRetries: 1,
-    steps: [
-      { action: 'analyze_schema', agent: 'database-expert', description: 'Analyze database issues', timeout: 300 },
-      { action: 'fix_migration', agent: 'database-expert', description: 'Fix migration issues', timeout: 600 },
-      { action: 'verify_data', agent: 'database-expert', description: 'Verify data integrity', timeout: 300 }
-    ],
-    preventiveActions: [
-      'Test migrations on copy of production data',
-      'Have rollback plan ready',
-      'Check for breaking schema changes'
-    ],
-    fallbackPhase: { name: 'Database Recovery', agents: ['database-expert', 'devops-expert'], duration: '1-2 days' }
-  },
-  'build-failure': {
-    description: 'Build process failed',
-    severity: 'high',
-    autoTrigger: true,
-    maxRetries: 3,
-    steps: [
-      { action: 'analyze_build', agent: 'devops-expert', description: 'Analyze build errors', timeout: 300 },
-      { action: 'fix_dependencies', agent: 'backend-expert', description: 'Fix dependency issues', timeout: 600 },
-      { action: 'rebuild', agent: 'devops-expert', description: 'Rebuild application', timeout: 300 }
-    ],
-    preventiveActions: [
-      'Lock dependency versions',
-      'Verify build environment matches CI',
-      'Check for circular dependencies'
-    ],
-    fallbackPhase: { name: 'Build Investigation', agents: ['devops-expert', 'backend-expert'], duration: '1 day' }
-  },
-  'integration-failure': {
-    description: 'Integration issues with external services',
-    severity: 'medium',
-    autoTrigger: false,
-    maxRetries: 2,
-    steps: [
-      { action: 'diagnose_integration', agent: 'api-expert', description: 'Diagnose integration issues', timeout: 300 },
-      { action: 'fix_api', agent: 'api-expert', description: 'Fix API integration', timeout: 600 },
-      { action: 'verify_integration', agent: 'testing-expert', description: 'Verify integration works', timeout: 300 }
-    ],
-    preventiveActions: [
-      'Mock external services in tests',
-      'Check API version compatibility',
-      'Verify credentials and permissions'
-    ],
-    fallbackPhase: { name: 'Integration Workaround', agents: ['api-expert', 'backend-expert'], duration: '1-2 days' }
-  },
-  'timeout-failure': {
-    description: 'Operation timed out',
-    severity: 'medium',
-    autoTrigger: false,
-    maxRetries: 2,
-    steps: [
-      { action: 'profile_operation', agent: 'performance-expert', description: 'Profile slow operation', timeout: 600 },
-      { action: 'optimize_critical_path', agent: 'performance-expert', description: 'Optimize critical path', timeout: 600 },
-      { action: 'adjust_timeout', agent: 'devops-expert', description: 'Adjust timeout settings', timeout: 300 }
-    ],
-    preventiveActions: [
-      'Set appropriate timeout values',
-      'Add progress indicators',
-      'Consider async processing'
-    ],
-    fallbackPhase: { name: 'Async Processing', agents: ['backend-expert', 'performance-expert'], duration: '1-2 days' }
-  }
-};
 
-/**
- * Failure pattern signatures for auto-detection
- * Maps keywords to failure types for intelligent failure classification
- */
-const FAILURE_SIGNATURES = {
-  'testing': ['test', 'spec', 'jest', 'vitest', 'assertion', 'expect', 'failing', 'failed test'],
-  'security': ['vulnerability', 'auth', 'permission', 'unauthorized', 'csrf', 'xss', 'injection', 'security'],
-  'performance': ['slow', 'timeout', 'memory', 'cpu', 'latency', 'bottleneck', 'performance'],
-  'deployment': ['deploy', 'release', 'ci/cd', 'pipeline', 'staging', 'production', 'build failed'],
-  'database': ['migration', 'schema', 'query', 'prisma', 'sql', 'database', 'connection', 'deadlock'],
-  'build': ['build', 'compile', 'bundle', 'webpack', 'typescript', 'syntax error', 'module not found'],
-  'integration': ['api', 'endpoint', 'external', 'service', 'http', 'request failed', '500', '503'],
-  'timeout': ['timeout', 'deadline', 'exceeded', 'timed out', 'ETIMEDOUT']
-};
-
-/**
- * Severity weights for adaptive response calculation
- */
-const SEVERITY_WEIGHTS = {
-  'critical': 4,
-  'high': 3,
-  'medium': 2,
-  'low': 1
-};
 /**
  * Report a phase failure and get remediation options
  * @param {string} failureType - Type of failure (testing, security, performance, deployment, database)
@@ -2273,18 +1790,6 @@ function getLinkedPrds() {
  * - Failure recovery and retry support
  */
 
-/**
- * Failure strategy options for parallel execution
- * - 'fail-fast': Stop all phases on first failure (default)
- * - 'continue': Continue other phases, collect failures at end
- * - 'retry': Allow retry of failed phases while others continue
- */
-const PARALLEL_FAILURE_STRATEGIES = {
-  'fail-fast': 'Stop all phases when one fails',
-  'continue': 'Continue other phases, handle failures at completion',
-  'retry': 'Allow retry of failed phases'
-};
-
 /**
  * Start parallel phase execution
  * Identifies consecutive parallel phases and starts them together

package/mcp/contracts/mcp-contract.v1.json

@@ -1,7 +1,7 @@
 {
   "contractVersion": "v1",
   "packageName": "@girardmedia/bootspring",
-  "packageVersion": "2.0.22",
+  "packageVersion": "2.0.23",
   "tools": [
     {
       "name": "bootspring_assist",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@girardmedia/bootspring",
-  "version": "2.0.22",
+  "version": "2.0.23",
   "description": "Development scaffolding with intelligence - AI-powered context, agents, and workflows for any MCP-compatible assistant",
   "keywords": [
     "ai",