@girardmedia/bootspring 2.0.21 → 2.0.23

package/generators/index.ts

@@ -0,0 +1,82 @@
+/**
+ * Bootspring Generators Module
+ *
+ * Provides context generation, scaffolding, and project setup.
+ *
+ * @package bootspring
+ * @module generators
+ */
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export interface GenerateOptions {
+  cwd?: string | undefined;
+  force?: boolean | undefined;
+  verbose?: boolean | undefined;
+}
+
+export interface GenerateResult {
+  success: boolean;
+  files: string[];
+  errors?: string[] | undefined;
+}
+
+export interface MvpAnalysis {
+  sections: Record<string, string>;
+  features: string[];
+  entities: string[];
+  routes: string[];
+  components: string[];
+}
+
+export interface ParsedConfig {
+  project?: {
+    name?: string | undefined;
+    description?: string | undefined;
+    version?: string | undefined;
+  } | undefined;
+  stack?: {
+    framework?: string | undefined;
+    language?: string | undefined;
+    database?: string | undefined;
+  } | undefined;
+  plugins?: Record<string, unknown> | undefined;
+}
+
+export interface ParsedSeed {
+  name?: string | undefined;
+  tagline?: string | undefined;
+  problem?: string | undefined;
+  solution?: string | undefined;
+  features?: string[] | undefined;
+  userTypes?: string[] | undefined;
+  stack?: Record<string, string> | undefined;
+  phases?: Array<{
+    name: string;
+    tasks: string[];
+  }> | undefined;
+}
+
+// ============================================================================
+// Module Import
+// ============================================================================
+
+const generator = require('./generate') as {
+  generate: (options?: GenerateOptions) => GenerateResult;
+  generateClaudeMd: (options?: GenerateOptions) => string;
+  analyzeMvpSource: (content: string) => MvpAnalysis;
+  parseConfig: (configPath: string) => ParsedConfig | null;
+  parseSeedMd: (content: string) => ParsedSeed;
+};
+
+// ============================================================================
+// Exports
+// ============================================================================
+
+export const generate = generator.generate;
+export const generateClaudeMd = generator.generateClaudeMd;
+export const analyzeMvpSource = generator.analyzeMvpSource;
+export const parseConfig = generator.parseConfig;
+export const parseSeedMd = generator.parseSeedMd;

package/intelligence/orchestrator/config/failure-signatures.js

@@ -0,0 +1,48 @@
+/**
+ * Failure Signatures Configuration
+ * Failure pattern signatures and severity weights
+ * @package bootspring
+ */
+
+/**
+ * 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
+};
+
+/**
+ * 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'
+};
+
+module.exports = {
+  FAILURE_SIGNATURES,
+  SEVERITY_WEIGHTS,
+  PARALLEL_FAILURE_STRATEGIES
+};

package/intelligence/orchestrator/config/index.js

@@ -0,0 +1,23 @@
+/**
+ * Orchestrator Configuration Index
+ * Re-exports all configuration constants
+ * @package bootspring
+ */
+
+const { PHASE_AGENTS, TECHNICAL_TRIGGERS } = require('./phases');
+const { WORKFLOWS } = require('./workflows');
+const { REMEDIATION_PATHS } = require('./remediation');
+const { FAILURE_SIGNATURES, SEVERITY_WEIGHTS, PARALLEL_FAILURE_STRATEGIES } = require('./failure-signatures');
+const packLifecycle = require('./pack-lifecycle');
+
+module.exports = {
+  PHASE_AGENTS,
+  TECHNICAL_TRIGGERS,
+  WORKFLOWS,
+  REMEDIATION_PATHS,
+  FAILURE_SIGNATURES,
+  SEVERITY_WEIGHTS,
+  PARALLEL_FAILURE_STRATEGIES,
+  // Pack lifecycle exports
+  ...packLifecycle
+};

package/intelligence/orchestrator/config/pack-lifecycle.js

