proffesor-for-testing__agentic-qe/docs/implementation-plans/MASTER-IMPLEMENTATION-ROADMAP-v2.md

Master Implementation Roadmap v2.0

Agentic QE Fleet - Consolidated Implementation Plan

Date: October 17, 2025 Status: READY FOR EXECUTION Version: 2.0 (Revised - Memory System Already Complete)

---

Executive Summary

This master implementation roadmap consolidates three high-priority improvement tracks:

1. Test Coverage & Infrastructure Fixes (106-144 hours)
2. Deployment Readiness for v1.1.0 (12-16 hours)
3. QE Fleet Enhancements (excluding new agents - already have 17 + templates)

CRITICAL DISCOVERY:

• Sprint 2 Memory System Implementation: ❌ NOT NEEDED - Already complete with 15 SQLite tables
• SwarmMemoryManager.ts (1,989 lines) already implements all required functionality
• Original Sprint 2 plans were based on incorrect assumption

Updated Scope:

• Sprint 1: Test Infrastructure Fixes (40 hours)
• Sprint 2: Memory System → REMOVED (Already Complete)
• Sprint 3: Advanced Features & Agentic-Flow Integration (Optional, 60-80 hours)

---

Table of Contents

1. Critical Path Analysis
2. Sprint 1: Test Infrastructure & Deployment Readiness
3. Sprint 3: Advanced Features (Optional)
4. Task Dependency Graph
5. Consolidated Task List (JSON)
6. Execution Timeline
7. Success Metrics

---

1. Critical Path Analysis

1.1 Immediate Priorities (Week 1)

BLOCKER RESOLUTION:

Priority 1: Deployment Readiness (8-10 hours)
├─ DEPLOY-001: Fix Jest environment (process.cwd() issue) → Unblocks 46 tests
├─ DEPLOY-002-006: Fix remaining 7 test issues
└─ DEPLOY-007: Coverage validation (80%+ target)

Priority 2: Test Infrastructure (Week 1-2, 40 hours)
├─ TEST-001: Fix coverage instrumentation (CRITICAL)
├─ TEST-002-005: Fix failing tests
└─ Phase 1 completion

1.2 Updated Sprint Structure

Original Plan:

• Sprint 1: Test Infrastructure (40h)
• Sprint 2: Memory System (60h) ← REMOVED
• Sprint 3: Advanced Features (80h)

NEW Plan:

• Sprint 1: Test Infrastructure + Deployment Fixes (48h)
• Sprint 2: SKIPPED - Memory already complete
• Sprint 3: Advanced Features (Optional, 60-80h)

1.3 ROI Impact

Time Saved:

• Sprint 2 Memory System: 60 hours saved ✅
• Cost Saved: $9,000 (@$150/hr) ✅
• Faster to Production: 2 weeks earlier ✅

---

2. Sprint 1: Test Infrastructure & Deployment Readiness

2.1 Critical Path Tasks (Week 1)

DEPLOY-001: Fix Jest Environment (CRITICAL - 0.5-1h)

Issue: ENOENT: no such file or directory, uv_cwd affects 46 tests (86.8% of failures)

Fix:

// File: jest.setup.ts (CREATE)
const originalCwd = process.cwd.bind(process);

process.cwd = jest.fn(() => {
  try {
    return originalCwd();
  } catch (error) {
    return '/workspaces/agentic-qe-cf';
  }
});

afterAll(() => {
  process.cwd = originalCwd;
});

jest.setTimeout(30000);

// File: jest.config.js (UPDATE)
module.exports = {
  // ... existing config
  setupFilesAfterEnv: ['<rootDir>/jest.setup.ts'],
  testEnvironmentOptions: {
    cwd: process.cwd()
  },
};

Success Criteria:

• ✅ No ENOENT errors
• ✅ 46+ tests now able to run
• ✅ process.cwd() returns valid path

Agent: coder Priority: CRITICAL Effort: 0.5-1 hour Dependencies: None

---

DEPLOY-002: Fix Database Mock Initialization (1h)

Issue: TypeError: this.database.initialize is not a function

Affected Tests:

• tests/unit/fleet-manager.test.ts
• tests/cli/advanced-commands.test.ts

Fix:

// Complete database mock
const mockDatabase = {
  initialize: jest.fn().mockResolvedValue(undefined),
  query: jest.fn().mockResolvedValue({ rows: [] }),
  close: jest.fn().mockResolvedValue(undefined),
  prepare: jest.fn(),
  run: jest.fn(),
  get: jest.fn(),
  all: jest.fn().mockResolvedValue([])
};

Success Criteria:

• ✅ No "initialize is not a function" errors
• ✅ Fleet manager tests pass
• ✅ CLI advanced commands tests pass

