claude-flow-novice 2.0.0 → 2.0.1

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

@@ -0,0 +1,268 @@
+/**
+ * Production Blocking Coordination - Signal ACK Protocol
+ *
+ * Implements coordinator acknowledgment mechanism for distributed agent coordination.
+ * Part of Sprint 1.1: Signal ACK Protocol
+ *
+ * Features:
+ * - Immediate ACK on signal reception
+ * - Timestamp tracking for coordination timing
+ * - Iteration count for retry loop coordination
+ * - Redis persistence with 1-hour TTL
+ * - Idempotent ACK handling
+ * - HMAC-SHA256 cryptographic ACK verification (SEC-CRIT-001)
+ * - Input validation against injection attacks (SEC-HIGH-001)
+ *
+ * @module cfn-loop/blocking-coordination
+ */
+import type { Redis } from 'ioredis';
+import type { AgentLifecycleManager } from '../agents/lifecycle-manager.js';
+import type { AgentDefinition } from '../agents/agent-loader.js';
+/**
+ * Signal ACK structure
+ */
+export interface SignalAck {
+    /** Coordinator ID that sent the ACK */
+    coordinatorId: string;
+    /** Signal ID that triggered the ACK */
+    signalId: string;
+    /** Timestamp when ACK was sent (ms since epoch) */
+    timestamp: number;
+    /** Current iteration count (for retry loops) */
+    iteration: number;
+    /** ACK status - always "received" on initial send */
+    status: 'received';
+    /** HMAC-SHA256 signature for ACK verification (SEC-CRIT-001) */
+    signature: string;
+    /** Optional metadata for debugging */
+    metadata?: {
+        /** Signal type (e.g., "completion", "retry", "validation") */
+        signalType?: string;
+        /** Phase or context information */
+        phase?: string;
+    };
+}
+/**
+ * Signal structure for coordinator communication
+ */
+export interface CoordinationSignal {
+    /** Unique signal identifier */
+    signalId: string;
+    /** Signal type */
+    type: 'completion' | 'retry' | 'validation' | 'error';
+    /** Source coordinator that sent the signal */
+    source: string;
+    /** Target coordinator(s) */
+    targets: string[];
+    /** Signal payload */
+    payload?: any;
+    /** Timestamp when signal was created */
+    timestamp: number;
+}
+/**
+ * Configuration for blocking coordination
+ */
+export interface BlockingCoordinationConfig {
+    /** Redis client instance (ioredis) */
+    redisClient: Redis;
+    /** Coordinator ID for this instance */
+    coordinatorId: string;
+    /** TTL for ACK keys in seconds (default: 3600 = 1 hour) */
+    ackTtl?: number;
+    /** Enable debug logging */
+    debug?: boolean;
+    /** HMAC secret for ACK signing (SEC-CRIT-001) - defaults to env var or random */
+    hmacSecret?: string;
+    /** Lifecycle manager for hook execution (optional) */
+    lifecycleManager?: AgentLifecycleManager;
+    /** Agent profile for hook definitions (optional) */
+    agentProfile?: AgentDefinition;
+    /** Agent ID for hook execution context (optional) */
+    agentId?: string;
+    /** Current task description for hook context (optional) */
+    currentTask?: string;
+    /** Swarm ID for hook context (optional) */
+    swarmId?: string;
+    /** Current phase for hook context (optional) */
+    phase?: string;
+    /** CFN Loop memory manager for SQLite audit trail (optional) */
+    cfnMemoryManager?: any;
+}
+/**
+ * Manages blocking coordination and signal acknowledgment for CFN Loop coordinators
+ */
+export declare class BlockingCoordinationManager {
+    private logger;
+    private redis;
+    private coordinatorId;
+    private ackTtl;
+    private debug;
+    private hmacSecret;
+    private currentIteration;
+    private processedSignals;
+    private lifecycleManager?;
+    private agentProfile?;
+    private agentId?;
+    private currentTask?;
+    private swarmId?;
+    private phase?;
+    private cfnMemoryManager?;
+    private metrics;
+    private blockingStartTime?;
+    constructor(config: BlockingCoordinationConfig);
+    /**
+     * Process incoming signal and send immediate ACK
+     *
+     * CRITICAL: This method MUST be called BEFORE processing the signal payload.
+     * The ACK confirms receipt, allowing the sender to proceed without waiting.
+     *
+     * @param signal - Coordination signal to acknowledge
+     * @returns ACK object with timestamp and iteration
+     */
+    acknowledgeSignal(signal: CoordinationSignal): Promise<SignalAck>;
+    /**
+     * Retrieve ACK for a specific signal
+     *
+     * @param signalId - Signal ID to retrieve ACK for
+     * @returns ACK object if found, null otherwise
+     */
+    getAck(signalId: string): Promise<SignalAck | null>;
+    /**
+     * Check if a signal has been acknowledged by a specific coordinator
+     *
+     * @param coordinatorId - Coordinator to check
+     * @param signalId - Signal ID to check
+     * @returns True if ACK exists, false otherwise
+     */
+    isAcknowledged(coordinatorId: string, signalId: string): Promise<boolean>;
+    /**
+     * Wait for ACKs from multiple coordinators
+     *
+     * @param coordinatorIds - List of coordinator IDs to wait for
+     * @param signalId - Signal ID to check ACKs for
+     * @param timeoutMs - Maximum time to wait in milliseconds (default: 30000 = 30s)
+     * @returns Map of coordinator IDs to their ACKs
+     */
+    waitForAcks(coordinatorIds: string[], signalId: string, timeoutMs?: number): Promise<Map<string, SignalAck>>;
+    /**
+     * Increment iteration counter (called when entering a new retry loop)
+     *
+     * @returns New iteration count
+     */
+    incrementIteration(): number;
+    /**
+     * Get current iteration count
+     *
+     * @returns Current iteration number
+     */
+    getCurrentIteration(): number;
+    /**
+     * Reset iteration counter (called when starting fresh coordination)
+     */
+    resetIteration(): void;
+    /**
+     * Clear processed signals cache
+     */
+    clearProcessedSignals(): void;
+    /**
+     * Get hook execution metrics
+     *
+     * @returns Metrics object with hook execution statistics
+     */
+    getHookMetrics(): {
+        hooksExecuted: number;
+        hooksFailed: number;
+        hookExecutionTimeMs: number;
+        averageHookDuration: number;
+    };
+    /**
+     * Retry failed signal with exponential backoff
+     *
+     * Sprint 3.2: Auto-Recovery Mechanisms
+     *
+     * Implements retry mechanism for signal acknowledgment failures.
+     * Uses exponential backoff to avoid overwhelming the system.
+     *
+     * @param signal - Signal that failed to be acknowledged
+     * @param maxRetries - Maximum number of retry attempts (default: 3)
+     * @returns SignalAck if successful, null if all retries failed
+     */
+    retryFailedSignal(signal: CoordinationSignal, maxRetries?: number): Promise<SignalAck | null>;
+    /**
+     * Cleanup all ACKs for this coordinator
+     */
+    cleanup(): Promise<void>;
+    /**
+     * Execute lifecycle hook if configured
+     *
+     * @param hookName - Name of the hook to execute (on_blocking_start, on_signal_received, on_blocking_timeout)
+     * @param envVars - Environment variables to pass to the hook
+     * @returns Promise<void>
+     */
+    private executeLifecycleHook;
+    /**
+     * Execute hook script with environment variables
+     *
+     * @param script - Shell script to execute
+     * @param hookName - Name of the hook (for logging)
+     * @param envVars - Environment variables to set
+     * @returns Promise<void>
+     */
+    private executeHookScript;
+    /**
+     * Build Redis key for ACK
+     *
+     * Format: blocking:ack:{coordinatorId}:{signalId}
+     */
+    private buildAckKey;
+    /**
+     * Build Redis key for ACK from a specific coordinator
+     *
+     * Format: blocking:ack:{coordinatorId}:{signalId}
+     */
+    private buildAckKeyForCoordinator;
+    /**
+     * Sleep utility for polling loops
+     */
+    private sleep;
+    /**
+     * SEC-HIGH-001: Validate ID string to prevent injection attacks
+     *
+     * @param id - ID string to validate
+     * @param fieldName - Name of the field being validated (for error messages)
+     * @returns Validated ID string
+     * @throws Error if ID contains invalid characters
+     */
+    private validateId;
+    /**
+     * SEC-CRIT-001: Generate HMAC-SHA256 signature for ACK verification
+     *
+     * @param coordinatorId - Coordinator ID
+     * @param signalId - Signal ID
+     * @param timestamp - ACK timestamp
+     * @param iteration - Current iteration count
+     * @returns HMAC-SHA256 signature (hex string)
+     */
+    private signAck;
+    /**
+     * SEC-CRIT-001: Verify HMAC-SHA256 signature for ACK
+     *
+     * @param ack - ACK object to verify
+     * @returns True if signature is valid, false otherwise
+     */
+    private verifyAckSignature;
+    /**
+     * Log audit trail to SQLite (non-blocking)
+     *
+     * @param entry - Audit trail entry
+     */
+    private logAuditTrail;
+}
+/**
+ * Create a BlockingCoordinationManager instance
+ *
+ * @param config - Configuration for blocking coordination
+ * @returns Configured BlockingCoordinationManager
+ */
+export declare function createBlockingCoordinationManager(config: BlockingCoordinationConfig): BlockingCoordinationManager;
+export default BlockingCoordinationManager;

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

