claude-flow-novice 2.0.0 → 2.0.1

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

@@ -0,0 +1,111 @@
+/**
+ * CFN Loop Mode Registry and Selector
+ *
+ * Central registry for CFN Loop modes with auto-detection from epic metadata.
+ *
+ * Features:
+ * - Mode registration (MVP, Enterprise, Standard)
+ * - Auto-detection from filename patterns
+ * - Metadata parsing from epic config
+ * - Explicit mode selection via CLI flags
+ *
+ * @module cfn-loop/modes
+ */
+import type { CFNLoopMode, CFNLoopModeName, ModeDetectionMetadata, ModeSelectionResult } from './types.js';
+/**
+ * Select CFN Loop mode with auto-detection
+ *
+ * Selection priority:
+ * 1. Explicit mode parameter
+ * 2. Filename pattern (e.g., "project-mvp.json")
+ * 3. Metadata fields (cfnMode, mode, quality)
+ * 4. Default to standard mode
+ *
+ * @param options - Mode selection options
+ * @returns Selected mode with detection source
+ *
+ * @example
+ * ```typescript
+ * // Explicit selection
+ * const result = selectMode({ mode: 'mvp' });
+ *
+ * // Auto-detection from filename
+ * const result = selectMode({
+ *   filename: 'my-project-mvp.json',
+ *   auto: true
+ * });
+ *
+ * // Auto-detection from metadata
+ * const result = selectMode({
+ *   metadata: { cfnMode: 'enterprise' },
+ *   auto: true
+ * });
+ * ```
+ */
+export declare function selectMode(options: {
+    mode?: CFNLoopModeName;
+    filename?: string;
+    metadata?: ModeDetectionMetadata;
+    auto?: boolean;
+}): ModeSelectionResult;
+/**
+ * Get mode by name
+ *
+ * @param name - Mode name (mvp, enterprise, standard)
+ * @returns Mode configuration or undefined
+ */
+export declare function getMode(name: CFNLoopModeName): CFNLoopMode | undefined;
+/**
+ * Get all registered modes
+ *
+ * @returns Array of all mode configurations
+ */
+export declare function getAllModes(): CFNLoopMode[];
+/**
+ * Register custom mode (for testing or extensions)
+ *
+ * @param mode - Custom mode configuration
+ */
+export declare function registerMode(mode: CFNLoopMode): void;
+/**
+ * Detect mode from filename patterns
+ *
+ * Patterns:
+ * - "project-mvp.json" → mvp
+ * - "project_mvp.json" → mvp
+ * - "project.mvp.json" → mvp
+ * - "project-enterprise.json" → enterprise
+ * - "project_enterprise.json" → enterprise
+ * - "project.enterprise.json" → enterprise
+ *
+ * @param filename - Epic configuration filename
+ * @returns Detected mode or undefined
+ */
+export declare function detectModeFromFilename(filename: string): CFNLoopModeName | undefined;
+/**
+ * Detect mode from epic metadata
+ *
+ * Checks metadata fields in order:
+ * 1. cfnMode (explicit)
+ * 2. mode (general)
+ * 3. quality (mapped to mode)
+ *
+ * @param metadata - Epic configuration metadata
+ * @returns Detected mode or undefined
+ */
+export declare function detectModeFromMetadata(metadata: ModeDetectionMetadata): CFNLoopModeName | undefined;
+export * from './types.js';
+export { mvpMode } from './mvp-mode.js';
+export { enterpriseMode } from './enterprise-mode.js';
+export { standardMode } from './standard-mode.js';
+declare const _default: {
+    selectMode: typeof selectMode;
+    getMode: typeof getMode;
+    getAllModes: typeof getAllModes;
+    registerMode: typeof registerMode;
+    detectModeFromFilename: typeof detectModeFromFilename;
+    detectModeFromMetadata: typeof detectModeFromMetadata;
+    MODE_REGISTRY: Record<CFNLoopModeName, CFNLoopMode>;
+    DEFAULT_MODE: "standard";
+};
+export default _default;

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

