claude-flow-novice 2.18.6 → 2.18.7

package/claude-assets/skills/cfn-memory-persistence/lib/redis/dist/context-manager.js

@@ -1,230 +0,0 @@
-"use strict";
-/**
- * Task Context Manager
- *
- * Handles storing and retrieving task context in Redis (CLI Mode)
- * or gracefully stubbing in Task Mode.
- *
- * Migrated from:
- * - store-context.sh (93 lines)
- * - get-context.sh (145 lines)
- * - store-success-criteria.sh (85 lines)
- * - get-success-criteria.sh (54 lines)
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ContextManager = void 0;
-const types_1 = require("./types");
-class ContextManager {
-    redis;
-    logger;
-    constructor(redis, logger) {
-        this.redis = redis;
-        this.logger = logger;
-    }
-    /**
-     * Store task context in Redis
-     *
-     * In Task Mode: Logs and returns gracefully
-     * In CLI Mode: Stores in Redis with 24h TTL
-     */
-    async storeContext(taskId, context) {
-        // Validate input
-        if (!(0, types_1.isValidTaskId)(taskId)) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid task ID: ${taskId}`);
-        }
-        // Graceful no-op in Task Mode
-        if (!this.redis.canUseRedis) {
-            this.logger.info('Task Mode: Context passed via Task() parameters (no Redis storage)');
-            return;
-        }
-        // CLI Mode: Store in Redis
-        const key = `swarm:${taskId}:context`;
-        const epic = context.epic || '';
-        const scope = JSON.stringify(context.scope || {});
-        const deliverables = JSON.stringify(context.deliverables || []);
-        const successCriteria = JSON.stringify(context.successCriteria || []);
-        const mode = context.mode || 'standard';
-        const timestamp = context.timestamp || new Date().toISOString();
-        try {
-            await this.redis.hset(key, 'epic', epic, 'scope', scope, 'deliverables', deliverables, 'successCriteria', successCriteria, 'mode', mode, 'updated_at', timestamp);
-            // Set TTL (24 hours)
-            await this.redis.expire(key, 86400);
-            this.logger.info(`✅ Context stored for task: ${taskId}`);
-        }
-        catch (error) {
-            this.logger.error('Failed to store context', error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `Failed to store context for task ${taskId}: ${error.message}`);
-        }
-    }
-    /**
-     * Retrieve task context from Redis
-     *
-     * In Task Mode: Returns empty context
-     * In CLI Mode: Retrieves from Redis
-     */
-    async getContext(taskId) {
-        // Validate input
-        if (!(0, types_1.isValidTaskId)(taskId)) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid task ID: ${taskId}`);
-        }
-        // Graceful no-op in Task Mode
-        if (!this.redis.canUseRedis) {
-            this.logger.info('Task Mode: No context available in Redis');
-            return null;
-        }
-        // CLI Mode: Retrieve from Redis
-        const key = `swarm:${taskId}:context`;
-        try {
-            const data = await this.redis.hgetall(key);
-            if (!data || Object.keys(data).length === 0) {
-                this.logger.warn(`No context found for task: ${taskId}`);
-                return null;
-            }
-            // Parse JSON fields
-            const scope = data.scope ? JSON.parse(data.scope) : {};
-            const deliverables = data.deliverables ? JSON.parse(data.deliverables) : [];
-            const successCriteria = data.successCriteria ? JSON.parse(data.successCriteria) : [];
-            const context = {
-                taskId,
-                epic: data.epic || undefined,
-                scope: Object.keys(scope).length > 0 ? scope : undefined,
-                deliverables: deliverables.length > 0 ? deliverables : undefined,
-                successCriteria: successCriteria.length > 0 ? successCriteria : undefined,
-                mode: data.mode || 'standard',
-                timestamp: data.updated_at
-            };
-            this.logger.info(`✅ Context retrieved for task: ${taskId}`);
-            return context;
-        }
-        catch (error) {
-            this.logger.error('Failed to get context', error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `Failed to retrieve context for task ${taskId}: ${error.message}`);
-        }
-    }
-    /**
-     * Store success criteria for a task
-     *
-     * In Task Mode: Logs and returns gracefully
-     * In CLI Mode: Stores in Redis with 24h TTL
-     */
-    async storeSuccessCriteria(taskId, criteria) {
-        // Validate input
-        if (!(0, types_1.isValidTaskId)(taskId)) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid task ID: ${taskId}`);
-        }
-        if (!criteria.criteria || criteria.criteria.length === 0) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, 'Success criteria must contain at least one criterion');
-        }
-        // Graceful no-op in Task Mode
-        if (!this.redis.canUseRedis) {
-            this.logger.info('Task Mode: Success criteria passed via Task() parameters');
-            return;
-        }
-        // CLI Mode: Store in Redis
-        const key = `swarm:${taskId}:success_criteria`;
-        try {
-            const criteriaJson = JSON.stringify(criteria.criteria);
-            const testSuitesJson = JSON.stringify(criteria.testSuites || []);
-            const timestamp = criteria.timestamp || new Date().toISOString();
-            await this.redis.hset(key, 'criteria', criteriaJson, 'testSuites', testSuitesJson, 'passThreshold', String(criteria.passThreshold || 0.95), 'stored_at', timestamp);
-            // Set TTL (24 hours)
-            await this.redis.expire(key, 86400);
-            this.logger.info(`✅ Success criteria stored for task: ${taskId}`);
-        }
-        catch (error) {
-            this.logger.error('Failed to store success criteria', error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `Failed to store success criteria for task ${taskId}: ${error.message}`);
-        }
-    }
-    /**
-     * Retrieve success criteria from Redis
-     *
-     * In Task Mode: Returns null
-     * In CLI Mode: Retrieves from Redis
-     */
-    async getSuccessCriteria(taskId) {
-        // Validate input
-        if (!(0, types_1.isValidTaskId)(taskId)) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid task ID: ${taskId}`);
-        }
-        // Graceful no-op in Task Mode
-        if (!this.redis.canUseRedis) {
-            this.logger.info('Task Mode: No success criteria available in Redis');
-            return null;
-        }
-        // CLI Mode: Retrieve from Redis
-        const key = `swarm:${taskId}:success_criteria`;
-        try {
-            const data = await this.redis.hgetall(key);
-            if (!data || Object.keys(data).length === 0) {
-                this.logger.warn(`No success criteria found for task: ${taskId}`);
-                return null;
-            }
-            // Parse JSON fields
-            const criteria = data.criteria ? JSON.parse(data.criteria) : [];
-            const testSuites = data.testSuites ? JSON.parse(data.testSuites) : [];
-            const passThreshold = data.passThreshold ? parseFloat(data.passThreshold) : 0.95;
-            const result = {
-                taskId,
-                criteria,
-                testSuites: testSuites.length > 0 ? testSuites : undefined,
-                passThreshold,
-                timestamp: data.stored_at
-            };
-            this.logger.info(`✅ Success criteria retrieved for task: ${taskId}`);
-            return result;
-        }
-        catch (error) {
-            this.logger.error('Failed to get success criteria', error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `Failed to retrieve success criteria for task ${taskId}: ${error.message}`);
-        }
-    }
-    /**
-     * Validate context structure
-     */
-    validateContext(context) {
-        const errors = [];
-        if (!(0, types_1.isValidTaskId)(context.taskId)) {
-            errors.push(`Invalid task ID: ${context.taskId}`);
-        }
-        if (context.deliverables && !Array.isArray(context.deliverables)) {
-            errors.push('Deliverables must be an array');
-        }
-        if (context.successCriteria && !Array.isArray(context.successCriteria)) {
-            errors.push('Success criteria must be an array');
-        }
-        if (context.mode && !['mvp', 'standard', 'enterprise'].includes(context.mode)) {
-            errors.push(`Invalid mode: ${context.mode}`);
-        }
-        return {
-            valid: errors.length === 0,
-            errors
-        };
-    }
-    /**
-     * Clear context for a task
-     */
-    async clearContext(taskId) {
-        if (!(0, types_1.isValidTaskId)(taskId)) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid task ID: ${taskId}`);
-        }
-        if (!this.redis.canUseRedis) {
-            this.logger.info('Task Mode: Context cleanup skipped');
-            return;
-        }
-        try {
-            const keys = [
-                `swarm:${taskId}:context`,
-                `swarm:${taskId}:success_criteria`
-            ];
-            await this.redis.del(...keys);
-            this.logger.info(`✅ Context cleared for task: ${taskId}`);
-        }
-        catch (error) {
-            this.logger.error('Failed to clear context', error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `Failed to clear context for task ${taskId}: ${error.message}`);
-        }
-    }
-}
-exports.ContextManager = ContextManager;
-//# sourceMappingURL=context-manager.js.map

package/claude-assets/skills/cfn-memory-persistence/lib/redis/dist/index.d.ts

@@ -1,45 +0,0 @@
-/**
- * CFN Redis Coordination - TypeScript Entry Point
- *
- * Complete Redis coordination layer with Task Mode graceful fallback
- */
-export * from './types';
-export { detectMode, ConsoleLogger } from './mode-detector';
-export { RedisCoordinator } from './redis-client';
-export { ContextManager } from './context-manager';
-export type { SuccessCriteria } from './context-manager';
-export { CompletionReporter } from './completion-reporter';
-export type { CompletionReportOptions } from './completion-reporter';
-export { ResultCollector } from './result-collector';
-export type { CollectionResult, AggregatedScores } from './result-collector';
-export { WaitingCoordinator } from './waiting-coordinator';
-export type { WaitResult, SignalResult } from './waiting-coordinator';
-export { SwarmManager } from './swarm-manager';
-export type { SwarmMetadata, CancellationSignal } from './swarm-manager';
-export { AgentRecoveryManager } from './agent-recovery';
-export type { AgentHealth } from './agent-recovery';
-export { AgentLogger, storeAgentLog, getAgentLogs, getTaskLogs, clearLogs } from './agent-logger';
-export type { LogLevel, LogEntry } from './agent-logger';
-export { TaskAnalyzer } from './task-analyzer';
-export type { ComplexityAnalysis, DifficultyLevel } from './task-analyzer';
-export { TaskExecutor } from './task-executor';
-export type { ExecutionConfig, ExecutionResult, ExecutionProgress } from './task-executor';
-/**
- * Factory function to initialize all coordination modules
- *
- * Lazy-loaded to avoid circular dependencies
- */
-export declare function initializeCoordination(): Promise<{
-    redis: import("./redis-client").RedisCoordinator;
-    logger: import("./mode-detector").ConsoleLogger;
-    context: import("./context-manager").ContextManager;
-    completion: import("./completion-reporter").CompletionReporter;
-    results: import("./result-collector").ResultCollector;
-    waiting: import("./waiting-coordinator").WaitingCoordinator;
-    swarm: import("./swarm-manager").SwarmManager;
-    recovery: import("./agent-recovery").AgentRecoveryManager;
-    analyzer: import("./task-analyzer").TaskAnalyzer;
-    executor: import("./task-executor").TaskExecutor;
-}>;
-export { detectMode as default } from './mode-detector';
-//# sourceMappingURL=index.d.ts.map

package/claude-assets/skills/cfn-memory-persistence/lib/redis/dist/index.js

@@ -1,114 +0,0 @@
-"use strict";
-/**
- * CFN Redis Coordination - TypeScript Entry Point
- *
- * Complete Redis coordination layer with Task Mode graceful fallback
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = exports.TaskExecutor = exports.TaskAnalyzer = exports.clearLogs = exports.getTaskLogs = exports.getAgentLogs = exports.storeAgentLog = exports.AgentLogger = exports.AgentRecoveryManager = exports.SwarmManager = exports.WaitingCoordinator = exports.ResultCollector = exports.CompletionReporter = exports.ContextManager = exports.RedisCoordinator = exports.ConsoleLogger = exports.detectMode = void 0;
-exports.initializeCoordination = initializeCoordination;
-// Core types
-__exportStar(require("./types"), exports);
-// Mode detection
-var mode_detector_1 = require("./mode-detector");
-Object.defineProperty(exports, "detectMode", { enumerable: true, get: function () { return mode_detector_1.detectMode; } });
-Object.defineProperty(exports, "ConsoleLogger", { enumerable: true, get: function () { return mode_detector_1.ConsoleLogger; } });
-// Redis client
-var redis_client_1 = require("./redis-client");
-Object.defineProperty(exports, "RedisCoordinator", { enumerable: true, get: function () { return redis_client_1.RedisCoordinator; } });
-// Coordination modules
-var context_manager_1 = require("./context-manager");
-Object.defineProperty(exports, "ContextManager", { enumerable: true, get: function () { return context_manager_1.ContextManager; } });
-var completion_reporter_1 = require("./completion-reporter");
-Object.defineProperty(exports, "CompletionReporter", { enumerable: true, get: function () { return completion_reporter_1.CompletionReporter; } });
-var result_collector_1 = require("./result-collector");
-Object.defineProperty(exports, "ResultCollector", { enumerable: true, get: function () { return result_collector_1.ResultCollector; } });
-var waiting_coordinator_1 = require("./waiting-coordinator");
-Object.defineProperty(exports, "WaitingCoordinator", { enumerable: true, get: function () { return waiting_coordinator_1.WaitingCoordinator; } });
-var swarm_manager_1 = require("./swarm-manager");
-Object.defineProperty(exports, "SwarmManager", { enumerable: true, get: function () { return swarm_manager_1.SwarmManager; } });
-var agent_recovery_1 = require("./agent-recovery");
-Object.defineProperty(exports, "AgentRecoveryManager", { enumerable: true, get: function () { return agent_recovery_1.AgentRecoveryManager; } });
-var agent_logger_1 = require("./agent-logger");
-Object.defineProperty(exports, "AgentLogger", { enumerable: true, get: function () { return agent_logger_1.AgentLogger; } });
-Object.defineProperty(exports, "storeAgentLog", { enumerable: true, get: function () { return agent_logger_1.storeAgentLog; } });
-Object.defineProperty(exports, "getAgentLogs", { enumerable: true, get: function () { return agent_logger_1.getAgentLogs; } });
-Object.defineProperty(exports, "getTaskLogs", { enumerable: true, get: function () { return agent_logger_1.getTaskLogs; } });
-Object.defineProperty(exports, "clearLogs", { enumerable: true, get: function () { return agent_logger_1.clearLogs; } });
-var task_analyzer_1 = require("./task-analyzer");
-Object.defineProperty(exports, "TaskAnalyzer", { enumerable: true, get: function () { return task_analyzer_1.TaskAnalyzer; } });
-var task_executor_1 = require("./task-executor");
-Object.defineProperty(exports, "TaskExecutor", { enumerable: true, get: function () { return task_executor_1.TaskExecutor; } });
-/**
- * Factory function to initialize all coordination modules
- *
- * Lazy-loaded to avoid circular dependencies
- */
-async function initializeCoordination() {
-    // Dynamic imports to avoid circular dep issues
-    const { RedisCoordinator } = await Promise.resolve().then(() => __importStar(require('./redis-client')));
-    const { ConsoleLogger } = await Promise.resolve().then(() => __importStar(require('./mode-detector')));
-    const { ContextManager: CM } = await Promise.resolve().then(() => __importStar(require('./context-manager')));
-    const { CompletionReporter: CR } = await Promise.resolve().then(() => __importStar(require('./completion-reporter')));
-    const { ResultCollector: RC } = await Promise.resolve().then(() => __importStar(require('./result-collector')));
-    const { WaitingCoordinator: WC } = await Promise.resolve().then(() => __importStar(require('./waiting-coordinator')));
-    const { SwarmManager: SM } = await Promise.resolve().then(() => __importStar(require('./swarm-manager')));
-    const { AgentRecoveryManager: ARM } = await Promise.resolve().then(() => __importStar(require('./agent-recovery')));
-    const { TaskAnalyzer: TA } = await Promise.resolve().then(() => __importStar(require('./task-analyzer')));
-    const { TaskExecutor: TE } = await Promise.resolve().then(() => __importStar(require('./task-executor')));
-    const redis = new RedisCoordinator();
-    await redis.initialize();
-    const logger = new ConsoleLogger('[CFN-Coord]');
-    return {
-        redis,
-        logger,
-        context: new CM(redis, logger),
-        completion: new CR(redis, logger),
-        results: new RC(redis, logger),
-        waiting: new WC(redis, logger),
-        swarm: new SM(redis, logger),
-        recovery: new ARM(redis, logger),
-        analyzer: new TA(redis, logger),
-        executor: new TE(redis, logger)
-    };
-}
-// Re-export mode detection for convenience
-var mode_detector_2 = require("./mode-detector");
-Object.defineProperty(exports, "default", { enumerable: true, get: function () { return mode_detector_2.detectMode; } });
-//# sourceMappingURL=index.js.map

package/claude-assets/skills/cfn-memory-persistence/lib/redis/dist/mode-detector.d.ts

@@ -1,31 +0,0 @@
-/**
- * Mode Detection for CFN Loop Agents
- *
- * Detects whether an agent is running in Task Mode or CLI Mode,
- * and whether Redis operations are safe to execute.
- *
- * CRITICAL: Task Mode agents should NOT use Redis (per CLAUDE.md).
- * This module enforces that distinction at runtime.
- */
-import type { ModeDetection, Logger } from './types';
-/**
- * Detect execution mode and Redis availability
- *
- * @param logger Optional logger for diagnostics
- * @returns ModeDetection with full context
- */
-export declare function detectMode(logger?: Logger): Promise<ModeDetection>;
-/**
- * Console logger implementation for mode detection
- *
- * Simple console-based logger that doesn't require external dependencies.
- */
-export declare class ConsoleLogger implements Logger {
-    private prefix;
-    constructor(prefix?: string);
-    debug(message: string, context?: Record<string, unknown>): void;
-    info(message: string, context?: Record<string, unknown>): void;
-    warn(message: string, context?: Record<string, unknown>): void;
-    error(message: string, error?: Error, context?: Record<string, unknown>): void;
-}
-//# sourceMappingURL=mode-detector.d.ts.map

package/claude-assets/skills/cfn-memory-persistence/lib/redis/dist/mode-detector.js

@@ -1,185 +0,0 @@
-"use strict";
-/**
- * Mode Detection for CFN Loop Agents
- *
- * Detects whether an agent is running in Task Mode or CLI Mode,
- * and whether Redis operations are safe to execute.
- *
- * CRITICAL: Task Mode agents should NOT use Redis (per CLAUDE.md).
- * This module enforces that distinction at runtime.
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConsoleLogger = void 0;
-exports.detectMode = detectMode;
-/**
- * Detect execution mode and Redis availability
- *
- * @param logger Optional logger for diagnostics
- * @returns ModeDetection with full context
- */
-async function detectMode(logger) {
-    // Check environment variables
-    const cfnMode = process.env.CFN_MODE?.toLowerCase();
-    const taskId = process.env.TASK_ID;
-    const agentId = process.env.AGENT_ID;
-    // Check Redis availability (quick test)
-    const redisAvailable = await checkRedisAvailability();
-    // Determine mode
-    let mode = 'unknown';
-    let canUseRedis = false;
-    let reason = '';
-    // Explicit CFN_MODE takes precedence
-    if (cfnMode === 'task') {
-        mode = 'task';
-        canUseRedis = false;
-        reason = 'CFN_MODE=task (explicit Task Mode - Redis operations disabled)';
-    }
-    else if (cfnMode === 'cli') {
-        mode = 'cli';
-        canUseRedis = redisAvailable;
-        reason = redisAvailable
-            ? 'CFN_MODE=cli (CLI Mode - Redis operations enabled)'
-            : 'CFN_MODE=cli but Redis unavailable (Redis operations disabled)';
-    }
-    // Fallback: Infer mode from environment variables
-    else if (taskId && agentId) {
-        mode = 'cli';
-        canUseRedis = redisAvailable;
-        reason = redisAvailable
-            ? 'TASK_ID and AGENT_ID present, Redis available (inferred CLI Mode)'
-            : 'TASK_ID and AGENT_ID present but Redis unavailable (Redis operations disabled)';
-    }
-    else {
-        mode = 'task';
-        canUseRedis = false;
-        reason = 'No TASK_ID or AGENT_ID (inferred Task Mode - Redis operations disabled)';
-    }
-    const detection = {
-        mode,
-        redisAvailable,
-        taskIdPresent: !!taskId,
-        agentIdPresent: !!agentId,
-        canUseRedis,
-        reason
-    };
-    // Log detection result
-    if (logger) {
-        logger.info('Mode detection complete', detection);
-        if (mode === 'task') {
-            logger.info('⚠️  Task Mode detected: Redis operations will be stubbed');
-            logger.info('💡 Task Mode agents return results directly to Main Chat');
-            logger.info('🔧 Redis coordination is only for CLI Mode agents');
-        }
-        else if (mode === 'cli' && !redisAvailable) {
-            logger.warn('⚠️  CLI Mode but Redis unavailable: Operations will soft-fail');
-            logger.warn('💡 Check Redis connection: REDIS_HOST, REDIS_PORT');
-        }
-        else if (mode === 'cli' && redisAvailable) {
-            logger.info('✅ CLI Mode with Redis: Full coordination available');
-        }
-    }
-    return detection;
-}
-/**
- * Check if Redis is available
- *
- * Quick connectivity test with 1 second timeout.
- * Returns false instead of throwing errors.
- */
-async function checkRedisAvailability() {
-    try {
-        // Dynamic import to avoid loading Redis in Task Mode
-        const Redis = (await Promise.resolve().then(() => __importStar(require('ioredis')))).default;
-        const host = process.env.REDIS_HOST || 'localhost';
-        const port = parseInt(process.env.REDIS_PORT || '6379', 10);
-        const password = process.env.REDIS_PASSWORD || process.env.CFN_REDIS_PASSWORD;
-        const client = new Redis({
-            host,
-            port,
-            password: password || undefined,
-            connectTimeout: 1000,
-            maxRetriesPerRequest: 0,
-            retryStrategy: () => null, // Don't retry
-            lazyConnect: true
-        });
-        try {
-            await client.connect();
-            const result = await client.ping();
-            await client.quit();
-            return result === 'PONG';
-        }
-        catch {
-            try {
-                await client.disconnect();
-            }
-            catch {
-                // Ignore disconnect errors
-            }
-            return false;
-        }
-    }
-    catch {
-        // Redis module not available or connection failed
-        return false;
-    }
-}
-/**
- * Console logger implementation for mode detection
- *
- * Simple console-based logger that doesn't require external dependencies.
- */
-class ConsoleLogger {
-    prefix;
-    constructor(prefix = '[CFN-Redis]') {
-        this.prefix = prefix;
-    }
-    debug(message, context) {
-        if (process.env.DEBUG) {
-            console.log(`${this.prefix} DEBUG: ${message}`, context || '');
-        }
-    }
-    info(message, context) {
-        console.log(`${this.prefix} ${message}`, context || '');
-    }
-    warn(message, context) {
-        console.warn(`${this.prefix} ⚠️  ${message}`, context || '');
-    }
-    error(message, error, context) {
-        console.error(`${this.prefix} ❌ ${message}`, error?.message || '', context || '');
-    }
-}
-exports.ConsoleLogger = ConsoleLogger;
-//# sourceMappingURL=mode-detector.js.map