@@ -0,0 +1,193 @@
+/**
+ * Byzantine Consensus Adapter for CFN Loop 2
+ *
+ * Bridges ByzantineConsensusCoordinator with CFN Loop orchestrator.
+ * Implements PBFT (Practical Byzantine Fault Tolerance) consensus for validator agreement.
+ *
+ * Features:
+ * - PBFT three-phase consensus (prepare, commit, reply)
+ * - Malicious validator detection and flagging
+ * - Cryptographic signature verification
+ * - SwarmMemory persistence for malicious agents
+ * - Backwards compatibility with simple consensus
+ *
+ * @module cfn-loop/byzantine-consensus-adapter
+ */
+import { EventEmitter } from 'events';
+import { SwarmMemoryManager } from '../memory/swarm-memory.js';
+import type { ValidatorVote, ByzantineConsensusResult, ByzantineAdapterConfig, AgentResponse } from './types.js';
+/**
+ * Adapter that integrates Byzantine consensus into CFN Loop
+ *
+ * Responsibilities:
+ * - Initialize Byzantine coordinator with validator configuration
+ * - Collect and validate validator votes
+ * - Execute PBFT consensus phases
+ * - Detect and flag malicious validators
+ * - Map Byzantine results to CFN Loop ConsensusResult interface
+ * - Persist malicious agent data to SwarmMemory
+ */
+export declare class ByzantineConsensusAdapter extends EventEmitter {
+    private logger;
+    private config;
+    private byzantineCoordinator;
+    private memoryManager?;
+    private maliciousAgents;
+    constructor(config?: ByzantineAdapterConfig, memoryManager?: SwarmMemoryManager);
+    /**
+     * Execute Byzantine consensus on validator responses
+     *
+     * Process:
+     * 1. Collect validator votes from responses
+     * 2. Verify cryptographic signatures
+     * 3. Execute PBFT three-phase consensus
+     * 4. Detect malicious validators
+     * 5. Calculate consensus score
+     * 6. Return ByzantineConsensusResult
+     *
+     * @param validatorResponses - Array of validator agent responses
+     * @returns Byzantine consensus result with PBFT phases and malicious agent detection
+     */
+    executeConsensus(validatorResponses: AgentResponse[]): Promise<ByzantineConsensusResult>;
+    /**
+     * Extract validator votes from agent responses
+     *
+     * Parses agent deliverables to extract ValidatorVote objects.
+     * Supports both structured vote objects and text-based responses.
+     *
+     * @param responses - Array of agent responses
+     * @returns Array of validator votes
+     */
+    private extractValidatorVotes;
+    /**
+     * Execute PBFT three-phase consensus
+     *
+     * Phases:
+     * 1. Prepare: Validators prepare to commit to proposal
+     * 2. Commit: Validators commit to the agreed proposal
+     * 3. Reply: Final confirmation of consensus
+     *
+     * @param votes - Array of validator votes
+     * @returns PBFT phase completion status
+     */
+    private executePBFTConsensus;
+    /**
+     * PBFT Prepare Phase
+     * Validators prepare to commit to the proposal
+     */
+    private pbftPrepare;
+    /**
+     * PBFT Commit Phase
+     * Validators commit to the agreed proposal
+     */
+    private pbftCommit;
+    /**
+     * PBFT Reply Phase
+     * Final confirmation of consensus
+     */
+    private pbftReply;
+    /**
+     * Detect malicious agents based on voting patterns
+     *
+     * Detection criteria:
+     * - Outlier confidence scores (>2 std deviations)
+     * - Invalid signatures
+     * - Inconsistent reasoning
+     * - Suspicious timing patterns
+     *
+     * @param votes - Array of validator votes
+     * @returns Array of malicious agent IDs
+     */
+    detectMaliciousAgents(votes: ValidatorVote[]): Promise<string[]>;
+    /**
+     * Flag an agent as malicious and persist to memory
+     *
+     * @param agentId - ID of malicious agent
+     * @param reason - Reason for flagging
+     */
+    flagMaliciousAgent(agentId: string, reason: string): Promise<void>;
+    /**
+     * Verify cryptographic signatures for all votes
+     *
+     * @param votes - Array of validator votes
+     * @returns True if all signatures are valid
+     */
+    private verifySignatures;
+    /**
+     * Verify signature for a single vote
+     *
+     * @param vote - Validator vote to verify
+     * @returns True if signature is valid
+     */
+    private verifyVoteSignature;
+    /**
+     * Generate cryptographic signature for a vote
+     *
+     * @param vote - Validator vote or agent response
+     * @returns SHA-256 signature hash
+     */
+    private generateVoteSignature;
+    /**
+     * Generate signature from agent response
+     *
+     * @param response - Agent response
+     * @returns SHA-256 signature hash
+     */
+    private generateSignature;
+    /**
+     * Calculate consensus score from validator votes
+     *
+     * Formula: (weighted_pass_votes) / (total_validators)
+     * Weighted by validator confidence scores
+     *
+     * @param votes - Array of validator votes
+     * @returns Consensus score (0.0 to 1.0)
+     */
+    private calculateConsensusScore;
+    /**
+     * Build voting breakdown for reporting
+     *
+     * @param votes - Array of validator votes
+     * @returns Voting breakdown by type
+     */
+    private buildVotingBreakdown;
+    /**
+     * Type guard to check if object is a ValidatorVote
+     *
+     * @param obj - Object to check
+     * @returns True if object is ValidatorVote
+     */
+    private isValidatorVote;
+    /**
+     * Infer validator type from agent type string
+     *
+     * @param agentType - Agent type string
+     * @returns Validator type
+     */
+    private inferValidatorType;
+    /**
+     * Generate unique node ID for Byzantine coordinator
+     *
+     * @returns Random node ID
+     */
+    private generateNodeId;
+    /**
+     * Get set of malicious agents
+     *
+     * @returns Set of malicious agent IDs
+     */
+    getMaliciousAgents(): Set<string>;
+    /**
+     * Clear malicious agents set
+     */
+    clearMaliciousAgents(): void;
+}
+/**
+ * Create Byzantine consensus adapter instance
+ *
+ * @param config - Adapter configuration
+ * @param memoryManager - Optional SwarmMemory manager
+ * @returns Configured adapter instance
+ */
+export declare function createByzantineConsensusAdapter(config?: ByzantineAdapterConfig, memoryManager?: SwarmMemoryManager): ByzantineConsensusAdapter;
+export default ByzantineConsensusAdapter;

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