@@ -0,0 +1,31 @@
+/**
+ * MVP Mode Configuration
+ *
+ * Speed-focused CFN Loop mode for rapid prototyping and MVP development.
+ *
+ * Characteristics:
+ * - Lower thresholds (Gate: 0.70, Consensus: 0.80)
+ * - Fewer iterations (Max Loop2: 5, Max Loop3: 5)
+ * - 2 validators (minimal team)
+ * - Single product owner agent
+ * - Skip non-critical validations (accessibility, performance benchmarks)
+ * - Prioritize working implementation over perfect architecture
+ *
+ * @module cfn-loop/modes/mvp-mode
+ */
+import type { CFNLoopMode } from './types.js';
+/**
+ * MVP mode configuration
+ *
+ * Optimized for:
+ * - Fast iteration cycles
+ * - Working prototypes
+ * - Technical debt acceptable
+ * - Ship fast, iterate later
+ */
+export declare const mvpMode: CFNLoopMode;
+/**
+ * Get MVP mode configuration
+ */
+export declare function getMVPMode(): CFNLoopMode;
+export default mvpMode;

package/.claude-flow-novice/dist/cfn-loop/modes/standard-mode.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Standard Mode Configuration
+ *
+ * Balanced CFN Loop mode for general-purpose development.
+ * This is the default mode when no explicit mode is specified.
+ *
+ * Characteristics:
+ * - Standard thresholds (Gate: 0.75, Consensus: 0.90)
+ * - Standard iterations (Max Loop2: 10, Max Loop3: 10)
+ * - 4 validators (balanced team)
+ * - Single product owner agent
+ * - Balanced quality and speed
+ *
+ * @module cfn-loop/modes/standard-mode
+ */
+import type { CFNLoopMode } from './types.js';
+/**
+ * Standard mode configuration
+ *
+ * Optimized for:
+ * - Production-ready code
+ * - Reasonable quality standards
+ * - Balanced development speed
+ * - Standard best practices
+ */
+export declare const standardMode: CFNLoopMode;
+/**
+ * Get Standard mode configuration
+ */
+export declare function getStandardMode(): CFNLoopMode;
+export default standardMode;

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

