claude-flow-novice 2.18.6 → 2.18.8

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

@@ -1,302 +0,0 @@
-"use strict";
-/**
- * Agent Recovery Manager
- *
- * Handles agent health checks, stuck agent detection, and recovery mechanisms.
- *
- * Migrated from:
- * - agent-recovery.sh (74 lines)
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgentRecoveryManager = void 0;
-const types_1 = require("./types");
-class AgentRecoveryManager {
-    redis;
-    logger;
-    HEARTBEAT_TIMEOUT_MS = 60000; // 60 seconds
-    STUCK_THRESHOLD_MS = 300000; // 5 minutes
-    HEARTBEAT_TTL_SECONDS = 420; // 7 minutes - longer than stuck threshold
-    constructor(redis, logger) {
-        this.redis = redis;
-        this.logger = logger;
-    }
-    /**
-     * Record agent heartbeat to indicate it's still alive
-     *
-     * In Task Mode: Logs and returns gracefully
-     * In CLI Mode: Updates heartbeat timestamp in Redis
-     */
-    async recordHeartbeat(taskId, agentId, processPid, namespace = 'swarm') {
-        // Validate inputs
-        if (!(0, types_1.isValidTaskId)(taskId)) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid task ID: ${taskId}`);
-        }
-        if (!(0, types_1.isValidAgentId)(agentId)) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid agent ID: ${agentId}`);
-        }
-        // Graceful no-op in Task Mode
-        if (!this.redis.canUseRedis) {
-            return;
-        }
-        // CLI Mode: Update heartbeat
-        const key = `${namespace}:${taskId}:${agentId}:heartbeat`;
-        const timestamp = new Date().toISOString();
-        try {
-            const data = {
-                timestamp,
-                lastSeen: new Date().getTime().toString()
-            };
-            if (processPid) {
-                data.processPid = String(processPid);
-            }
-            await this.redis.hset(key, ...Object.entries(data).flat());
-            // Set TTL longer than stuck threshold to allow stuck detection
-            await this.redis.expire(key, this.HEARTBEAT_TTL_SECONDS);
-        }
-        catch (error) {
-            // Non-fatal: heartbeat failure shouldn't crash agent
-            this.logger.warn('Failed to record heartbeat');
-        }
-    }
-    /**
-     * Check agent health status
-     *
-     * In Task Mode: Returns 'healthy'
-     * In CLI Mode: Checks heartbeat freshness
-     */
-    async checkAgentHealth(taskId, agentId, namespace = 'swarm') {
-        // Validate inputs
-        if (!(0, types_1.isValidTaskId)(taskId)) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid task ID: ${taskId}`);
-        }
-        if (!(0, types_1.isValidAgentId)(agentId)) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid agent ID: ${agentId}`);
-        }
-        const baseHealth = {
-            agentId,
-            taskId,
-            status: 'unknown'
-        };
-        // Graceful no-op in Task Mode
-        if (!this.redis.canUseRedis) {
-            baseHealth.status = 'healthy';
-            baseHealth.reason = 'Task Mode: Always healthy';
-            return baseHealth;
-        }
-        // CLI Mode: Check heartbeat
-        const key = `${namespace}:${taskId}:${agentId}:heartbeat`;
-        try {
-            const data = await this.redis.hgetall(key);
-            if (!data || Object.keys(data).length === 0) {
-                baseHealth.status = 'dead';
-                baseHealth.reason = 'No heartbeat found';
-                return baseHealth;
-            }
-            const lastSeenStr = data.lastSeen;
-            if (!lastSeenStr) {
-                baseHealth.status = 'unknown';
-                baseHealth.reason = 'Invalid heartbeat data';
-                return baseHealth;
-            }
-            const lastSeen = parseInt(lastSeenStr, 10);
-            const now = new Date().getTime();
-            const timeSinceLastHeartbeat = now - lastSeen;
-            baseHealth.lastHeartbeat = data.timestamp;
-            baseHealth.processPid = data.processPid ? parseInt(data.processPid, 10) : undefined;
-            if (timeSinceLastHeartbeat > this.STUCK_THRESHOLD_MS) {
-                baseHealth.status = 'stuck';
-                baseHealth.stuckFor = timeSinceLastHeartbeat;
-                baseHealth.reason = `No heartbeat for ${Math.round(timeSinceLastHeartbeat / 1000)}s`;
-            }
-            else if (timeSinceLastHeartbeat > this.HEARTBEAT_TIMEOUT_MS) {
-                baseHealth.status = 'dead';
-                baseHealth.reason = `Heartbeat timeout (${Math.round(timeSinceLastHeartbeat / 1000)}s)`;
-            }
-            else {
-                baseHealth.status = 'healthy';
-                baseHealth.reason = `Healthy (last beat ${Math.round(timeSinceLastHeartbeat / 1000)}s ago)`;
-            }
-            return baseHealth;
-        }
-        catch (error) {
-            this.logger.error('Failed to check agent health', error);
-            baseHealth.status = 'unknown';
-            baseHealth.reason = `Error checking health: ${error.message}`;
-            return baseHealth;
-        }
-    }
-    /**
-     * Detect all stuck agents for a task
-     */
-    async detectStuckAgents(taskId, agentIds, namespace = 'swarm') {
-        // Validate input
-        if (!(0, types_1.isValidTaskId)(taskId)) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid task ID: ${taskId}`);
-        }
-        const stuckAgents = [];
-        try {
-            for (const agentId of agentIds) {
-                const health = await this.checkAgentHealth(taskId, agentId, namespace);
-                if (health.status === 'stuck' || health.status === 'dead') {
-                    stuckAgents.push(health);
-                    this.logger.warn(`🚨 Stuck agent detected: ${agentId} - Status: ${health.status}, Stuck for: ${health.stuckFor}ms`);
-                }
-            }
-            if (stuckAgents.length > 0) {
-                this.logger.warn(`⚠️ Found ${stuckAgents.length} stuck agents`);
-            }
-            return stuckAgents;
-        }
-        catch (error) {
-            this.logger.error('Failed to detect stuck agents', error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `Failed to detect stuck agents: ${error.message}`);
-        }
-    }
-    /**
-     * Mark agent for recovery
-     *
-     * In Task Mode: Logs and returns gracefully
-     * In CLI Mode: Records recovery marker in Redis
-     */
-    async markForRecovery(taskId, agentId, mode = 'soft', namespace = 'swarm') {
-        // Validate inputs
-        if (!(0, types_1.isValidTaskId)(taskId)) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid task ID: ${taskId}`);
-        }
-        if (!(0, types_1.isValidAgentId)(agentId)) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid agent ID: ${agentId}`);
-        }
-        // Graceful no-op in Task Mode
-        if (!this.redis.canUseRedis) {
-            this.logger.info(`Task Mode: Agent recovery marker not stored (no Redis) - Agent: ${agentId}`);
-            return;
-        }
-        // CLI Mode: Mark in Redis
-        const key = `${namespace}:${taskId}:${agentId}:recovery`;
-        const timestamp = new Date().toISOString();
-        try {
-            await this.redis.hset(key, 'mode', mode, 'markedAt', timestamp, 'status', 'pending');
-            // Set TTL (1 hour)
-            await this.redis.expire(key, 3600);
-            this.logger.info(`✅ Agent marked for ${mode} recovery: ${agentId}`);
-        }
-        catch (error) {
-            this.logger.error('Failed to mark for recovery', error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `Failed to mark agent for recovery: ${error.message}`);
-        }
-    }
-    /**
-     * Get recovery markers for agents
-     */
-    async getRecoveryMarkers(taskId, agentIds, namespace = 'swarm') {
-        // 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) {
-            return [];
-        }
-        // CLI Mode: Retrieve markers
-        const markers = [];
-        try {
-            for (const agentId of agentIds) {
-                const key = `${namespace}:${taskId}:${agentId}:recovery`;
-                const data = await this.redis.hgetall(key);
-                if (data && Object.keys(data).length > 0 && data.status === 'pending') {
-                    markers.push({
-                        agentId,
-                        mode: data.mode || 'soft',
-                        markedAt: data.markedAt || new Date().toISOString()
-                    });
-                }
-            }
-            return markers;
-        }
-        catch (error) {
-            this.logger.error('Failed to get recovery markers', error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `Failed to get recovery markers: ${error.message}`);
-        }
-    }
-    /**
-     * Clear recovery marker after recovery is complete
-     */
-    async clearRecoveryMarker(taskId, agentId, namespace = 'swarm') {
-        // Validate inputs
-        if (!(0, types_1.isValidTaskId)(taskId)) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid task ID: ${taskId}`);
-        }
-        if (!(0, types_1.isValidAgentId)(agentId)) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid agent ID: ${agentId}`);
-        }
-        // Graceful no-op in Task Mode
-        if (!this.redis.canUseRedis) {
-            this.logger.info('Task Mode: Recovery marker cleanup skipped');
-            return;
-        }
-        // CLI Mode: Delete marker
-        try {
-            const keys = [
-                `${namespace}:${taskId}:${agentId}:recovery`,
-                `${namespace}:${taskId}:${agentId}:heartbeat`
-            ];
-            await this.redis.del(...keys);
-            this.logger.info(`✅ Recovery marker cleared: ${agentId}`);
-        }
-        catch (error) {
-            this.logger.error('Failed to clear recovery marker', error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `Failed to clear recovery marker: ${error.message}`);
-        }
-    }
-    /**
-     * Get overall swarm health summary
-     */
-    async getSwarmHealth(taskId, agentIds, namespace = 'swarm') {
-        // Validate input
-        if (!(0, types_1.isValidTaskId)(taskId)) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid task ID: ${taskId}`);
-        }
-        const health = {
-            healthy: 0,
-            stuck: 0,
-            dead: 0,
-            unknown: 0,
-            summary: ''
-        };
-        try {
-            for (const agentId of agentIds) {
-                const agentHealth = await this.checkAgentHealth(taskId, agentId, namespace);
-                switch (agentHealth.status) {
-                    case 'healthy':
-                        health.healthy++;
-                        break;
-                    case 'stuck':
-                        health.stuck++;
-                        break;
-                    case 'dead':
-                        health.dead++;
-                        break;
-                    case 'unknown':
-                        health.unknown++;
-                        break;
-                }
-            }
-            const total = agentIds.length;
-            health.summary = (`Swarm Health: ${health.healthy}/${total} healthy, ` +
-                `${health.stuck} stuck, ${health.dead} dead, ${health.unknown} unknown`);
-            if (health.stuck > 0 || health.dead > 0) {
-                this.logger.warn(health.summary);
-            }
-            else {
-                this.logger.info(health.summary);
-            }
-            return health;
-        }
-        catch (error) {
-            this.logger.error('Failed to get swarm health', error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `Failed to get swarm health: ${error.message}`);
-        }
-    }
-}
-exports.AgentRecoveryManager = AgentRecoveryManager;
-//# sourceMappingURL=agent-recovery.js.map

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