@@ -0,0 +1,221 @@
+/**
+ * CFN Loop Memory Manager - SQLite + Redis Dual-Layer Memory System
+ * Sprint 1.5: Loop 3/2/4 Integration
+ *
+ * Implements CQRS pattern with dual-write strategy:
+ * - Commands: Redis pub/sub (real-time coordination, <10ms)
+ * - Queries: SQLite (persistent state, audit trail, <50ms)
+ *
+ * Features:
+ * - Dual-write pattern (Redis first, SQLite async)
+ * - Loop 3 confidence score persistence
+ * - Loop 2 consensus storage
+ * - Loop 4 decision history
+ * - 5-level ACL enforcement
+ * - AES-256-GCM encryption for private data
+ * - Cross-session recovery
+ *
+ * Epic: production-blocking-coordination
+ * Sprint: 1.5 - SQLite Memory Integration
+ *
+ * @module cfn-loop/cfn-loop-memory-manager
+ */
+import { EventEmitter } from 'events';
+import type { Redis } from 'ioredis';
+/**
+ * ACL levels for memory access
+ */
+export declare enum ACLLevel {
+    PRIVATE = 1,// Only accessible by specific agent
+    TEAM = 2,// Accessible by agents in same team
+    SWARM = 3,// Accessible by all agents in swarm
+    PROJECT = 4,// Accessible by agents in same project
+    SYSTEM = 5
+}
+/**
+ * Loop 3 confidence data structure
+ */
+export interface Loop3Confidence {
+    agentId: string;
+    confidence: number;
+    reasoning: string;
+    blockers: string[];
+    timestamp: number;
+    phase: string;
+    iteration: number;
+    metadata?: {
+        filesModified?: string[];
+        testsRun?: number;
+        testsPassed?: number;
+    };
+}
+/**
+ * Loop 2 validation result structure
+ */
+export interface Loop2ValidationResult {
+    validatorId: string;
+    validationType: 'security' | 'performance' | 'code-quality' | 'architecture';
+    score: number;
+    issues: Array<{
+        severity: 'low' | 'medium' | 'high' | 'critical';
+        description: string;
+        location?: string;
+        recommendation?: string;
+    }>;
+    recommendations: string[];
+    timestamp: number;
+    phase: string;
+    iteration: number;
+}
+/**
+ * Loop 2 consensus data structure
+ */
+export interface Loop2Consensus {
+    consensusId: string;
+    phase: string;
+    iteration: number;
+    threshold: number;
+    currentScore: number;
+    validationResults: Loop2ValidationResult[];
+    status: 'pending' | 'achieved' | 'failed';
+    timestamp: number;
+    resolvedAt?: number;
+}
+/**
+ * Loop 4 Product Owner decision
+ */
+export interface Loop4Decision {
+    decisionId: string;
+    phase: string;
+    iteration: number;
+    decision: 'PROCEED' | 'DEFER' | 'ESCALATE';
+    reasoning: string;
+    loop3Confidence: number;
+    loop2Consensus: number;
+    deferredIssues?: string[];
+    escalationReason?: string;
+    timestamp: number;
+    nextActions: string[];
+}
+/**
+ * Configuration for CFN Loop memory manager
+ */
+export interface CFNLoopMemoryConfig {
+    /** Redis client instance (ioredis) */
+    redisClient: Redis;
+    /** SQLite database path */
+    sqliteDbPath?: string;
+    /** Swarm ID for context */
+    swarmId: string;
+    /** Project ID for ACL (optional) */
+    projectId?: string;
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Dual-write timeout (ms) - default 5000 */
+    dualWriteTimeout?: number;
+    /** Enable encryption for private data (default: true) */
+    enableEncryption?: boolean;
+    /** Compression threshold in bytes (default: 1024) */
+    compressionThreshold?: number;
+}
+/**
+ * Memory operation options
+ */
+export interface MemoryOptions {
+    /** Agent ID for ACL enforcement */
+    agentId: string;
+    /** ACL level (default: SWARM) */
+    aclLevel?: ACLLevel;
+    /** Team ID for team-level access */
+    teamId?: string;
+    /** TTL in seconds (default: 86400 = 24 hours) */
+    ttl?: number;
+    /** Enable compression (default: true for large data) */
+    compress?: boolean;
+    /** Enable encryption (default: true for private data) */
+    encrypt?: boolean;
+}
+/**
+ * Manages CFN Loop memory with Redis + SQLite dual-layer system
+ */
+export declare class CFNLoopMemoryManager extends EventEmitter {
+    private logger;
+    private redis;
+    private sqlite;
+    private swarmId;
+    private projectId?;
+    private debug;
+    private dualWriteTimeout;
+    private enableEncryption;
+    private compressionThreshold;
+    private secretDetector;
+    private metrics;
+    constructor(config: CFNLoopMemoryConfig);
+    /**
+     * Initialize the memory manager
+     */
+    initialize(): Promise<void>;
+    /**
+     * Store Loop 3 confidence score with dual-write
+     */
+    storeLoop3Confidence(data: Loop3Confidence, options: MemoryOptions): Promise<void>;
+    /**
+     * Retrieve Loop 3 confidence scores for phase
+     */
+    getLoop3Confidence(phase: string, options: MemoryOptions): Promise<Loop3Confidence[]>;
+    /**
+     * Store Loop 2 consensus result with dual-write
+     */
+    storeLoop2Consensus(data: Loop2Consensus, options: MemoryOptions): Promise<void>;
+    /**
+     * Store consensus record in SQLite consensus table
+     */
+    private storeConsensusRecord;
+    /**
+     * Retrieve Loop 2 consensus for phase
+     */
+    getLoop2Consensus(phase: string, options: MemoryOptions): Promise<Loop2Consensus | null>;
+    /**
+     * Store Loop 4 Product Owner decision with dual-write
+     */
+    storeLoop4Decision(data: Loop4Decision, options: MemoryOptions): Promise<void>;
+    /**
+     * Store audit log entry in SQLite
+     */
+    private storeAuditLog;
+    /**
+     * Retrieve Loop 4 decision history for phase
+     */
+    getLoop4DecisionHistory(phase: string, options: MemoryOptions): Promise<Loop4Decision[]>;
+    /**
+     * Get performance metrics
+     */
+    getMetrics(): {
+        dualWrites: number;
+        dualWriteFailures: number;
+        redisWrites: number;
+        sqliteWrites: number;
+        dualWriteLatency: {
+            avg: number;
+            p50: number;
+            p95: number;
+            p99: number;
+        };
+        redisLatency: {
+            avg: number;
+            p50: number;
+            p95: number;
+            p99: number;
+        };
+        sqliteLatency: {
+            avg: number;
+            p50: number;
+            p95: number;
+            p99: number;
+        };
+    };
+    /**
+     * Graceful shutdown
+     */
+    shutdown(): Promise<void>;
+}