Agent: coder Priority: HIGH Effort: 1 hour Dependencies: DEPLOY-001

---

DEPLOY-003: Fix Statistical Analysis Precision (0.5h)

Issue: Floating point precision errors in StatisticalAnalysis.test.ts

Fix:

// Use toBeCloseTo with proper precision
expect(passRate).toBeCloseTo(0.6, 2); // 2 decimal places

// OR: Round before comparing
expect(Math.round(passRate * 100) / 100).toBe(0.60);

Agent: coder Priority: MEDIUM Effort: 0.5 hours Dependencies: DEPLOY-001

---

DEPLOY-004: Fix Module Import Paths (0.5h)

Issue: Cannot find module '../../src/cli/commands/agent/spawn'

Fix:

# Find actual module location
find src/cli/commands -name "*.ts" | grep -i spawn

# Update import path
import { spawn } from '../../src/cli/commands/agent';

Agent: coder Priority: HIGH Effort: 0.5 hours Dependencies: DEPLOY-001

---

DEPLOY-005: Fix EventBus Timing (0.5h)

Issue: Async event timing causing call count mismatches

Fix:

test('should handle multiple initialization calls gracefully', async () => {
  // Await async initialization
  await eventBus.initialize();
  await eventBus.initialize();

  // Wait for event propagation
  await new Promise(resolve => setImmediate(resolve));

  expect(mockHandler).toHaveBeenCalledTimes(2);
});

Agent: coder Priority: MEDIUM Effort: 0.5 hours Dependencies: DEPLOY-001

---

DEPLOY-006: Fix Learning System Tests (1h)

Issue: ML models not properly initialized before detection

Fix:

describe('detectFlakyTests', () => {
  test('should detect intermittent flaky test', async () => {
    // ADD: Train model with sufficient data
    const trainingData = [
      { testId: 'test-1', history: [true, true, true, true, true] },
      { testId: 'test-2', history: [true, true, true, true, true] },
      { testId: 'test-3', history: [true, false, true, false, true] },
    ];

    await detector.train(trainingData);

    // Now test detection
    const flaky = detector.detectFlakyTests(testResults);
    expect(flaky.length).toBe(1);
  });
});

Agent: coder Priority: MEDIUM Effort: 1 hour Dependencies: DEPLOY-001

---

DEPLOY-007: Coverage Validation (1h)

Objective: Validate test coverage meets 80%+ threshold after all fixes

Steps:

# 1. Run full test suite
npm test

# 2. Run coverage analysis
npm run test:coverage-safe

# 3. Check coverage thresholds
cat coverage/coverage-summary.json | jq '.total'

# 4. Identify gaps if <80%
find coverage/lcov-report -name "*.html" | xargs grep -l "0.00%"

Success Criteria:

• ✅ All tests passing (0 failures)
• ✅ Statements coverage ≥ 80%
• ✅ Branches coverage ≥ 80%
• ✅ Functions coverage ≥ 80%
• ✅ Lines coverage ≥ 80%

Agent: qe-coverage-analyzer Priority: CRITICAL Effort: 1 hour Dependencies: DEPLOY-001 through DEPLOY-006

---

INTEGRATION-001: SwarmMemoryManager Integration in QE Agents (2h)

Issue: Agent Task tool agents create markdown documentation but don't actually store data in SwarmMemoryManager database

Problem: Previous agent runs (yesterday) did NOT integrate with the database:

• Agents modified files and created reports
• No database entries were created in .swarm/memory.db
• Documentation was aspirational, not actual integration

Objective: Ensure ALL future QE fleet agents properly integrate with SwarmMemoryManager by:

1. Storing task status in database with proper keys
2. Emitting events via EventBus for coordination
3. Storing patterns in the patterns table
4. Creating performance metrics entries

Implementation:

// Example: Proper SwarmMemoryManager integration in agents
// File: src/agents/BaseAgent.ts (or any QE agent)

import { SwarmMemoryManager } from '../core/memory/SwarmMemoryManager';
import { EventBus } from '../core/EventBus';
import * as path from 'path';

export class IntegratedQEAgent extends BaseAgent {
  private memoryStore: SwarmMemoryManager;
  private eventBus: EventBus;

  async initialize() {
    // Initialize memory store
    const dbPath = path.join(process.cwd(), '.swarm/memory.db');
    this.memoryStore = new SwarmMemoryManager(dbPath);
    await this.memoryStore.initialize();

    // Initialize event bus
    this.eventBus = EventBus.getInstance();
    await this.eventBus.initialize();
  }