@@ -0,0 +1,135 @@
+/**
+ * CFN Loop Mode Type Definitions
+ *
+ * Defines interfaces for MVP, Enterprise, and Standard CFN Loop modes.
+ * Each mode has different thresholds, iteration limits, and team structures.
+ *
+ * @module cfn-loop/modes/types
+ */
+/**
+ * CFN Loop mode types
+ */
+export type CFNLoopModeName = 'mvp' | 'enterprise' | 'standard';
+/**
+ * Product owner decision structure types
+ */
+export type ProductOwnerStructure = 'single' | 'team';
+/**
+ * Planning consensus configuration for Enterprise mode (Loop 0.5)
+ */
+export interface PlanningConsensusConfig {
+    enabled: boolean;
+    architectTypes: string[];
+    threshold: number;
+}
+/**
+ * Product owner team role with weighted voting
+ */
+export interface ProductOwnerRole {
+    name: string;
+    weight: number;
+}
+/**
+ * Product owner team configuration for Enterprise mode
+ */
+export interface ProductOwnerTeamConfig {
+    roles: ProductOwnerRole[];
+    votingAlgorithm: 'weighted-confidence';
+}
+/**
+ * Complete CFN Loop mode configuration
+ */
+export interface CFNLoopMode {
+    /** Mode identifier */
+    name: CFNLoopModeName;
+    /** Confidence gate threshold for Loop 3 (agent self-confidence) */
+    gateThreshold: number;
+    /** Consensus threshold for Loop 2 (validator consensus) */
+    consensusThreshold: number;
+    /** Maximum iterations for Loop 2 (phase-level) */
+    maxLoop2Iterations: number;
+    /** Maximum iterations for Loop 3 (swarm-level) */
+    maxLoop3Iterations: number;
+    /** Number of validators for Loop 2 consensus */
+    validatorCount: number;
+    /** Types of validators to spawn */
+    validatorTypes: string[];
+    /** Product owner structure (single agent or team) */
+    productOwnerStructure: ProductOwnerStructure;
+    /** Validations to skip in this mode (MVP only) */
+    skipValidations?: string[];
+    /** Special instructions injected into agent prompts */
+    specialInstructions: string;
+    /** Planning consensus configuration (Enterprise Loop 0.5 only) */
+    planningConsensus?: PlanningConsensusConfig;
+    /** Product owner team configuration (Enterprise Loop 4 only) */
+    productOwnerTeam?: ProductOwnerTeamConfig;
+}
+/**
+ * Mode detection metadata from epic configuration
+ */
+export interface ModeDetectionMetadata {
+    cfnMode?: CFNLoopModeName;
+    mode?: CFNLoopModeName;
+    quality?: 'mvp' | 'enterprise' | 'standard';
+}
+/**
+ * Mode selection result
+ */
+export interface ModeSelectionResult {
+    mode: CFNLoopMode;
+    source: 'explicit' | 'filename' | 'metadata' | 'default';
+    detectedFrom?: string;
+}
+/**
+ * Stakeholder vote in Enterprise product owner team
+ */
+export interface StakeholderVote {
+    stakeholder: 'cto' | 'product-owner' | 'user-power' | 'user-accessibility';
+    vote: 'PROCEED' | 'DEFER' | 'ESCALATE';
+    confidence: number;
+    weight: number;
+}
+/**
+ * Board decision result from weighted voting
+ */
+export interface BoardDecision {
+    decision: 'PROCEED' | 'DEFER' | 'ESCALATE';
+    decisionScore: number;
+    confidence: number;
+    reasoning: string;
+    backlogItems: string[];
+    blockers: string[];
+    recommendations: string[];
+    evaluations: StakeholderVote[];
+    boardConsensus: number;
+    timestamp: number;
+}
+/**
+ * Type guard to check if mode is MVP
+ */
+export declare function isMVPMode(mode: CFNLoopMode): boolean;
+/**
+ * Type guard to check if mode is Enterprise
+ */
+export declare function isEnterpriseMode(mode: CFNLoopMode): boolean;
+/**
+ * Type guard to check if mode is Standard
+ */
+export declare function isStandardMode(mode: CFNLoopMode): boolean;
+/**
+ * Type guard to check if mode has planning consensus (Loop 0.5)
+ */
+export declare function hasPlanningConsensus(mode: CFNLoopMode): boolean;
+/**
+ * Type guard to check if mode has product owner team
+ */
+export declare function hasProductOwnerTeam(mode: CFNLoopMode): boolean;
+declare const _default: {
+    isMVPMode: typeof isMVPMode;
+    isEnterpriseMode: typeof isEnterpriseMode;
+    isStandardMode: typeof isStandardMode;
+    hasPlanningConsensus: typeof hasPlanningConsensus;
+    hasProductOwnerTeam: typeof hasProductOwnerTeam;
+};
+export default _default;

package/.claude-flow-novice/dist/cfn-loop/product-owner/enterprise-owner-team.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Enterprise Product Owner Team with Weighted Voting
+ *
+ * 4-person board for Loop 4 GOAP decisions in Enterprise mode.
+ *
+ * Board Members:
+ * 1. CTO (30%): Strategic decisions
+ * 2. Product Owner (30%): Business value
+ * 3. Power User (20%): Usability
+ * 4. Accessibility User (20%): WCAG compliance
+ *
+ * Voting Algorithm: Weighted confidence from DESIGN_CONSENSUS_MULTI_STAKEHOLDER_ARCHITECTURE.md:776-820
+ *
+ * @module cfn-loop/product-owner/enterprise-owner-team
+ */
+import type { StakeholderVote, BoardDecision } from '../modes/types.js';
+import type { ConsensusResult, AgentResponse, ProductOwnerDecision } from '../types.js';
+/**
+ * Execute Enterprise product owner board decision (Loop 4)
+ *
+ * Process:
+ * 1. Spawn 4 stakeholder agents
+ * 2. Each votes: PROCEED, DEFER, or ESCALATE
+ * 3. Calculate weighted decision score
+ * 4. Return board decision with consensus
+ *
+ * Decision Thresholds:
+ * - ≥0.85: PROCEED
+ * - ≥0.65: DEFER
+ * - <0.65: ESCALATE
+ *
+ * @param consensusResult - Loop 2 consensus validation result
+ * @param primaryResponses - Loop 3 implementation results
+ * @returns Board decision with weighted voting
+ */
+export declare function executeEnterpriseBoardDecision(consensusResult: ConsensusResult, primaryResponses: AgentResponse[]): Promise<ProductOwnerDecision>;
+/**
+ * Calculate board decision using weighted voting
+ *
+ * Algorithm from DESIGN_CONSENSUS_MULTI_STAKEHOLDER_ARCHITECTURE.md:776-820
+ *
+ * @param votes - Stakeholder votes with weights
+ * @returns Board decision with consensus score
+ */
+export declare function calculateBoardDecision(votes: StakeholderVote[]): BoardDecision;
+declare const _default: {
+    executeEnterpriseBoardDecision: typeof executeEnterpriseBoardDecision;
+    calculateBoardDecision: typeof calculateBoardDecision;
+};
+export default _default;

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