@@ -0,0 +1,262 @@
+/**
+ * Pack Lifecycle Configuration
+ * Manages premium pack rollout stages: draft -> QA -> canary -> GA
+ * @package bootspring
+ */
+
+/**
+ * Lifecycle stages
+ */
+const LIFECYCLE_STAGES = {
+  DRAFT: 'draft',       // Internal development, not visible to users
+  QA: 'qa',             // Internal testing, visible to team accounts
+  CANARY: 'canary',     // Limited rollout (25% of eligible users)
+  GA: 'ga'              // General availability (100% rollout)
+};
+
+/**
+ * Stage order for progression
+ */
+const STAGE_ORDER = ['draft', 'qa', 'canary', 'ga'];
+
+/**
+ * Default rollout percentages per stage
+ */
+const DEFAULT_ROLLOUT = {
+  draft: 0,       // Not available to users
+  qa: 5,          // 5% of team/enterprise users for internal QA
+  canary: 25,     // 25% of eligible users
+  ga: 100         // All eligible users
+};
+
+/**
+ * Pack lifecycle definitions
+ * Tracks current stage and rollout status for each premium pack
+ */
+const PACK_LIFECYCLE = {
+  'launch-pack': {
+    name: 'Launch Pack',
+    description: 'Premium guided launch workflow from freeze to production validation',
+    currentStage: 'ga',
+    stageHistory: [
+      { stage: 'draft', date: '2026-01-15', approved_by: 'system' },
+      { stage: 'qa', date: '2026-01-22', approved_by: 'system' },
+      { stage: 'canary', date: '2026-02-01', approved_by: 'system' },
+      { stage: 'ga', date: '2026-02-15', approved_by: 'system' }
+    ],
+    rolloutPercentage: 100,
+    qualityGates: {
+      errorRateThreshold: 0.01,  // Max 1% error rate to advance
+      minUsageCount: 10,         // Min 10 uses in current stage
+      minSuccessRate: 0.95       // 95% completion rate
+    },
+    featureFlags: {}
+  },
+  'reliability-pack': {
+    name: 'Reliability Pack',
+    description: 'Premium reliability hardening workflow for incidents and regressions',
+    currentStage: 'ga',
+    stageHistory: [
+      { stage: 'draft', date: '2026-01-15', approved_by: 'system' },
+      { stage: 'qa', date: '2026-01-22', approved_by: 'system' },
+      { stage: 'canary', date: '2026-02-01', approved_by: 'system' },
+      { stage: 'ga', date: '2026-02-15', approved_by: 'system' }
+    ],
+    rolloutPercentage: 100,
+    qualityGates: {
+      errorRateThreshold: 0.01,
+      minUsageCount: 10,
+      minSuccessRate: 0.95
+    },
+    featureFlags: {}
+  },
+  'growth-pack': {
+    name: 'Growth Pack',
+    description: 'Premium experimentation workflow for activation and conversion improvements',
+    currentStage: 'ga',
+    stageHistory: [
+      { stage: 'draft', date: '2026-01-15', approved_by: 'system' },
+      { stage: 'qa', date: '2026-01-22', approved_by: 'system' },
+      { stage: 'canary', date: '2026-02-01', approved_by: 'system' },
+      { stage: 'ga', date: '2026-02-15', approved_by: 'system' }
+    ],
+    rolloutPercentage: 100,
+    qualityGates: {
+      errorRateThreshold: 0.01,
+      minUsageCount: 10,
+      minSuccessRate: 0.95
+    },
+    featureFlags: {}
+  }
+};
+
+/**
+ * Get pack lifecycle info
+ * @param {string} packName - Pack name (e.g., 'launch-pack')
+ * @returns {object|null} Pack lifecycle info
+ */
+function getPackLifecycle(packName) {
+  return PACK_LIFECYCLE[packName] || null;
+}
+
+/**
+ * Get current stage for a pack
+ * @param {string} packName - Pack name
+ * @returns {string} Current stage
+ */
+function getPackStage(packName) {
+  const lifecycle = getPackLifecycle(packName);
+  return lifecycle?.currentStage || 'draft';
+}
+
+/**
+ * Check if pack is visible to user based on stage and rollout
+ * @param {string} packName - Pack name
+ * @param {object} options - Options including tier, userId
+ * @returns {boolean} Whether pack is visible
+ */
+function isPackVisibleToUser(packName, options = {}) {
+  const lifecycle = getPackLifecycle(packName);
+  if (!lifecycle) return false;
+
+  const stage = lifecycle.currentStage;
+  const rollout = lifecycle.rolloutPercentage;
+
+  // Draft: never visible
+  if (stage === 'draft') return false;
+
+  // QA: only visible to team/enterprise
+  if (stage === 'qa') {
+    const tier = options.tier || 'free';
+    return ['team', 'enterprise'].includes(tier);
+  }
+
+  // Canary/GA: check rollout percentage
+  if (rollout === 100) return true;
+  if (rollout === 0) return false;
+
+  // Hash user ID to determine if in rollout
+  const userId = options.userId || options.deviceId || 'anonymous';
+  const hash = simpleHash(userId + packName);
+  const bucket = hash % 100;
+
+  return bucket < rollout;
+}
+
+/**
+ * Simple hash function for rollout bucketing
+ * @param {string} str - String to hash
+ * @returns {number} Hash value 0-999999
+ */
+function simpleHash(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = ((hash << 5) - hash) + char;
+    hash = hash & hash; // Convert to 32-bit integer
+  }
+  return Math.abs(hash);
+}
+
+/**
+ * Check if stage can be advanced based on quality gates
+ * @param {string} packName - Pack name
+ * @param {object} metrics - Current metrics { errorRate, usageCount, successRate }
+ * @returns {object} { canAdvance, reasons }
+ */
+function checkQualityGates(packName, metrics = {}) {
+  const lifecycle = getPackLifecycle(packName);
+  if (!lifecycle) {
+    return { canAdvance: false, reasons: ['Pack not found'] };
+  }
+
+  const gates = lifecycle.qualityGates;
+  const reasons = [];
+
+  // Check error rate
+  if (metrics.errorRate !== undefined && metrics.errorRate > gates.errorRateThreshold) {
+    reasons.push(`Error rate ${(metrics.errorRate * 100).toFixed(2)}% exceeds threshold ${(gates.errorRateThreshold * 100).toFixed(2)}%`);
+  }
+
+  // Check usage count
+  if (metrics.usageCount !== undefined && metrics.usageCount < gates.minUsageCount) {
+    reasons.push(`Usage count ${metrics.usageCount} below minimum ${gates.minUsageCount}`);
+  }
+
+  // Check success rate
+  if (metrics.successRate !== undefined && metrics.successRate < gates.minSuccessRate) {
+    reasons.push(`Success rate ${(metrics.successRate * 100).toFixed(2)}% below threshold ${(gates.minSuccessRate * 100).toFixed(2)}%`);
+  }
+
+  return {
+    canAdvance: reasons.length === 0,
+    reasons
+  };
+}
+
+/**
+ * Get next stage in lifecycle
+ * @param {string} currentStage - Current stage
+ * @returns {string|null} Next stage or null if at GA
+ */
+function getNextStage(currentStage) {
+  const index = STAGE_ORDER.indexOf(currentStage);
+  if (index === -1 || index === STAGE_ORDER.length - 1) return null;
+  return STAGE_ORDER[index + 1];
+}
+
+/**
+ * Get previous stage in lifecycle
+ * @param {string} currentStage - Current stage
+ * @returns {string|null} Previous stage or null if at draft
+ */
+function getPreviousStage(currentStage) {
+  const index = STAGE_ORDER.indexOf(currentStage);
+  if (index <= 0) return null;
+  return STAGE_ORDER[index - 1];
+}
+
+/**
+ * List all pack lifecycle statuses
+ * @returns {Array} Pack status list
+ */
+function listPackStatuses() {
+  return Object.entries(PACK_LIFECYCLE).map(([key, pack]) => ({
+    key,
+    name: pack.name,
+    description: pack.description,
+    currentStage: pack.currentStage,
+    rolloutPercentage: pack.rolloutPercentage,
+    lastUpdate: pack.stageHistory[pack.stageHistory.length - 1]?.date
+  }));
+}
+
+/**
+ * Get stage badge for display
+ * @param {string} stage - Stage name
+ * @returns {string} Badge string
+ */
+function getStageBadge(stage) {
+  const badges = {
+    draft: '[draft]',
+    qa: '[QA]',
+    canary: '[canary]',
+    ga: '[GA]'
+  };
+  return badges[stage] || `[${stage}]`;
+}
+
+module.exports = {
+  LIFECYCLE_STAGES,
+  STAGE_ORDER,
+  DEFAULT_ROLLOUT,
+  PACK_LIFECYCLE,
+  getPackLifecycle,
+  getPackStage,
+  isPackVisibleToUser,
+  checkQualityGates,
+  getNextStage,
+  getPreviousStage,
+  listPackStatuses,
+  getStageBadge
+};

package/intelligence/orchestrator/config/phases.js

@@ -0,0 +1,111 @@
+/**
+ * Phase Agents Configuration
+ * Maps project phases to recommended agents
+ * @package bootspring
+ */
+
+/**
+ * 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']
+  }
+};
+
+module.exports = {
+  PHASE_AGENTS,
+  TECHNICAL_TRIGGERS
+};

package/intelligence/orchestrator/config/remediation.js

@@ -0,0 +1,150 @@
+/**
+ * Remediation Configuration
+ * Remediation workflows for common failure scenarios
+ * @package bootspring
+ */
+
+/**
+ * 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' }
+  }
+};
+
+module.exports = { REMEDIATION_PATHS };