  // Pre-task hook - called BEFORE task execution
  protected async onPreTask(data: { assignment: TaskAssignment }): Promise<void> {
    const taskId = data.assignment.task.id;

    // Store task start in memory
    await this.memoryStore.store(`tasks/${taskId}/status`, {
      status: 'started',
      timestamp: Date.now(),
      agent: this.agentId,
      taskType: data.assignment.task.type
    }, {
      partition: 'coordination',
      ttl: 86400 // 24 hours
    });

    // Emit task started event
    await this.eventBus.emit('task.started', {
      taskId,
      agentId: this.agentId,
      timestamp: Date.now()
    });

    this.logger.info(`Task ${taskId} started - stored in database`);
  }

  // Post-task hook - called AFTER task completion
  protected async onPostTask(data: { assignment: TaskAssignment; result: any }): Promise<void> {
    const taskId = data.assignment.task.id;

    // Store task completion in memory
    await this.memoryStore.store(`tasks/${taskId}/status`, {
      status: 'completed',
      timestamp: Date.now(),
      agent: this.agentId,
      result: data.result,
      filesModified: data.result.filesModified || [],
      testsFixed: data.result.testsFixed || 0
    }, {
      partition: 'coordination',
      ttl: 86400
    });

    // Store learned pattern if applicable
    if (data.result.pattern) {
      await this.memoryStore.storePattern({
        pattern: data.result.pattern.name,
        confidence: data.result.pattern.confidence || 0.9,
        usageCount: 1,
        metadata: {
          taskId,
          timestamp: Date.now(),
          description: data.result.pattern.description
        }
      });
    }

    // Emit task completed event
    await this.eventBus.emit('task.completed', {
      taskId,
      agentId: this.agentId,
      timestamp: Date.now(),
      success: true,
      result: data.result
    });

    // Store performance metrics
    if (data.result.executionTime) {
      await this.memoryStore.storePerformanceMetric({
        metric: 'task_execution_time',
        value: data.result.executionTime,
        unit: 'ms',
        agentId: this.agentId,
        timestamp: Date.now(),
        metadata: { taskId }
      });
    }

    this.logger.info(`Task ${taskId} completed - all data stored in database`);
  }

  // Error handler - called on task failure
  protected async onTaskError(data: { assignment: TaskAssignment; error: Error }): Promise<void> {
    const taskId = data.assignment.task.id;

    // Store error in memory
    await this.memoryStore.store(`tasks/${taskId}/error`, {
      status: 'failed',
      timestamp: Date.now(),
      agent: this.agentId,
      error: {
        message: data.error.message,
        stack: data.error.stack
      }
    }, {
      partition: 'coordination',
      ttl: 86400
    });

    // Emit error event
    await this.eventBus.emit('task.error', {
      taskId,
      agentId: this.agentId,
      timestamp: Date.now(),
      error: data.error.message
    });
  }

  async cleanup() {
    await this.memoryStore.close();
  }
}

Validation Script:

// scripts/verify-agent-integration.ts
import { SwarmMemoryManager } from '../src/core/memory/SwarmMemoryManager';
import * as path from 'path';

async function verifyIntegration() {
  const dbPath = path.join(process.cwd(), '.swarm/memory.db');
  const memory = new SwarmMemoryManager(dbPath);
  await memory.initialize();

  // Check for task status entries
  const tasks = await memory.query('tasks/%', { partition: 'coordination' });
  console.log(`Found ${tasks.length} task entries`);

  // Check for events
  const events = await memory.queryEvents('task.completed');
  console.log(`Found ${events.length} task completion events`);

  // Check for patterns
  const patterns = await memory.queryPatternsByConfidence(0.0);
  console.log(`Found ${patterns.length} learned patterns`);

  // Check for metrics
  const stats = await memory.stats();
  console.log('Database stats:', JSON.stringify(stats, null, 2));

  await memory.close();
}

Success Criteria:

• ✅ New database entries created for each task execution
• ✅ Events emitted to EventBus for each task lifecycle stage
• ✅ Patterns stored in patterns table when learned
• ✅ Performance metrics recorded for task execution times
• ✅ Verification script shows entries from TODAY's date

Agent: coder Priority: CRITICAL Effort: 2 hours Dependencies: DEPLOY-007

Files to Modify:

• src/agents/BaseAgent.ts (add memory integration example)
• scripts/verify-agent-integration.ts (create new verification script)
• docs/guides/AGENT-INTEGRATION-GUIDE.md (create integration guide)

---

2.2 Test Infrastructure Fixes (Week 1-2, 40h)

TEST-001: Fix Coverage Instrumentation (4-6h)

Problem: Coverage reports show 0% despite 329 passing tests

Implementation:

// jest.config.js - Verify coverage configuration
module.exports = {
  preset: 'ts-jest',
  testEnvironment: 'node',

  // CRITICAL: Ensure coverage collection is enabled
  collectCoverage: true,
  collectCoverageFrom: [
    'src/**/*.{ts,tsx}',
    '!src/**/*.d.ts',
    '!src/**/*.test.ts',
    '!src/**/__mocks__/**',
    '!src/**/types/**'
  ],

  coverageThresholds: {
    global: {
      statements: 80,
      branches: 80,
      functions: 80,
      lines: 80
    }
  },

  coverageReporters: ['text', 'lcov', 'html', 'json-summary'],
  coverageDirectory: 'coverage',

  transform: {
    '^.+\\.tsx?$': ['ts-jest', {
      tsconfig: 'tsconfig.json',
      diagnostics: true
    }]
  },

  moduleNameMapper: {
    '^@/(.*)$': '<rootDir>/src/$1'
  }
};

Success Criteria:

• ✅ Coverage report shows actual percentages (not 0%)
• ✅ Coverage HTML report generated in /coverage directory
• ✅ npm run test:coverage completes without errors

Agent: coder Priority: CRITICAL Effort: 4-6 hours Dependencies: DEPLOY-001

---

TEST-002 through TEST-011: Additional Test Fixes

See test-coverage-implementation-plan.md for complete details:

• TEST-002: Fix EventBus tests (4h)
• TEST-003: Fix FleetManager tests (6h)
• TEST-004: Fix FlakyTestDetector tests (4h)
• TEST-005: Create BaseAgent edge case tests (16h)
• TEST-006: Multi-agent load testing (12h)
• TEST-007: E2E QE workflow tests (16h)
• TEST-008: SwarmMemoryManager security tests (16h)
• TEST-009: Performance benchmarking (16h)
• TEST-010: Chaos engineering tests (20h)
• TEST-011: Property-based testing (12h)

Total Effort: 106-144 hours across 4 phases

---

3. Sprint 3: Advanced Features (Optional)

3.1 Agentic-Flow Integration (60-80h)

Note: This sprint focuses on enhancing existing capabilities, NOT creating new agents.

AF-001: Multi-Model Router Expansion (24h)

Objective: Extend from 4 models to 100+ with 5-tier architecture

Current:

• 4 models (GPT-3.5, GPT-4, Claude Haiku, Claude Sonnet 4.5)
• 70-81% cost savings

Enhanced:

• 100+ models via OpenRouter
• 5 tiers: Flagship, Cost-Effective, Budget, Local (ONNX), Ultra-Budget
• 85-90% cost savings

Implementation:

// src/routing/EnhancedModelRouter.ts (create)
export class EnhancedModelRouter {
  private tiers: ModelTier[] = [
    { name: 'flagship', models: ['claude-sonnet-4.5', 'gpt-4o'] },
    { name: 'cost-effective', models: ['deepseek-r1', 'claude-haiku'] },
    { name: 'budget', models: ['llama-3.1-8b', 'gpt-3.5-turbo'] },
    { name: 'local', models: ['phi-4-onnx'] },
    { name: 'ultra-budget', models: ['qwen-2.5'] }
  ];

  async selectModel(complexity: string, preferences: any): Promise<string> {
    // Intelligent routing based on complexity and budget
  }
}

Success Criteria:

• ✅ 100+ models supported
• ✅ 85-90% cost savings
• ✅ Local model fallback works offline

Agent: coder Priority: HIGH Effort: 24 hours ROI: $51,000/year savings

---

AF-002: Local Model Integration (Phi-4 ONNX) (16h)

Objective: Zero-cost offline operations via local ONNX model

Implementation:

// src/models/Phi4ONNXRunner.ts (create)
import * as onnx from 'onnxruntime-node';

export class Phi4ONNXRunner {
  private session: onnx.InferenceSession;

  async initialize(modelPath: string): Promise<void> {
    this.session = await onnx.InferenceSession.create(modelPath);
  }

  async generate(prompt: string): Promise<string> {
    // Run inference locally (zero API cost)
  }
}

Success Criteria:

• ✅ Local model runs offline
• ✅ Zero API cost
• ✅ Quality ≥75%

Agent: coder Priority: HIGH Effort: 16 hours ROI: $10,000/year savings

---

AF-007 through AF-012: QUIC Transport & Agent Booster

QUIC Transport (64h):

• AF-007: Implement QUIC Transport Layer (40h)
• AF-008: Integrate QUIC with EventBus (24h)
• Benefit: 50-70% faster agent coordination

Agent Booster (104h):