@@ -0,0 +1,31 @@
+/**
+ * MVP Product Owner (Single Agent)
+ *
+ * Speed-focused product owner for MVP mode.
+ * Single agent with simplified decision criteria.
+ *
+ * Decision Criteria:
+ * - Lower bar for PROCEED (consensus ≥0.80)
+ * - Bias toward shipping fast
+ * - Technical debt acceptable
+ *
+ * @module cfn-loop/product-owner/mvp-owner
+ */
+import type { ConsensusResult, AgentResponse, ProductOwnerDecision } from '../types.js';
+/**
+ * Execute MVP product owner decision (Loop 4)
+ *
+ * Simplified decision process:
+ * 1. Check consensus score ≥0.80
+ * 2. Bias toward PROCEED or DEFER
+ * 3. Only ESCALATE on critical issues
+ *
+ * @param consensusResult - Loop 2 consensus validation result
+ * @param primaryResponses - Loop 3 implementation results
+ * @returns Product owner decision
+ */
+export declare function executeMVPOwnerDecision(consensusResult: ConsensusResult, primaryResponses: AgentResponse[]): Promise<ProductOwnerDecision>;
+declare const _default: {
+    executeMVPOwnerDecision: typeof executeMVPOwnerDecision;
+};
+export default _default;

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