@@ -1,58 +0,0 @@
-/**
- * Agent Completion Reporter
- *
- * Handles reporting agent completion, confidence, and test results to Redis.
- *
- * Migrated from:
- * - report-completion.sh (89 lines)
- */
-import type { TaskId, AgentId, Logger, CompletionReport, TestResults } from './types';
-import { RedisCoordinator } from './redis-client';
-export interface CompletionReportOptions {
-    result?: {
-        status: 'complete' | 'failed' | 'blocked';
-        deliverablesCreated?: string[];
-        testsRun?: number;
-        testsPassed?: number;
-        testsFailed?: number;
-        errors?: string[];
-        metadata?: Record<string, unknown>;
-    };
-    iteration?: number;
-    namespace?: string;
-}
-export declare class CompletionReporter {
-    private redis;
-    private logger;
-    constructor(redis: RedisCoordinator, logger: Logger);
-    /**
-     * Report agent completion with confidence score
-     *
-     * In Task Mode: Logs and returns gracefully
-     * In CLI Mode: Stores in Redis and signals completion
-     */
-    reportCompletion(taskId: TaskId, agentId: AgentId, confidence: number, options?: CompletionReportOptions): Promise<void>;
-    /**
-     * Report test results with pass rate
-     *
-     * In Task Mode: Logs and returns gracefully
-     * In CLI Mode: Stores in Redis for gate checking
-     */
-    reportTestResults(taskId: TaskId, agentId: AgentId, results: TestResults, iteration?: number, namespace?: string): Promise<void>;
-    /**
-     * Signal agent done for waiting mode
-     *
-     * In Task Mode: Logs and returns gracefully
-     * In CLI Mode: Signals via Redis list
-     */
-    signalDone(taskId: TaskId, agentId: AgentId, namespace?: string): Promise<void>;
-    /**
-     * Get completion report for an agent
-     */
-    getCompletionReport(taskId: TaskId, agentId: AgentId, namespace?: string): Promise<CompletionReport | null>;
-    /**
-     * Clear completion data for an agent
-     */
-    clearCompletion(taskId: TaskId, agentId: AgentId, namespace?: string): Promise<void>;
-}
-//# sourceMappingURL=completion-reporter.d.ts.map

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