• AF-009: Build Rust/WASM Booster Module (40h)
• AF-010: Create TypeScript WASM Wrapper (16h)
• AF-011: Integrate Booster with TestGeneratorAgent (24h)
• AF-012: Optimize Pattern Bank with WASM (24h)
• Benefit: 352x faster deterministic operations

Total Sprint 3 Effort: 168-200 hours (optional)

---

4. Task Dependency Graph

┌──────────────────────────────────────────────────────────┐
│ CRITICAL PATH: Deployment Readiness (8-10 hours)        │
└──────────────────────────────────────────────────────────┘
              ↓
┌──────────────────────────────────────────────────────────┐
│ DEPLOY-001: Jest Environment Fix (0.5-1h)               │
│ ⚠️ BLOCKS 46 TESTS (86.8% of failures)                  │
└──────────────────────────────────────────────────────────┘
              ↓
    ┌─────────┴─────────┬─────────┬─────────┬─────────┐
    ↓                   ↓         ↓         ↓         ↓
┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐
│DEPLOY-002│  │DEPLOY-003│  │DEPLOY-004│  │DEPLOY-005│  │DEPLOY-006│
│DB Mocks  │  │Stats Fix │  │Imports   │  │EventBus  │  │Learning  │
│(1h)      │  │(0.5h)    │  │(0.5h)    │  │(0.5h)    │  │Tests(1h) │
└────┬─────┘  └────┬─────┘  └────┬─────┘  └────┬─────┘  └────┬─────┘
     └─────────────┴─────────────┴─────────────┴─────────────┘
                                ↓
                    ┌───────────────────────┐
                    │ DEPLOY-007: Coverage  │
                    │ Validation (1h)       │
                    └───────────────────────┘
                                ↓
                    ┌───────────────────────┐
                    │ PRODUCTION READY      │
                    │ (v1.1.0)              │
                    └───────────────────────┘

PARALLEL TRACK (Can run concurrently with deployment fixes):
┌──────────────────────────────────────────────────────────┐
│ Test Infrastructure Improvements (40 hours)              │
├──────────────────────────────────────────────────────────┤
│ TEST-001: Coverage Instrumentation (6h)                  │
│ TEST-002-005: Unit Test Fixes (30h)                     │
│ TEST-006-007: Integration Tests (28h)                   │
│ TEST-008: Security Tests (16h)                          │
│ TEST-009-010: Performance & Chaos Tests (36h)           │
│ TEST-011: Property-Based Tests (12h)                    │
└──────────────────────────────────────────────────────────┘

OPTIONAL TRACK (Sprint 3 - After production deployment):
┌──────────────────────────────────────────────────────────┐
│ Advanced Features (168-200 hours, optional)              │
├──────────────────────────────────────────────────────────┤
│ AF-001-002: Multi-Model Router + Local Models (40h)     │
│ AF-007-008: QUIC Transport (64h)                        │
│ AF-009-012: Agent Booster WASM (104h)                   │
└──────────────────────────────────────────────────────────┘

---

5. Consolidated Task List (JSON)