@@ -0,0 +1,183 @@
+/**
+ * Recovery Engine - Resume CFN Loop Execution from Checkpoint
+ *
+ * Loads checkpoint state and resumes execution from last known state:
+ * - Recovery prompt with options (resume/restart/inspect/abandon)
+ * - Load checkpoint state from Redis
+ * - Resume agents from last known state
+ * - Skip completed sprints, resume in-progress sprints
+ * - Handle partially written files (compare disk vs checkpoint)
+ * - Re-establish coordination locks and dependencies
+ *
+ * Acceptance Criteria:
+ * - Resumes execution within 2 minutes of crash
+ * - Work loss < 5% for crashes at any point
+ * - Completed sprints not re-executed
+ * - In-progress files resume from last completed section
+ * - Locks and dependencies correctly restored
+ *
+ * @module cfn-loop/recovery-engine
+ */
+import { EventEmitter } from 'node:events';
+import { StateCheckpointManager, EpicState } from './state-checkpoint-manager.js';
+import { CrashDetector } from './crash-detector.js';
+/**
+ * Recovery mode options
+ */
+export declare enum RecoveryMode {
+    RESUME = "resume",// Resume from last checkpoint
+    RESTART = "restart",// Restart epic from beginning
+    INSPECT = "inspect",// Inspect checkpoint state only
+    ABANDON = "abandon"
+}
+/**
+ * Recovery options configuration
+ */
+export interface RecoveryOptions {
+    mode: RecoveryMode;
+    epicId: string;
+    continueFromSprint?: string;
+    skipFileReconciliation?: boolean;
+    forceReset?: boolean;
+}
+/**
+ * File reconciliation result
+ */
+export interface FileReconciliationResult {
+    filePath: string;
+    diskExists: boolean;
+    checkpointExists: boolean;
+    diskSize: number;
+    checkpointSize: number;
+    action: 'keep-disk' | 'restore-checkpoint' | 'skip' | 'merge-required';
+    reason: string;
+}
+/**
+ * Recovery result
+ */
+export interface RecoveryResult {
+    success: boolean;
+    mode: RecoveryMode;
+    epicId: string;
+    recoveryDurationMs: number;
+    sprintsResumed: string[];
+    sprintsSkipped: string[];
+    filesReconciled: number;
+    locksRestored: number;
+    agentsResumed: number;
+    estimatedWorkLoss: number;
+    errors: string[];
+    timestamp: number;
+}
+/**
+ * Configuration for recovery engine
+ */
+export interface RecoveryEngineConfig {
+    redisUrl?: string;
+    checkpointManager?: StateCheckpointManager;
+    crashDetector?: CrashDetector;
+    maxRecoveryTimeMs?: number;
+    enableFileReconciliation?: boolean;
+    workingDirectory?: string;
+}
+/**
+ * Resumes CFN Loop execution from checkpoint after crash
+ *
+ * Features:
+ * - Fast recovery (<2 minutes)
+ * - Minimal work loss (<5%)
+ * - Smart file reconciliation
+ * - Coordination state restoration
+ * - Multiple recovery modes
+ *
+ * Usage:
+ * ```typescript
+ * const engine = new RecoveryEngine({
+ *   checkpointManager: manager,
+ *   crashDetector: detector
+ * });
+ *
+ * await engine.initialize();
+ * const result = await engine.resumeFromCheckpoint({
+ *   mode: RecoveryMode.RESUME,
+ *   epicId: 'epic-123'
+ * });
+ * ```
+ */
+export declare class RecoveryEngine extends EventEmitter {
+    private logger;
+    private config;
+    private redis;
+    private checkpointManager;
+    private crashDetector;
+    private serializer;
+    constructor(config: RecoveryEngineConfig);
+    /**
+     * Initialize recovery engine
+     */
+    initialize(): Promise<void>;
+    /**
+     * Load checkpoint state from Redis
+     */
+    loadCheckpoint(epicId: string): Promise<EpicState | null>;
+    /**
+     * Resume execution from checkpoint
+     */
+    resumeFromCheckpoint(options: RecoveryOptions): Promise<RecoveryResult>;
+    /**
+     * Handle RESUME mode - resume from last checkpoint
+     */
+    private handleResumeMode;
+    /**
+     * Handle RESTART mode - restart epic from beginning
+     */
+    private handleRestartMode;
+    /**
+     * Handle INSPECT mode - inspect checkpoint state only
+     */
+    private handleInspectMode;
+    /**
+     * Handle ABANDON mode - abandon recovery and clean up
+     */
+    private handleAbandonMode;
+    /**
+     * Skip completed sprints (mark as done, don't re-execute)
+     */
+    skipCompletedSprints(state: EpicState): Promise<string[]>;
+    /**
+     * Resume in-progress sprints from last known state
+     */
+    resumeInProgressSprints(state: EpicState, options: RecoveryOptions): Promise<string[]>;
+    /**
+     * Build sprint resume context
+     */
+    private buildSprintResumeContext;
+    /**
+     * Resume sprint execution
+     */
+    private resumeSprint;
+    /**
+     * Reconcile partially written files (compare disk vs checkpoint)
+     */
+    reconcilePartialFiles(state: EpicState): Promise<FileReconciliationResult[]>;
+    /**
+     * Reconcile single file
+     */
+    private reconcileFile;
+    /**
+     * Re-establish coordination locks and dependencies
+     */
+    reestablishCoordination(state: EpicState): Promise<number>;
+    /**
+     * Calculate work loss percentage
+     */
+    private calculateWorkLoss;
+    /**
+     * Clean up epic state (for restart/abandon)
+     */
+    private cleanupEpicState;
+    /**
+     * Shutdown recovery engine
+     */
+    shutdown(): Promise<void>;
+}

package/.claude-flow-novice/dist/cfn-loop/redis-health-integration-example.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Redis Health Monitor Integration Example - Sprint 1.3
+ *
+ * Demonstrates how to integrate Redis health monitoring with blocking coordination.
+ * Shows proper health check setup, event handling, and graceful degradation.
+ *
+ * Epic: production-blocking-coordination
+ * Sprint: 1.3 - Redis Health Check
+ *
+ * @module cfn-loop/redis-health-integration-example
+ */
+declare function main(): Promise<void>;
+export { main as runRedisHealthIntegrationExample };