@@ -1,237 +0,0 @@
-"use strict";
-/**
- * Agent Completion Reporter
- *
- * Handles reporting agent completion, confidence, and test results to Redis.
- *
- * Migrated from:
- * - report-completion.sh (89 lines)
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CompletionReporter = void 0;
-const types_1 = require("./types");
-class CompletionReporter {
-    redis;
-    logger;
-    constructor(redis, logger) {
-        this.redis = redis;
-        this.logger = logger;
-    }
-    /**
-     * Report agent completion with confidence score
-     *
-     * In Task Mode: Logs and returns gracefully
-     * In CLI Mode: Stores in Redis and signals completion
-     */
-    async reportCompletion(taskId, agentId, confidence, options = {}) {
-        // Validate inputs
-        if (!(0, types_1.isValidTaskId)(taskId)) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid task ID: ${taskId}`);
-        }
-        if (!(0, types_1.isValidAgentId)(agentId)) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid agent ID: ${agentId}`);
-        }
-        if (!(0, types_1.isValidConfidence)(confidence)) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid confidence value: ${confidence}. Must be between 0.0 and 1.0.`);
-        }
-        // Graceful no-op in Task Mode
-        if (!this.redis.canUseRedis) {
-            this.logger.info(`Task Mode: Agent completion reported (no Redis storage) - Agent: ${agentId}, Confidence: ${confidence}`);
-            return;
-        }
-        // CLI Mode: Report to Redis with optimized pipeline
-        const iteration = options.iteration || 1;
-        const namespace = options.namespace || 'swarm';
-        const timestamp = new Date().toISOString();
-        try {
-            // Signal completion (for waiting mode)
-            await this.redis.lpush(`${namespace}:${taskId}:${agentId}:done`, 'complete');
-            // Store confidence score
-            await this.redis.set(`${namespace}:${taskId}:${agentId}:confidence`, String(confidence), 'EX', 3600);
-            // Store detailed result
-            const resultData = {
-                confidence: String(confidence),
-                iteration: String(iteration),
-                timestamp
-            };
-            if (options.result) {
-                resultData.status = options.result.status;
-                if (options.result.deliverablesCreated) {
-                    resultData.deliverablesCreated = JSON.stringify(options.result.deliverablesCreated);
-                }
-                if (options.result.testsRun !== undefined) {
-                    resultData.testsRun = String(options.result.testsRun);
-                }
-                if (options.result.testsPassed !== undefined) {
-                    resultData.testsPassed = String(options.result.testsPassed);
-                }
-                if (options.result.testsFailed !== undefined) {
-                    resultData.testsFailed = String(options.result.testsFailed);
-                }
-                if (options.result.errors) {
-                    resultData.errors = JSON.stringify(options.result.errors);
-                }
-                if (options.result.metadata) {
-                    resultData.metadata = JSON.stringify(options.result.metadata);
-                }
-            }
-            await this.redis.hset(`${namespace}:${taskId}:${agentId}:result`, ...Object.entries(resultData).flat());
-            // Track in completed agents list
-            await this.redis.lpush(`${namespace}:${taskId}:completed_agents`, agentId);
-            // Set TTLs
-            await this.redis.expire(`${namespace}:${taskId}:${agentId}:result`, 3600);
-            await this.redis.expire(`${namespace}:${taskId}:${agentId}:done`, 3600);
-            this.logger.info(`✅ Completion reported: Agent ${agentId}, Confidence: ${confidence}, Iteration: ${iteration}`);
-        }
-        catch (error) {
-            this.logger.error('Failed to report completion', error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `Failed to report completion for agent ${agentId}: ${error.message}`);
-        }
-    }
-    /**
-     * Report test results with pass rate
-     *
-     * In Task Mode: Logs and returns gracefully
-     * In CLI Mode: Stores in Redis for gate checking
-     */
-    async reportTestResults(taskId, agentId, results, iteration = 1, namespace = 'swarm') {
-        // Validate inputs
-        if (!(0, types_1.isValidTaskId)(taskId)) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid task ID: ${taskId}`);
-        }
-        if (!(0, types_1.isValidAgentId)(agentId)) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid agent ID: ${agentId}`);
-        }
-        if (!Number.isFinite(results.passRate) || results.passRate < 0 || results.passRate > 1) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid pass rate: ${results.passRate}. Must be between 0.0 and 1.0.`);
-        }
-        // Graceful no-op in Task Mode
-        if (!this.redis.canUseRedis) {
-            this.logger.info(`Task Mode: Test results reported (no Redis storage) - Pass Rate: ${(results.passRate * 100).toFixed(1)}%`);
-            return;
-        }
-        // CLI Mode: Store in Redis
-        const timestamp = new Date().toISOString();
-        try {
-            const testResultsKey = `${namespace}:${taskId}:${agentId}:test-results`;
-            await this.redis.hset(testResultsKey, 'pass', String(results.pass), 'fail', String(results.fail), 'skip', String(results.skip || 0), 'total', String(results.total), 'passRate', String(results.passRate), 'iteration', String(iteration), 'timestamp', timestamp);
-            // Set TTL (24 hours)
-            await this.redis.expire(testResultsKey, 86400);
-            this.logger.info(`✅ Test results reported: Pass Rate ${(results.passRate * 100).toFixed(1)}% (${results.pass}/${results.total})`);
-        }
-        catch (error) {
-            this.logger.error('Failed to report test results', error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `Failed to report test results for agent ${agentId}: ${error.message}`);
-        }
-    }
-    /**
-     * Signal agent done for waiting mode
-     *
-     * In Task Mode: Logs and returns gracefully
-     * In CLI Mode: Signals via Redis list
-     */
-    async signalDone(taskId, agentId, namespace = 'swarm') {
-        // Validate inputs
-        if (!(0, types_1.isValidTaskId)(taskId)) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid task ID: ${taskId}`);
-        }
-        if (!(0, types_1.isValidAgentId)(agentId)) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid agent ID: ${agentId}`);
-        }
-        // Graceful no-op in Task Mode
-        if (!this.redis.canUseRedis) {
-            this.logger.info(`Task Mode: Agent done signal ignored (no Redis) - Agent: ${agentId}`);
-            return;
-        }
-        // CLI Mode: Push to done list
-        try {
-            const doneKey = `${namespace}:${taskId}:${agentId}:done`;
-            await this.redis.lpush(doneKey, 'done');
-            await this.redis.expire(doneKey, 3600);
-            this.logger.info(`✅ Done signal sent for agent: ${agentId}`);
-        }
-        catch (error) {
-            this.logger.error('Failed to signal done', error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `Failed to signal done for agent ${agentId}: ${error.message}`);
-        }
-    }
-    /**
-     * Get completion report for an agent
-     */
-    async getCompletionReport(taskId, agentId, namespace = 'swarm') {
-        // Validate inputs
-        if (!(0, types_1.isValidTaskId)(taskId)) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid task ID: ${taskId}`);
-        }
-        if (!(0, types_1.isValidAgentId)(agentId)) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid agent ID: ${agentId}`);
-        }
-        // Graceful no-op in Task Mode
-        if (!this.redis.canUseRedis) {
-            this.logger.info('Task Mode: No completion reports available in Redis');
-            return null;
-        }
-        // CLI Mode: Retrieve from Redis
-        try {
-            const resultKey = `${namespace}:${taskId}:${agentId}:result`;
-            const data = await this.redis.hgetall(resultKey);
-            if (!data || Object.keys(data).length === 0) {
-                this.logger.warn(`No completion report found for agent: ${agentId}`);
-                return null;
-            }
-            const confidence = parseFloat(data.confidence || '0');
-            const report = {
-                agentId,
-                taskId,
-                confidence,
-                iteration: parseInt(data.iteration || '1', 10),
-                result: {
-                    status: data.status || 'complete',
-                    deliverablesCreated: data.deliverablesCreated ? JSON.parse(data.deliverablesCreated) : undefined,
-                    testsRun: data.testsRun ? parseInt(data.testsRun, 10) : undefined,
-                    testsPassed: data.testsPassed ? parseInt(data.testsPassed, 10) : undefined,
-                    testsFailed: data.testsFailed ? parseInt(data.testsFailed, 10) : undefined,
-                    errors: data.errors ? JSON.parse(data.errors) : undefined,
-                    metadata: data.metadata ? JSON.parse(data.metadata) : undefined
-                },
-                timestamp: data.timestamp || new Date().toISOString()
-            };
-            return report;
-        }
-        catch (error) {
-            this.logger.error('Failed to get completion report', error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `Failed to retrieve completion report for agent ${agentId}: ${error.message}`);
-        }
-    }
-    /**
-     * Clear completion data for an agent
-     */
-    async clearCompletion(taskId, agentId, namespace = 'swarm') {
-        if (!(0, types_1.isValidTaskId)(taskId)) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid task ID: ${taskId}`);
-        }
-        if (!(0, types_1.isValidAgentId)(agentId)) {
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.VALIDATION_ERROR, `Invalid agent ID: ${agentId}`);
-        }
-        if (!this.redis.canUseRedis) {
-            this.logger.info('Task Mode: Completion data cleanup skipped');
-            return;
-        }
-        try {
-            const keys = [
-                `${namespace}:${taskId}:${agentId}:done`,
-                `${namespace}:${taskId}:${agentId}:confidence`,
-                `${namespace}:${taskId}:${agentId}:result`,
-                `${namespace}:${taskId}:${agentId}:test-results`
-            ];
-            await this.redis.del(...keys);
-            this.logger.info(`✅ Completion data cleared for agent: ${agentId}`);
-        }
-        catch (error) {
-            this.logger.error('Failed to clear completion data', error);
-            throw new types_1.CoordinationError(types_1.CoordinationErrorType.REDIS_UNAVAILABLE, `Failed to clear completion data for agent ${agentId}: ${error.message}`);
-        }
-    }
-}
-exports.CompletionReporter = CompletionReporter;
-//# sourceMappingURL=completion-reporter.js.map

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

@@ -1,63 +0,0 @@
-/**
- * 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)
- */
-import type { TaskId, Logger, TaskContext, ValidationResult } from './types';
-import { RedisCoordinator } from './redis-client';
-export interface SuccessCriteria {
-    taskId: TaskId;
-    criteria: string[];
-    testSuites?: string[];
-    passThreshold?: number;
-    timestamp?: string;
-}
-export declare class ContextManager {
-    private redis;
-    private logger;
-    constructor(redis: RedisCoordinator, logger: Logger);
-    /**
-     * Store task context in Redis
-     *
-     * In Task Mode: Logs and returns gracefully
-     * In CLI Mode: Stores in Redis with 24h TTL
-     */
-    storeContext(taskId: TaskId, context: TaskContext): Promise<void>;
-    /**
-     * Retrieve task context from Redis
-     *
-     * In Task Mode: Returns empty context
-     * In CLI Mode: Retrieves from Redis
-     */
-    getContext(taskId: TaskId): Promise<TaskContext | null>;
-    /**
-     * Store success criteria for a task
-     *
-     * In Task Mode: Logs and returns gracefully
-     * In CLI Mode: Stores in Redis with 24h TTL
-     */
-    storeSuccessCriteria(taskId: TaskId, criteria: SuccessCriteria): Promise<void>;
-    /**
-     * Retrieve success criteria from Redis
-     *
-     * In Task Mode: Returns null
-     * In CLI Mode: Retrieves from Redis
-     */
-    getSuccessCriteria(taskId: TaskId): Promise<SuccessCriteria | null>;
-    /**
-     * Validate context structure
-     */
-    validateContext(context: TaskContext): ValidationResult;
-    /**
-     * Clear context for a task
-     */
-    clearContext(taskId: TaskId): Promise<void>;
-}
-//# sourceMappingURL=context-manager.d.ts.map