{
  "master_roadmap_v2": {
    "project": "Agentic QE Fleet",
    "version": "2.0",
    "last_updated": "2025-10-17",
    "critical_discovery": "Sprint 2 Memory System already complete with 15 SQLite tables in SwarmMemoryManager.ts",
    "time_saved": "60 hours",
    "cost_saved": "$9,000",

    "sprints": [
      {
        "id": "sprint-1",
        "name": "Test Infrastructure & Deployment Readiness",
        "duration_weeks": 2,
        "effort_hours": 48,
        "priority": "CRITICAL",

        "phase_1_deployment_readiness": {
          "duration": "8-10 hours",
          "critical_path": true,
          "tasks": [
            {
              "id": "DEPLOY-001",
              "title": "Fix Jest environment - process.cwd() issue",
              "agent": "coder",
              "effort_hours": 1,
              "priority": "CRITICAL",
              "blocks": "46 tests (86.8% of failures)",
              "files": ["jest.config.js", "jest.setup.ts"],
              "dependencies": [],
              "success_criteria": [
                "No ENOENT errors",
                "46+ tests now able to run",
                "process.cwd() returns valid path"
              ]
            },
            {
              "id": "DEPLOY-002",
              "title": "Fix database mock initialization methods",
              "agent": "coder",
              "effort_hours": 1,
              "priority": "HIGH",
              "files": [
                "tests/unit/fleet-manager.test.ts",
                "tests/cli/advanced-commands.test.ts"
              ],
              "dependencies": ["DEPLOY-001"],
              "success_criteria": [
                "No 'initialize is not a function' errors",
                "Fleet manager tests pass",
                "CLI advanced commands tests pass"
              ]
            },
            {
              "id": "DEPLOY-003",
              "title": "Fix statistical analysis floating point precision",
              "agent": "coder",
              "effort_hours": 0.5,
              "priority": "MEDIUM",
              "files": ["tests/unit/learning/StatisticalAnalysis.test.ts"],
              "dependencies": ["DEPLOY-001"],
              "success_criteria": [
                "No floating point precision errors",
                "Statistical analysis tests pass"
              ]
            },
            {
              "id": "DEPLOY-004",
              "title": "Fix agent test module import paths",
              "agent": "coder",
              "effort_hours": 0.5,
              "priority": "HIGH",
              "files": ["tests/cli/agent.test.ts"],
              "dependencies": ["DEPLOY-001"],
              "success_criteria": [
                "No module import errors",
                "Agent CLI tests pass"
              ]
            },
            {
              "id": "DEPLOY-005",
              "title": "Fix EventBus initialization timing issue",
              "agent": "coder",
              "effort_hours": 0.5,
              "priority": "MEDIUM",
              "files": ["tests/unit/EventBus.test.ts"],
              "dependencies": ["DEPLOY-001"],
              "success_criteria": [
                "No timing-related test failures",
                "EventBus tests pass consistently"
              ]
            },
            {
              "id": "DEPLOY-006",
              "title": "Fix learning system test model initialization",
              "agent": "coder",
              "effort_hours": 1,
              "priority": "MEDIUM",
              "files": [
                "tests/unit/learning/FlakyTestDetector.test.ts",
                "tests/unit/learning/SwarmIntegration.test.ts"
              ],
              "dependencies": ["DEPLOY-001"],
              "success_criteria": [
                "ML models properly initialized before tests",
                "Flaky detection tests pass",
                "Swarm integration tests pass"
              ]
            },
            {
              "id": "DEPLOY-007",
              "title": "Validate test coverage meets 80%+ threshold",
              "agent": "qe-coverage-analyzer",
              "effort_hours": 1,
              "priority": "CRITICAL",
              "files": [],
              "dependencies": [
                "DEPLOY-001",
                "DEPLOY-002",
                "DEPLOY-003",
                "DEPLOY-004",
                "DEPLOY-005",
                "DEPLOY-006"
              ],
              "success_criteria": [
                "All tests passing (0 failures)",
                "Statements coverage ≥ 80%",
                "Branches coverage ≥ 80%",
                "Functions coverage ≥ 80%",
                "Lines coverage ≥ 80%",
                "Coverage report generated successfully"
              ]
            }
          ]
        },

        "phase_2_test_infrastructure": {
          "duration": "40 hours (parallel with deployment)",
          "critical_path": false,
          "tasks": [
            {
              "id": "TEST-001",
              "title": "Fix coverage instrumentation",
              "agent": "coder",
              "effort_hours": 6,
              "priority": "CRITICAL",
              "files": ["jest.config.js", "package.json"],
              "dependencies": [],
              "success_criteria": [
                "Coverage report shows actual percentages",
                "Coverage HTML report generated",
                "npm run test:coverage completes without errors"
              ]
            },
            {
              "id": "TEST-002",
              "title": "Fix EventBus initialization test",
              "agent": "tester",
              "effort_hours": 4,
              "priority": "CRITICAL",
              "files": ["tests/unit/EventBus.test.ts"],
              "dependencies": ["TEST-001"],
              "success_criteria": [
                "Test passes consistently",
                "Idempotent initialization verified"
              ]
            },
            {
              "id": "TEST-003",
              "title": "Fix FleetManager database initialization",
              "agent": "coder",
              "effort_hours": 6,
              "priority": "CRITICAL",
              "files": ["tests/unit/fleet-manager.test.ts"],
              "dependencies": ["TEST-001"],
              "success_criteria": [
                "All FleetManager tests pass",
                "Database initialization verified"
              ]
            },
            {
              "id": "TEST-004",
              "title": "Fix FlakyTestDetector ML model tests",
              "agent": "tester",
              "effort_hours": 4,
              "priority": "HIGH",
              "files": ["tests/unit/learning/FlakyTestDetector.test.ts"],
              "dependencies": ["TEST-001"],
              "success_criteria": [
                "ML model tests pass consistently",
                "Deterministic behavior with fixed seed"
              ]
            },
            {
              "id": "TEST-005",
              "title": "Create BaseAgent edge case tests",
              "agent": "tester",
              "effort_hours": 16,
              "priority": "HIGH",
              "files": ["tests/agents/BaseAgent.edge-cases.test.ts"],
              "dependencies": ["TEST-001"],
              "success_criteria": [
                "All edge case tests pass",
                "Hook failure scenarios covered",
                "Concurrent operation safety verified"
              ]
            }
          ]
        }
      },

      {
        "id": "sprint-2",
        "name": "SKIPPED - Memory System Already Complete",
        "status": "NOT_NEEDED",
        "reason": "SwarmMemoryManager.ts already implements 15 SQLite tables with full feature set",
        "evidence": "src/core/memory/SwarmMemoryManager.ts (1,989 lines)",
        "time_saved": "60 hours",
        "cost_saved": "$9,000"
      },

      {
        "id": "sprint-3",
        "name": "Advanced Features (Optional)",
        "duration_weeks": 8,
        "effort_hours": 168,
        "priority": "OPTIONAL",
        "start_condition": "After v1.1.0 production deployment",

        "tasks": [
          {
            "id": "AF-001",
            "title": "Create Enhanced Multi-Model Router",
            "agent": "coder",
            "effort_hours": 24,
            "priority": "HIGH",
            "roi_annual": 51000,
            "files": [
              "src/routing/EnhancedModelRouter.ts",
              "src/config/models.config.ts",
              "tests/routing/EnhancedModelRouter.test.ts"
            ],
            "dependencies": [],
            "success_criteria": [
              "100+ models supported",
              "85-90% cost savings achieved",
              "All tests pass"
            ]
          },
          {
            "id": "AF-002",
            "title": "Integrate Phi-4 ONNX Local Model",
            "agent": "coder",
            "effort_hours": 16,
            "priority": "HIGH",
            "roi_annual": 10000,
            "files": [
              "src/models/Phi4ONNXRunner.ts",
              "models/phi-4.onnx",
              "tests/models/Phi4ONNXRunner.test.ts"
            ],
            "dependencies": ["AF-001"],
            "success_criteria": [
              "Local model runs offline",
              "Zero API cost for offline ops",
              "Quality ≥75%"
            ]
          },
          {
            "id": "AF-007",
            "title": "Implement QUIC Transport Layer",
            "agent": "coder",
            "effort_hours": 40,
            "priority": "MEDIUM",
            "roi_annual": 10800,
            "files": [
              "src/transport/QUICTransport.ts",
              "tests/transport/QUICTransport.test.ts"
            ],
            "dependencies": [],
            "success_criteria": [
              "QUIC operational",
              "50-70% latency reduction",
              "0-RTT working",
              "100+ streams supported"
            ]
          },
          {
            "id": "AF-008",
            "title": "Integrate QUIC with EventBus",
            "agent": "coder",
            "effort_hours": 24,
            "priority": "MEDIUM",
            "roi_annual": 10800,
            "files": ["src/core/EventBus.ts"],
            "dependencies": ["AF-007"],
            "success_criteria": [
              "QUIC integration complete",
              "Fallback to TCP works",
              "Latency reduced 50-70%"
            ]
          },
          {
            "id": "AF-009",
            "title": "Build Rust/WASM Booster Module",
            "agent": "coder",
            "effort_hours": 40,
            "priority": "MEDIUM",
            "roi_annual": 36000,
            "files": [
              "booster/src/lib.rs",
              "booster/Cargo.toml",
              "scripts/build-wasm.sh"
            ],
            "dependencies": [],
            "success_criteria": [
              "WASM module compiles",
              "1000 templates in <1s",
              "352x speedup achieved"
            ]
          },
          {
            "id": "AF-010",
            "title": "Create TypeScript WASM Wrapper",
            "agent": "coder",
            "effort_hours": 16,
            "priority": "MEDIUM",
            "roi_annual": 36000,
            "files": [
              "src/acceleration/AgentBooster.ts",
              "tests/acceleration/AgentBooster.test.ts"
            ],
            "dependencies": ["AF-009"],
            "success_criteria": [
              "TypeScript wrapper works",
              "All methods functional",
              "Performance maintained"
            ]
          },
          {
            "id": "AF-011",
            "title": "Integrate Booster with TestGeneratorAgent",
            "agent": "coder",
            "effort_hours": 24,
            "priority": "MEDIUM",
            "roi_annual": 36000,
            "files": ["src/agents/TestGeneratorAgent.ts"],
            "dependencies": ["AF-010"],
            "success_criteria": [
              "Hybrid mode operational",
              "352x speedup for templates",
              "100% cost reduction for patterns"
            ]
          },
          {
            "id": "AF-012",
            "title": "Optimize Pattern Bank with WASM",
            "agent": "coder",
            "effort_hours": 24,
            "priority": "LOW",
            "roi_annual": 12000,
            "files": ["src/learning/PatternBank.ts"],
            "dependencies": ["AF-010"],
            "success_criteria": [
              "Pattern application <1s",
              "Zero API cost",
              "Quality maintained"
            ]
          }
        ]
      }
    ],

    "summary": {
      "total_sprints": 2,
      "sprint_2_removed": true,
      "total_effort_hours": 216,
      "critical_path_hours": 48,
      "optional_hours": 168,
      "time_saved": 60,
      "cost_saved": 9000,
      "weeks_saved": 2,

      "immediate_focus": [
        "Deploy v1.1.0 (8-10 hours)",
        "Fix 53 test failures (majority from 1 issue)",
        "Achieve 80%+ test coverage",
        "Validate deployment readiness"
      ],

      "optional_enhancements": [
        "Multi-model router expansion (85-90% cost savings)",
        "Local ONNX model support (offline operation)",
        "QUIC transport (50-70% faster coordination)",
        "WASM booster (352x faster operations)"
      ]
    }
  }
}

