claude-flow-novice 2.0.0 → 2.0.1

package/.claude-flow-novice/dist/cfn-loop/cfn-loop-orchestrator.d.ts

@@ -21,6 +21,8 @@
 import { EventEmitter } from 'events';
 import { ConfidenceScore, ConfidenceValidationResult } from '../coordination/confidence-score-system.js';
 import { ConsensusFeedback } from './feedback-injection-system.js';
+import type { ByzantineAdapterConfig, ByzantineConsensusResult, ProductOwnerDecision } from './types.js';
+import { type CFNLoopModeName } from './modes/index.js';
 export interface CFNLoopConfig {
     phaseId: string;
     swarmId?: string;
@@ -32,6 +34,12 @@ export interface CFNLoopConfig {
     enableCircuitBreaker?: boolean;
     enableMemoryPersistence?: boolean;
     memoryConfig?: any;
+    enableByzantineConsensus?: boolean;
+    byzantineConfig?: ByzantineAdapterConfig;
+    cfnMode?: CFNLoopModeName;
+    epicFilename?: string;
+    epicMetadata?: any;
+    autoDetectMode?: boolean;
 }
 export interface AgentResponse {
     agentId: string;
@@ -67,6 +75,7 @@ export interface PhaseResult {
     finalDeliverables: any[];
     confidenceScores: ConfidenceScore[];
     consensusResult: ConsensusResult;
+    productOwnerDecision?: ProductOwnerDecision;
     escalated: boolean;
     escalationReason?: string;
     statistics: PhaseStatistics;
@@ -99,6 +108,9 @@ export declare class CFNLoopOrchestrator extends EventEmitter {
     private feedbackSystem;
     private circuitBreaker;
     private memoryManager?;
+    private byzantineAdapter?;
+    private mode;
+    private planningConsensusResult?;
     private phaseStartTime;
     private statistics;
     private currentFeedback?;
@@ -133,8 +145,188 @@ export declare class CFNLoopOrchestrator extends EventEmitter {
     collectConfidence(responses: AgentResponse[]): Promise<ConfidenceScore[]>;
     /**
      * Execute consensus validation (Loop 2)
+     *
+     * Spawns 4 validator agents (reviewer, security-specialist, tester, analyst)
+     * and executes consensus validation using Byzantine consensus if enabled.
+     *
+     * @param primaryResponses - Responses from Loop 3 primary swarm
+     * @returns Consensus result (Byzantine or simple)
+     */
+    executeConsensusValidation(primaryResponses: AgentResponse[]): Promise<ConsensusResult | ByzantineConsensusResult>;
+    /**
+     * Execute Byzantine consensus validation with PBFT
+     *
+     * Process:
+     * 1. Spawn 4 validator agents (reviewer, security-specialist, tester, analyst)
+     * 2. Collect validator responses
+     * 3. Execute Byzantine consensus via adapter
+     * 4. Return ByzantineConsensusResult
+     *
+     * @param primaryResponses - Responses from primary swarm
+     * @returns Byzantine consensus result
+     */
+    private executeByzantineConsensus;
+    /**
+     * Execute simple consensus validation (fallback)
+     *
+     * Simple majority voting without Byzantine fault tolerance.
+     *
+     * @param primaryResponses - Responses from primary swarm
+     * @returns Simple consensus result
+     */
+    private executeSimpleConsensus;
+    /**
+     * Spawn 4 validator agents for Byzantine consensus
+     *
+     * Spawns:
+     * 1. reviewer - Code quality, architecture, maintainability
+     * 2. security-specialist - Security vulnerabilities, attack vectors
+     * 3. tester - Test coverage, edge cases, validation
+     * 4. analyst - Overall quality, confidence scoring
+     *
+     * @param primaryResponses - Primary swarm responses to validate
+     * @returns Array of validator responses
+     */
+    private spawnValidatorAgents;
+    /**
+     * Spawn 2 simple validators (fallback)
+     *
+     * @param primaryResponses - Primary swarm responses to validate
+     * @returns Array of simple validator responses
+     */
+    private spawnSimpleValidators;
+    /**
+     * Spawn a single validator agent using Task tool
+     *
+     * @param role - Agent role (reviewer, security-specialist, tester, analyst)
+     * @param agentId - Unique agent identifier
+     * @param prompt - Validation prompt with context
+     * @param context - Primary swarm responses for reference
+     * @returns Parsed validator response
+     */
+    private spawnValidator;
+    /**
+     * Execute validator task (Task tool integration point)
+     *
+     * This method encapsulates the actual Task tool call for validator agents.
+     * In production, this calls Claude Code's Task() function to spawn real agents.
+     *
+     * @param role - Validator role type
+     * @param prompt - Complete validation prompt with context
+     * @returns Validator output string (JSON format expected)
+     */
+    private executeValidatorTask;
+    /**
+     * Parse validator output from agent response
+     *
+     * Handles JSON extraction from markdown code fences and plain JSON.
+     * Validates response structure and returns AgentResponse format.
+     *
+     * @param output - Raw validator output string
+     * @param role - Validator role for fallback
+     * @param agentId - Agent identifier
+     * @returns Parsed AgentResponse
+     */
+    private parseValidatorOutput;
+    /**
+     * Generate realistic validator response for mock implementation
+     *
+     * This generates realistic validator JSON responses based on role.
+     * Used during Sprint 1.6 before Task tool integration.
+     *
+     * @param role - Validator role type
+     * @returns Mock validator response object
+     */
+    private generateRealisticValidatorResponse;
+    /**
+     * Prepare validation context for validators
+     *
+     * @param primaryResponses - Loop 3 implementation results
+     * @returns Formatted validation context string
+     */
+    private prepareValidationContext;
+    /**
+     * Generate validator reasoning based on role and confidence
+     */
+    private generateValidatorReasoning;
+    /**
+     * Generate validator recommendations based on role
+     */
+    private generateValidatorRecommendations;
+    /**
+     * Create fallback validators when spawning fails
+     */
+    private createFallbackValidators;
+    /**
+     * Execute Loop 4: Product Owner Decision Gate (GOAP)
+     *
+     * Makes autonomous decision based on Loop 2 consensus results:
+     * - PROCEED: Continue to next phase/sprint
+     * - DEFER: Approve with backlog for minor issues
+     * - ESCALATE: Critical issues require human review
+     *
+     * @param consensusResult - Loop 2 consensus validation result
+     * @param primaryResponses - Loop 3 implementation results
+     * @returns Product Owner decision
+     */
+    private executeProductOwnerDecision;
+    /**
+     * Prepare decision context for Product Owner
+     */
+    private prepareProductOwnerContext;
+    /**
+     * Format consensus results for Product Owner prompt
+     */
+    private formatConsensusResults;
+    /**
+     * Format implementation summary for Product Owner prompt
+     */
+    private formatImplementationSummary;
+    /**
+     * Spawn Product Owner agent with GOAP decision authority
+     *
+     * In production with Claude Code Task tool, this would be:
+     * const result = await Task("product-owner", prompt, "product-owner");
+     *
+     * For Sprint 1.6, implements Task tool integration point with realistic mock.
+     *
+     * @param prompt - Decision prompt with consensus and implementation context
+     * @returns JSON string with ProductOwnerDecision
+     */
+    private spawnProductOwner;
+    /**
+     * Execute Product Owner task (Task tool integration point)
+     *
+     * This method encapsulates the actual Task tool call for Product Owner agent.
+     * In production, this calls Claude Code's Task() function to spawn real agent.
+     *
+     * @param prompt - Complete GOAP decision prompt with context
+     * @returns Product Owner output string (JSON format expected)
+     */
+    private executeProductOwnerTask;
+    /**
+     * Generate realistic Product Owner GOAP decision for mock implementation
+     *
+     * Implements GOAP (Goal-Oriented Action Planning) decision logic:
+     * - PROCEED: High confidence, no critical issues
+     * - DEFER: Good confidence, minor issues to backlog
+     * - ESCALATE: Low confidence, critical blockers
+     *
+     * @returns Mock Product Owner decision object
+     */
+    private generateRealisticProductOwnerDecision;
+    /**
+     * Parse Product Owner decision from response
+     */
+    private parseProductOwnerDecision;
+    /**
+     * Validate and normalize Product Owner decision
+     */
+    private validateProductOwnerDecision;
+    /**
+     * Create backlog items in memory for deferred work
      */
-    executeConsensusValidation(primaryResponses: AgentResponse[]): Promise<ConsensusResult>;
+    private createBacklogItems;
     /**
      * Capture feedback and prepare for retry
      */

package/.claude-flow-novice/dist/cfn-loop/checkpoint-serializer.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Checkpoint Serializer - State Compression and Serialization
+ *
+ * Provides efficient serialization and compression for checkpoint data:
+ * - JSON serialization with optional compression (gzip)
+ * - Incremental serialization (only changed data)
+ * - Size validation (<1MB target)
+ * - Compression ratio tracking
+ *
+ * Acceptance Criteria:
+ * - Serialization latency: <50ms
+ * - Compression ratio: ≥2:1 for typical state
+ * - Target size: <1MB per sprint checkpoint
+ * - Incremental checkpoint: Only serialize changed data
+ *
+ * @module cfn-loop/checkpoint-serializer
+ */
+import type { EpicState } from './state-checkpoint-manager.js';
+/**
+ * Serialized checkpoint data
+ */
+export interface SerializedCheckpoint {
+    data: string;
+    compressed: boolean;
+    sizeBytes: number;
+    originalSizeBytes: number;
+    compressionRatio: number;
+    checksum: string;
+    isIncremental: boolean;
+    timestamp: number;
+}
+/**
+ * Configuration for checkpoint serializer
+ */
+export interface CheckpointSerializerConfig {
+    compressionEnabled?: boolean;
+    compressionLevel?: number;
+    maxSizeBytes?: number;
+    enableChecksums?: boolean;
+    enableIncrementalSerialization?: boolean;
+}
+/**
+ * Serializes and compresses epic state for efficient checkpoint storage
+ *
+ * Features:
+ * - Automatic compression with gzip (configurable level)
+ * - Incremental serialization (only changed data)
+ * - Size validation and warnings
+ * - Checksum generation for integrity verification
+ * - Performance tracking
+ *
+ * Usage:
+ * ```typescript
+ * const serializer = new CheckpointSerializer({
+ *   compressionEnabled: true,
+ *   compressionLevel: 6
+ * });
+ *
+ * const serialized = await serializer.serialize(epicState);
+ * const restored = await serializer.deserialize(serialized);
+ * ```
+ */
+export declare class CheckpointSerializer {
+    private logger;
+    private config;
+    constructor(config?: CheckpointSerializerConfig);
+    /**
+     * Serialize epic state to compressed checkpoint
+     *
+     * @param state Epic state to serialize
+     * @param previousState Previous state for incremental serialization (optional)
+     * @returns Serialized checkpoint data
+     */
+    serialize(state: EpicState, previousState?: EpicState): Promise<SerializedCheckpoint>;
+    /**
+     * Deserialize checkpoint back to epic state
+     *
+     * @param serialized Serialized checkpoint data
+     * @param baseState Base state for incremental deserialization (optional)
+     * @returns Restored epic state
+     */
+    deserialize(serialized: SerializedCheckpoint, baseState?: EpicState): Promise<EpicState>;
+    /**
+     * Compute incremental diff between two states
+     *
+     * @param currentState Current state
+     * @param previousState Previous state
+     * @returns State diff
+     */
+    private computeDiff;
+    /**
+     * Apply diff to base state to reconstruct full state
+     *
+     * @param baseState Base state
+     * @param diff State diff
+     * @returns Reconstructed state
+     */
+    private applyDiff;
+    /**
+     * Generate simple checksum for data integrity verification
+     *
+     * @param data Data to checksum
+     * @returns Checksum string
+     */
+    private generateChecksum;
+    /**
+     * Estimate size of serialized state (without actually serializing)
+     *
+     * @param state State to estimate
+     * @returns Estimated size in bytes
+     */
+    estimateSize(state: EpicState): number;
+}

package/.claude-flow-novice/dist/cfn-loop/circuit-breaker.d.ts

@@ -9,8 +9,12 @@ export interface BreakerOptions {
     timeoutMs?: number;
     /** Number of failures before opening circuit */
     failureThreshold?: number;
-    /** Cooldown period before attempting half-open state (ms) */
+    /** Cooldown period before attempting half-open state (ms) - DEPRECATED: use delays */
     cooldownMs?: number;
+    /** Exponential backoff delays in milliseconds [1s, 2s, 4s, 8s] */
+    delays?: number[];
+    /** Maximum retry attempts (should match delays.length) */
+    maxAttempts?: number;
     /** Number of successes required to close from half-open */
     successThreshold?: number;
     /** Maximum requests allowed in half-open state */
@@ -54,9 +58,11 @@ export declare class CFNCircuitBreaker extends EventEmitter {
     private halfOpenRequests;
     private readonly failureThreshold;
     private readonly successThreshold;
-    private readonly cooldownMs;
+    private readonly delays;
+    private readonly maxAttempts;
     private readonly halfOpenLimit;
     private readonly defaultTimeoutMs;
+    private currentAttempt;
     private logger;
     constructor(name: string, options?: BreakerOptions);
     /**

package/.claude-flow-novice/dist/cfn-loop/conflict-resolver.d.ts

@@ -0,0 +1,221 @@
+/**
+ * Conflict Resolver - Sprint 4.3: File Edit Conflict Resolution
+ *
+ * Detects and resolves file edit conflicts when multiple agents work on the same files.
+ *
+ * Features:
+ * - Redis-based file edit locking
+ * - Conflict detection via version tracking
+ * - Smart merge for non-overlapping changes
+ * - Escalation for complex conflicts
+ * - Audit trail for conflict history
+ *
+ * Conflict Resolution Strategy:
+ * 1. Non-overlapping edits (different lines) → Automatic merge
+ * 2. Overlapping edits (same lines) → Escalate to human
+ * 3. Conflicting type definitions → Escalate with diff
+ *
+ * @module cfn-loop/conflict-resolver
+ */
+import { EventEmitter } from 'events';
+import type { Redis } from 'ioredis';
+/**
+ * File edit metadata
+ */
+export interface FileEditMetadata {
+    /** File path */
+    filePath: string;
+    /** Agent ID performing the edit */
+    agentId: string;
+    /** Sprint ID */
+    sprintId: string;
+    /** File content hash before edit */
+    hashBefore: string;
+    /** File content hash after edit */
+    hashAfter: string;
+    /** Edit timestamp */
+    timestamp: number;
+    /** Lines modified (start, end) */
+    modifiedLines: [number, number][];
+}
+/**
+ * Conflict detection result
+ */
+export interface ConflictDetection {
+    /** Conflict detected? */
+    hasConflict: boolean;
+    /** Type of conflict */
+    conflictType?: 'none' | 'non-overlapping' | 'overlapping' | 'type-conflict';
+    /** Conflicting edits */
+    conflicts?: FileEditMetadata[];
+    /** Can auto-merge? */
+    canAutoMerge: boolean;
+    /** Reason for escalation if cannot merge */
+    escalationReason?: string;
+}
+/**
+ * Merge result
+ */
+export interface MergeResult {
+    /** Merge successful? */
+    success: boolean;
+    /** Merged file content */
+    mergedContent?: string;
+    /** Merge strategy used */
+    strategy: 'auto-merge' | 'manual' | 'escalated';
+    /** Conflicts that were merged */
+    resolvedConflicts: FileEditMetadata[];
+    /** Conflicts that need escalation */
+    escalatedConflicts: FileEditMetadata[];
+    /** Merge timestamp */
+    timestamp: number;
+}
+/**
+ * Conflict audit entry
+ */
+export interface ConflictAuditEntry {
+    /** Unique conflict ID */
+    conflictId: string;
+    /** File path */
+    filePath: string;
+    /** Conflicting agents */
+    agents: string[];
+    /** Conflict type */
+    conflictType: string;
+    /** Resolution strategy */
+    resolution: 'auto-merged' | 'escalated' | 'manual';
+    /** Timestamp */
+    timestamp: number;
+    /** Details */
+    details: any;
+}
+/**
+ * Conflict resolver configuration
+ */
+export interface ConflictResolverConfig {
+    /** Redis client */
+    redisClient: Redis;
+    /** Sprint ID */
+    sprintId: string;
+    /** Project root directory */
+    projectRoot: string;
+    /** Enable automatic merge (default: true) */
+    enableAutoMerge?: boolean;
+    /** Lock timeout in ms (default: 300000 = 5min) */
+    lockTimeout?: number;
+    /** Audit trail enabled (default: true) */
+    enableAudit?: boolean;
+}
+/**
+ * File lock metadata
+ */
+export interface FileLockMetadata {
+    /** Agent holding the lock */
+    agentId: string;
+    /** Sprint ID */
+    sprintId: string;
+    /** Lock acquired timestamp */
+    acquiredAt: number;
+    /** Lock expires at */
+    expiresAt: number;
+    /** File content hash when locked */
+    contentHash: string;
+}
+/**
+ * Conflict Resolver for parallel file editing
+ */
+export declare class ConflictResolver extends EventEmitter {
+    private logger;
+    private config;
+    private redis;
+    private heldLocks;
+    private editHistory;
+    private conflictAudit;
+    private readonly LOCK_KEY_PREFIX;
+    private readonly EDIT_HISTORY_PREFIX;
+    private readonly CONFLICT_AUDIT_PREFIX;
+    constructor(config: ConflictResolverConfig);
+    /**
+     * Acquire edit lock for a file
+     */
+    acquireLock(filePath: string, agentId: string): Promise<{
+        acquired: boolean;
+        existingLock?: FileLockMetadata;
+    }>;
+    /**
+     * Release edit lock for a file
+     */
+    releaseLock(filePath: string, agentId: string): Promise<void>;
+    /**
+     * Detect conflicts for a file edit
+     */
+    detectConflicts(filePath: string, agentId: string, modifiedLines: [number, number][]): Promise<ConflictDetection>;
+    /**
+     * Merge conflicting edits (auto-merge non-overlapping changes)
+     */
+    mergeEdits(filePath: string, agentId: string, newContent: string, conflicts: FileEditMetadata[]): Promise<MergeResult>;
+    /**
+     * Record file edit in history
+     */
+    recordEdit(edit: FileEditMetadata): Promise<void>;
+    /**
+     * Get edit history for a file
+     */
+    private getEditHistory;
+    /**
+     * Check if line ranges overlap
+     */
+    private checkLineOverlap;
+    /**
+     * Determine conflict type
+     */
+    private determineConflictType;
+    /**
+     * Perform automatic merge for non-overlapping changes
+     */
+    private performAutoMerge;
+    /**
+     * Escalate conflict for manual resolution
+     */
+    private escalateConflict;
+    /**
+     * Record conflict audit entry
+     */
+    private recordConflictAudit;
+    /**
+     * Get file content hash (SHA-256)
+     */
+    private getFileHash;
+    /**
+     * Get Redis lock key for file
+     */
+    private getLockKey;
+    /**
+     * Get Redis history key for file
+     */
+    private getHistoryKey;
+    /**
+     * Get conflict statistics
+     */
+    getStatistics(): {
+        sprintId: string;
+        totalConflicts: number;
+        autoMerged: number;
+        escalated: number;
+        autoMergeRate: number;
+        activeFileLocks: number;
+    };
+    /**
+     * Setup exit handlers for cleanup
+     */
+    private setupExitHandlers;
+    /**
+     * Shutdown conflict resolver
+     */
+    shutdown(): Promise<void>;
+}
+/**
+ * Create Conflict Resolver instance
+ */
+export declare function createConflictResolver(config: ConflictResolverConfig): ConflictResolver;
+export default ConflictResolver;

package/.claude-flow-novice/dist/cfn-loop/consensus/enterprise-planning-consensus.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Enterprise Planning Consensus (Loop 0.5)
+ *
+ * Architecture planning consensus BEFORE Loop 3 implementation.
+ * 3 architects vote on ADRs and system diagrams.
+ *
+ * Architects:
+ * 1. architect - Overall system design
+ * 2. system-architect - Technical architecture
+ * 3. security-specialist - Security architecture
+ *
+ * Threshold: 0.85 (higher than Loop 2's 0.90 because early-stage)
+ *
+ * @module cfn-loop/consensus/enterprise-planning-consensus
+ */
+import type { ConsensusResult } from '../types.js';
+/**
+ * Planning consensus vote from architect
+ */
+export interface PlanningVote {
+    agentId: string;
+    agentType: string;
+    vote: 'APPROVE' | 'REJECT';
+    confidence: number;
+    reasoning: string;
+    recommendations: string[];
+    concerns: string[];
+    timestamp: number;
+}
+/**
+ * Planning consensus result with design specification
+ */
+export interface PlanningConsensusResult extends ConsensusResult {
+    designSpec: {
+        adrs: string[];
+        systemDiagrams: string[];
+        securityModel: string;
+        concerns: string[];
+    };
+    architectVotes: PlanningVote[];
+}
+/**
+ * Execute Loop 0.5: Enterprise planning consensus
+ *
+ * Process:
+ * 1. Spawn 3 architect agents
+ * 2. They analyze requirements and create design spec
+ * 3. Vote on design (APPROVE/REJECT)
+ * 4. Threshold: 0.85
+ * 5. Store design spec in SQLite for Loop 3 agents
+ *
+ * @param taskDescription - High-level task for this phase
+ * @param requirements - Business and technical requirements
+ * @param consensusThreshold - Threshold for consensus (default: 0.85)
+ * @returns Planning consensus result with design spec
+ */
+export declare function executePlanningConsensus(taskDescription: string, requirements: string[], consensusThreshold?: number): Promise<PlanningConsensusResult>;
+declare const _default: {
+    executePlanningConsensus: typeof executePlanningConsensus;
+};
+export default _default;

package/.claude-flow-novice/dist/cfn-loop/consensus/mvp-consensus.d.ts

@@ -0,0 +1,33 @@
+/**
+ * MVP Consensus Validator
+ *
+ * Minimal validator team for MVP mode (2 validators).
+ * Speed-focused consensus with basic quality checks.
+ *
+ * Validators:
+ * 1. reviewer - Code quality and maintainability
+ * 2. tester - Test coverage and basic validation
+ *
+ * Threshold: 0.80 (lower than standard 0.90)
+ *
+ * @module cfn-loop/consensus/mvp-consensus
+ */
+import type { AgentResponse, ConsensusResult } from '../types.js';
+/**
+ * Execute MVP consensus validation with 2 validators
+ *
+ * Fast validation for MVP mode:
+ * - 2 validators (reviewer, tester)
+ * - 0.80 consensus threshold
+ * - Skip comprehensive checks
+ * - Focus on basic functionality
+ *
+ * @param primaryResponses - Loop 3 implementation results
+ * @param consensusThreshold - Threshold for consensus (default: 0.80)
+ * @returns Consensus result
+ */
+export declare function executeMVPConsensus(primaryResponses: AgentResponse[], consensusThreshold?: number): Promise<ConsensusResult>;
+declare const _default: {
+    executeMVPConsensus: typeof executeMVPConsensus;
+};
+export default _default;