---

6. Execution Timeline

Week 1: Critical Path (8-10 hours)

Day 1 (0-4 hours):
├─ DEPLOY-001: Jest environment fix [0.5-1h] ──┐
├─ DEPLOY-002: Database mocks [1h]             ├─→ DEPLOY-007: Coverage [1h]
├─ DEPLOY-003: Statistical precision [0.5h]    │
├─ DEPLOY-004: Module imports [0.5h]           │
├─ DEPLOY-005: EventBus timing [0.5h]          │
└─ DEPLOY-006: Learning tests [1h] ────────────┘

Parallel Track (Day 1-2):
└─ TEST-001: Coverage instrumentation [6h]

Day 2-3 (4-10 hours):
├─ TEST-002: EventBus tests [4h]
├─ TEST-003: FleetManager tests [6h]
└─ TEST-004: FlakyTestDetector [4h]

Milestone: v1.1.0 Production Ready (End of Week 1)

Week 2-3: Test Infrastructure (30-40 hours)

Week 2:
├─ TEST-005: BaseAgent edge cases [16h]
├─ TEST-006: Multi-agent load testing [12h]
└─ TEST-007: E2E QE workflow [16h]

Week 3:
├─ TEST-008: Security tests [16h]
├─ TEST-009: Performance benchmarks [16h]
├─ TEST-010: Chaos engineering [20h]
└─ TEST-011: Property-based tests [12h]

Milestone: 80%+ Test Coverage (End of Week 3)

Week 4-12: Advanced Features (Optional, 168h)

Week 4-5: Multi-Model Router + Local Models
├─ AF-001: Enhanced router [24h]
└─ AF-002: Phi-4 ONNX integration [16h]

Week 6-8: QUIC Transport
├─ AF-007: QUIC implementation [40h]
└─ AF-008: EventBus integration [24h]

Week 9-12: Agent Booster (WASM)
├─ AF-009: Rust/WASM module [40h]
├─ AF-010: TypeScript wrapper [16h]
├─ AF-011: TestGenerator integration [24h]
└─ AF-012: Pattern Bank optimization [24h]

Milestone: Enhanced capabilities operational (End of Week 12)

---

7. Success Metrics

7.1 Deployment Readiness Gate (Week 1)

• Gate 1: All tests passing (0 failures)
• Gate 2: Coverage ≥ 80% (all metrics)
• Gate 3: No critical bugs
• Gate 4: Performance benchmarks pass
• Gate 5: Security scan clean

Status: READY when all gates pass

7.2 Test Infrastructure Gate (Week 2-3)

• Coverage > 80% across all modules
• Pass rate 100% (382/382 tests)
• Edge cases covered for core modules
• Integration tests comprehensive
• Performance benchmarks established

7.3 Advanced Features Gate (Week 4-12, Optional)

• Cost savings 85-90% (vs current 70-81%)
• Coordination latency -50-70%
• Template expansion 352x faster
• Local model operational (offline support)

---

Conclusion

This revised master roadmap correctly reflects the current state:

✅ Sprint 2 Memory System: Already complete (15 tables, 1,989 lines) ✅ Time Saved: 60 hours ($9,000 @ $150/hr) ✅ Faster to Production: 2 weeks earlier

Recommended Execution:

1. Week 1: Deploy v1.1.0 (critical path: 8-10 hours)
2. Week 2-3: Test infrastructure improvements (parallel)
3. Week 4+: Advanced features (optional, evaluate ROI)

Next Steps:

1. Confirm updated plan with stakeholders
2. Begin DEPLOY-001 (Jest environment fix)
3. Monitor progress with daily standups
4. Evaluate Sprint 3 features after v1.1.0 deployment

---

Document Version: 2.0 (Revised) Last Updated: October 17, 2025 Author: Claude (Code-Goal-Planner Agent) Approval Status: PENDING