@stoneforge/smithy 1.1.0 → 1.4.0

package/dist/services/health-steward-service.js

@@ -1,866 +0,0 @@
-/**
- * Health Steward Service
- *
- * This service monitors agent health and detects stuck agents.
- * The Health Steward detects problematic agents and takes corrective action.
- *
- * Key features:
- * - Detect agents with no output for configurable duration
- * - Detect agents with repeated errors
- * - Detect crashed agent processes
- * - Attempt to unstick agents
- * - Notify Director of issues
- * - Stop and reassign tasks from stuck agents
- *
- * TB-O24: Health Steward Implementation
- *
- * @module
- */
-import { EventEmitter } from 'node:events';
-import { createTimestamp, TaskStatus } from '@stoneforge/core';
-import { getAgentMetadata } from './agent-registry.js';
-/**
- * All valid health issue types
- */
-export const HealthIssueTypes = [
-    'no_output',
-    'repeated_errors',
-    'process_crashed',
-    'high_error_rate',
-    'session_stale',
-    'unresponsive',
-];
-/**
- * Type guard for HealthIssueType
- */
-export function isHealthIssueType(value) {
-    return typeof value === 'string' && HealthIssueTypes.includes(value);
-}
-/**
- * All valid severity levels
- */
-export const HealthIssueSeverities = ['warning', 'error', 'critical'];
-/**
- * Type guard for HealthIssueSeverity
- */
-export function isHealthIssueSeverity(value) {
-    return typeof value === 'string' && HealthIssueSeverities.includes(value);
-}
-/**
- * All valid health actions
- */
-export const HealthActions = [
-    'monitor',
-    'send_ping',
-    'restart',
-    'notify_director',
-    'reassign_task',
-    'escalate',
-];
-/**
- * Type guard for HealthAction
- */
-export function isHealthAction(value) {
-    return typeof value === 'string' && HealthActions.includes(value);
-}
-// ============================================================================
-// Health Steward Service Implementation
-// ============================================================================
-/**
- * Default configuration values
- */
-const DEFAULT_CONFIG = {
-    noOutputThresholdMs: 5 * 60 * 1000, // 5 minutes
-    errorCountThreshold: 5,
-    errorWindowMs: 10 * 60 * 1000, // 10 minutes
-    staleSessionThresholdMs: 15 * 60 * 1000, // 15 minutes
-    healthCheckIntervalMs: 60 * 1000, // 1 minute
-    maxPingAttempts: 3,
-    autoRestart: true,
-    autoReassign: true,
-    notifyDirector: true,
-    maxIssuesPerAgent: 10,
-};
-/**
- * Implementation of the Health Steward Service.
- */
-export class HealthStewardServiceImpl {
-    // Reserved for future persistence of health data
-    _api;
-    config;
-    agentRegistry;
-    sessionManager;
-    taskAssignment;
-    dispatchService;
-    emitter;
-    // State
-    running = false;
-    checkInterval;
-    issueCounter = 0;
-    // Tracking
-    activityTrackers = new Map();
-    activeIssues = new Map();
-    resolvedIssueIds = new Set();
-    // Statistics
-    totalChecks = 0;
-    totalIssuesDetected = 0;
-    totalIssuesResolved = 0;
-    totalActionsTaken = 0;
-    successfulActions = 0;
-    failedActions = 0;
-    constructor(api, agentRegistry, sessionManager, taskAssignment, dispatchService, config = {}) {
-        this._api = api;
-        this.agentRegistry = agentRegistry;
-        this.sessionManager = sessionManager;
-        this.taskAssignment = taskAssignment;
-        this.dispatchService = dispatchService;
-        this.config = { ...DEFAULT_CONFIG, ...config };
-        this.emitter = new EventEmitter();
-    }
-    // ----------------------------------------
-    // Health Checks
-    // ----------------------------------------
-    async runHealthCheck() {
-        const startTime = Date.now();
-        const timestamp = createTimestamp();
-        const newIssues = [];
-        const resolvedIssues = [];
-        const actionsTaken = [];
-        // Get all agents with running sessions
-        const agents = await this.getRunningAgents();
-        let agentsWithIssues = 0;
-        for (const agent of agents) {
-            const agentId = agent.id;
-            const status = await this.checkAgent(agentId);
-            if (!status.isHealthy) {
-                agentsWithIssues++;
-                // Record new issues
-                for (const issue of status.issues) {
-                    if (!this.activeIssues.has(issue.id)) {
-                        newIssues.push(issue);
-                        this.emitter.emit('issue:detected', issue);
-                    }
-                }
-                // Take automatic actions if configured
-                for (const issue of status.issues) {
-                    const action = await this.determineAction(issue);
-                    if (action !== 'monitor') {
-                        const result = await this.takeAction(issue.id, action);
-                        actionsTaken.push(result);
-                    }
-                }
-            }
-        }
-        // Check for resolved issues
-        for (const [issueId, issue] of this.activeIssues) {
-            const agent = await this.agentRegistry.getAgent(issue.agentId);
-            if (!agent) {
-                // Agent no longer exists - resolve issue
-                this.resolveIssue(issueId);
-                resolvedIssues.push(issueId);
-                continue;
-            }
-            // Check if the issue condition still applies
-            const stillApplies = await this.issueStillApplies(issue);
-            if (!stillApplies) {
-                this.resolveIssue(issueId);
-                resolvedIssues.push(issueId);
-            }
-        }
-        this.totalChecks++;
-        const result = {
-            timestamp,
-            agentsChecked: agents.length,
-            agentsWithIssues,
-            newIssues,
-            resolvedIssues,
-            actionsTaken,
-            durationMs: Date.now() - startTime,
-        };
-        this.emitter.emit('check:completed', result);
-        return result;
-    }
-    async checkAgent(agentId) {
-        const agent = await this.agentRegistry.getAgent(agentId);
-        if (!agent) {
-            return this.createUnhealthyStatus(agentId, 'unknown', 'worker', []);
-        }
-        const meta = getAgentMetadata(agent);
-        if (!meta) {
-            return this.createUnhealthyStatus(agentId, agent.name, 'worker', []);
-        }
-        const tracker = this.getOrCreateTracker(agentId);
-        tracker.lastHealthCheckAt = createTimestamp();
-        const issues = [];
-        const now = Date.now();
-        // Get session info
-        const session = this.sessionManager.getActiveSession(agentId);
-        const sessionStatus = session?.status ?? meta.sessionStatus ?? 'idle';
-        // Only check running sessions
-        if (sessionStatus === 'running') {
-            // Check for no output
-            if (tracker.lastOutputAt) {
-                const lastOutputTime = this.getTimestampMs(tracker.lastOutputAt);
-                const timeSinceOutput = now - lastOutputTime;
-                if (timeSinceOutput > this.config.noOutputThresholdMs) {
-                    issues.push(this.createIssue(agentId, agent.name, meta.agentRole, 'no_output', {
-                        timeSinceOutputMs: timeSinceOutput,
-                        thresholdMs: this.config.noOutputThresholdMs,
-                        sessionId: session?.id,
-                    }));
-                }
-            }
-            // Check for repeated errors
-            const recentErrors = this.countRecentEvents(tracker.errorTimestamps, this.config.errorWindowMs);
-            if (recentErrors >= this.config.errorCountThreshold) {
-                issues.push(this.createIssue(agentId, agent.name, meta.agentRole, 'repeated_errors', {
-                    errorCount: recentErrors,
-                    thresholdCount: this.config.errorCountThreshold,
-                    windowMs: this.config.errorWindowMs,
-                    sessionId: session?.id,
-                }));
-            }
-            // Check for high error rate
-            const recentOutputs = this.countRecentEvents(tracker.outputTimestamps, this.config.errorWindowMs);
-            if (recentOutputs > 0 && recentErrors > 0) {
-                const errorRate = recentErrors / (recentErrors + recentOutputs);
-                if (errorRate > 0.5) { // More than 50% errors
-                    issues.push(this.createIssue(agentId, agent.name, meta.agentRole, 'high_error_rate', {
-                        errorRate,
-                        errorCount: recentErrors,
-                        outputCount: recentOutputs,
-                        sessionId: session?.id,
-                    }));
-                }
-            }
-            // Check for stale session
-            if (session?.lastActivityAt) {
-                const lastActivityTime = this.getTimestampMs(session.lastActivityAt);
-                const timeSinceActivity = now - lastActivityTime;
-                if (timeSinceActivity > this.config.staleSessionThresholdMs) {
-                    issues.push(this.createIssue(agentId, agent.name, meta.agentRole, 'session_stale', {
-                        timeSinceActivityMs: timeSinceActivity,
-                        thresholdMs: this.config.staleSessionThresholdMs,
-                        sessionId: session.id,
-                    }));
-                }
-            }
-        }
-        // Get current task
-        const agentTasks = await this.taskAssignment.getAgentTasks(agentId, {
-            taskStatus: TaskStatus.IN_PROGRESS,
-        });
-        const currentTaskId = agentTasks[0]?.taskId;
-        // Add task context to issues
-        for (const issue of issues) {
-            if (currentTaskId) {
-                issue.taskId = currentTaskId;
-            }
-        }
-        // Update active issues
-        for (const issue of issues) {
-            const existingIssue = this.findExistingIssue(agentId, issue.issueType);
-            if (existingIssue) {
-                // Update existing issue
-                this.activeIssues.set(existingIssue.id, {
-                    ...existingIssue,
-                    lastSeenAt: createTimestamp(),
-                    occurrenceCount: existingIssue.occurrenceCount + 1,
-                    context: issue.context,
-                });
-            }
-            else {
-                // New issue
-                this.activeIssues.set(issue.id, issue);
-                this.totalIssuesDetected++;
-            }
-        }
-        const recentErrors = this.countRecentEvents(tracker.errorTimestamps, this.config.errorWindowMs);
-        const recentOutputs = this.countRecentEvents(tracker.outputTimestamps, this.config.errorWindowMs);
-        return {
-            agentId,
-            agentName: agent.name,
-            agentRole: meta.agentRole,
-            isHealthy: issues.length === 0,
-            issues,
-            lastActivityAt: tracker.lastOutputAt ?? meta.lastActivityAt,
-            lastHealthCheckAt: tracker.lastHealthCheckAt,
-            sessionStatus,
-            currentTaskId,
-            recentErrorCount: recentErrors,
-            recentOutputCount: recentOutputs,
-        };
-    }
-    async getAllAgentHealth() {
-        const agents = await this.getRunningAgents();
-        const statuses = [];
-        for (const agent of agents) {
-            const agentId = agent.id;
-            const status = await this.checkAgent(agentId);
-            statuses.push(status);
-        }
-        return statuses;
-    }
-    // ----------------------------------------
-    // Issue Management
-    // ----------------------------------------
-    getActiveIssues() {
-        return Array.from(this.activeIssues.values());
-    }
-    getIssuesForAgent(agentId) {
-        return Array.from(this.activeIssues.values()).filter((issue) => issue.agentId === agentId);
-    }
-    resolveIssue(issueId) {
-        const issue = this.activeIssues.get(issueId);
-        if (!issue) {
-            return false;
-        }
-        this.activeIssues.delete(issueId);
-        this.resolvedIssueIds.add(issueId);
-        this.totalIssuesResolved++;
-        this.emitter.emit('issue:resolved', issueId);
-        return true;
-    }
-    clearResolvedIssues() {
-        this.resolvedIssueIds.clear();
-    }
-    // ----------------------------------------
-    // Actions
-    // ----------------------------------------
-    async takeAction(issueId, action) {
-        const issue = this.activeIssues.get(issueId);
-        if (!issue) {
-            return {
-                success: false,
-                action: action ?? 'monitor',
-                issueId,
-                message: `Issue not found: ${issueId}`,
-                actionTakenAt: createTimestamp(),
-                error: 'Issue not found',
-            };
-        }
-        const effectiveAction = action ?? await this.determineAction(issue);
-        this.totalActionsTaken++;
-        let result;
-        try {
-            switch (effectiveAction) {
-                case 'monitor':
-                    result = {
-                        success: true,
-                        action: effectiveAction,
-                        issueId,
-                        message: `Continuing to monitor agent ${issue.agentName}`,
-                        actionTakenAt: createTimestamp(),
-                    };
-                    break;
-                case 'send_ping':
-                    const pingSuccess = await this.pingAgent(issue.agentId);
-                    result = {
-                        success: pingSuccess,
-                        action: effectiveAction,
-                        issueId,
-                        message: pingSuccess
-                            ? `Agent ${issue.agentName} responded to ping`
-                            : `Agent ${issue.agentName} did not respond to ping`,
-                        actionTakenAt: createTimestamp(),
-                    };
-                    break;
-                case 'restart':
-                    const restartSuccess = await this.restartAgent(issue.agentId);
-                    result = {
-                        success: restartSuccess,
-                        action: effectiveAction,
-                        issueId,
-                        message: restartSuccess
-                            ? `Successfully restarted agent ${issue.agentName}`
-                            : `Failed to restart agent ${issue.agentName}`,
-                        actionTakenAt: createTimestamp(),
-                    };
-                    if (restartSuccess) {
-                        this.resolveIssue(issueId);
-                    }
-                    break;
-                case 'notify_director':
-                    const notifySuccess = await this.notifyDirector(issue);
-                    result = {
-                        success: notifySuccess,
-                        action: effectiveAction,
-                        issueId,
-                        message: notifySuccess
-                            ? `Director notified about ${issue.agentName}`
-                            : `Failed to notify Director about ${issue.agentName}`,
-                        actionTakenAt: createTimestamp(),
-                    };
-                    break;
-                case 'reassign_task':
-                    if (!issue.taskId) {
-                        result = {
-                            success: false,
-                            action: effectiveAction,
-                            issueId,
-                            message: `No task to reassign for agent ${issue.agentName}`,
-                            actionTakenAt: createTimestamp(),
-                            error: 'No task associated with issue',
-                        };
-                    }
-                    else {
-                        const reassignResult = await this.reassignTask(issue.agentId, issue.taskId);
-                        result = {
-                            success: reassignResult.success,
-                            action: effectiveAction,
-                            issueId,
-                            message: reassignResult.success
-                                ? `Task reassigned from ${issue.agentName} to new agent`
-                                : `Failed to reassign task from ${issue.agentName}`,
-                            actionTakenAt: createTimestamp(),
-                            newAgentId: reassignResult.newAgentId,
-                            error: reassignResult.error,
-                        };
-                        if (reassignResult.success) {
-                            this.resolveIssue(issueId);
-                        }
-                    }
-                    break;
-                case 'escalate':
-                    // For escalate, we notify both Director and mark for human review
-                    await this.notifyDirector(issue);
-                    result = {
-                        success: true,
-                        action: effectiveAction,
-                        issueId,
-                        message: `Issue escalated for agent ${issue.agentName} - requires human intervention`,
-                        actionTakenAt: createTimestamp(),
-                    };
-                    break;
-                default:
-                    result = {
-                        success: false,
-                        action: effectiveAction,
-                        issueId,
-                        message: `Unknown action: ${effectiveAction}`,
-                        actionTakenAt: createTimestamp(),
-                        error: `Unknown action: ${effectiveAction}`,
-                    };
-            }
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            result = {
-                success: false,
-                action: effectiveAction,
-                issueId,
-                message: `Action failed: ${errorMessage}`,
-                actionTakenAt: createTimestamp(),
-                error: errorMessage,
-            };
-        }
-        if (result.success) {
-            this.successfulActions++;
-        }
-        else {
-            this.failedActions++;
-        }
-        this.emitter.emit('action:taken', result);
-        return result;
-    }
-    async pingAgent(agentId) {
-        const tracker = this.getOrCreateTracker(agentId);
-        // Check if we've exceeded ping attempts
-        if (tracker.pingAttempts >= this.config.maxPingAttempts) {
-            return false;
-        }
-        const session = this.sessionManager.getActiveSession(agentId);
-        if (!session || session.status !== 'running') {
-            return false;
-        }
-        tracker.lastPingAt = createTimestamp();
-        tracker.pingAttempts++;
-        // Send a health check message via the session
-        const result = await this.sessionManager.messageSession(session.id, {
-            content: 'Health check ping - please respond with any message to confirm you are active.',
-        });
-        return result.success;
-    }
-    async restartAgent(agentId) {
-        const session = this.sessionManager.getActiveSession(agentId);
-        if (session) {
-            try {
-                // Stop the current session
-                await this.sessionManager.stopSession(session.id, {
-                    graceful: true,
-                    reason: 'Health Steward restart due to detected issues',
-                });
-            }
-            catch {
-                // Continue even if stop fails
-            }
-        }
-        // Reset tracker
-        const tracker = this.getOrCreateTracker(agentId);
-        tracker.pingAttempts = 0;
-        tracker.errorTimestamps = [];
-        // Note: We don't auto-start a new session here - that's the responsibility
-        // of the agent or Director. We've cleared the issues by stopping.
-        return true;
-    }
-    async notifyDirector(issue) {
-        // Find the Director agent
-        const directors = await this.agentRegistry.getAgentsByRole('director');
-        if (directors.length === 0) {
-            return false;
-        }
-        const director = directors[0];
-        const directorId = director.id;
-        // Build notification content
-        const severity = issue.severity.toUpperCase();
-        const content = [
-            `# Health Alert: ${severity}`,
-            '',
-            `**Agent:** ${issue.agentName} (${issue.agentRole})`,
-            `**Issue:** ${issue.issueType}`,
-            `**Description:** ${issue.description}`,
-            '',
-            `**Detected:** ${issue.detectedAt}`,
-            `**Occurrences:** ${issue.occurrenceCount}`,
-            '',
-            issue.taskId ? `**Current Task:** ${issue.taskId}` : '',
-            '',
-            '**Recommended Action:**',
-            this.getRecommendedActionDescription(issue),
-        ].filter(Boolean).join('\n');
-        try {
-            // Use task-assignment type as a general notification mechanism
-            await this.dispatchService.notifyAgent(directorId, 'task-assignment', content, {
-                healthAlert: true,
-                issueId: issue.id,
-                issueType: issue.issueType,
-                severity: issue.severity,
-                agentId: issue.agentId,
-                agentName: issue.agentName,
-                taskId: issue.taskId,
-            });
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    async reassignTask(agentId, taskId) {
-        try {
-            // Stop the current agent session
-            const session = this.sessionManager.getActiveSession(agentId);
-            if (session) {
-                await this.sessionManager.stopSession(session.id, {
-                    graceful: false,
-                    reason: 'Task reassignment due to agent health issues',
-                });
-            }
-            // Unassign the task - it will be picked up by the dispatch daemon
-            await this.taskAssignment.unassignTask(taskId);
-            // Task reassignment is now handled by the dispatch daemon polling for
-            // unassigned tasks, rather than immediately dispatching here
-            return {
-                success: true,
-                // Note: newAgentId is undefined since dispatch daemon handles assignment
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            return {
-                success: false,
-                error: errorMessage,
-            };
-        }
-    }
-    // ----------------------------------------
-    // Activity Tracking
-    // ----------------------------------------
-    recordOutput(agentId) {
-        const tracker = this.getOrCreateTracker(agentId);
-        const now = createTimestamp();
-        tracker.lastOutputAt = now;
-        tracker.outputTimestamps.push(now);
-        // Reset ping attempts on successful output
-        tracker.pingAttempts = 0;
-        // Prune old timestamps
-        this.pruneTimestamps(tracker);
-    }
-    recordError(agentId, _error) {
-        const tracker = this.getOrCreateTracker(agentId);
-        const now = createTimestamp();
-        tracker.lastErrorAt = now;
-        tracker.errorTimestamps.push(now);
-        // Prune old timestamps
-        this.pruneTimestamps(tracker);
-    }
-    recordCrash(agentId, exitCode) {
-        const agent = this.activityTrackers.get(agentId);
-        const agentName = agent ? 'Agent' : 'Unknown';
-        // Create a crash issue immediately
-        const issue = this.createIssue(agentId, agentName, 'worker', // Default, will be updated
-        'process_crashed', { exitCode });
-        this.activeIssues.set(issue.id, issue);
-        this.totalIssuesDetected++;
-        this.emitter.emit('issue:detected', issue);
-    }
-    // ----------------------------------------
-    // Lifecycle
-    // ----------------------------------------
-    start() {
-        if (this.running) {
-            return;
-        }
-        this.running = true;
-        this.checkInterval = setInterval(() => this.runHealthCheck().catch(() => { }), this.config.healthCheckIntervalMs);
-    }
-    stop() {
-        if (!this.running) {
-            return;
-        }
-        this.running = false;
-        if (this.checkInterval) {
-            clearInterval(this.checkInterval);
-            this.checkInterval = undefined;
-        }
-    }
-    isRunning() {
-        return this.running;
-    }
-    // ----------------------------------------
-    // Statistics
-    // ----------------------------------------
-    getStats() {
-        return {
-            totalChecks: this.totalChecks,
-            totalIssuesDetected: this.totalIssuesDetected,
-            totalIssuesResolved: this.totalIssuesResolved,
-            totalActionsTaken: this.totalActionsTaken,
-            successfulActions: this.successfulActions,
-            failedActions: this.failedActions,
-            activeIssues: this.activeIssues.size,
-            monitoredAgents: this.activityTrackers.size,
-        };
-    }
-    on(event, listener) {
-        this.emitter.on(event, listener);
-    }
-    off(event, listener) {
-        this.emitter.off(event, listener);
-    }
-    // ----------------------------------------
-    // Private Helpers
-    // ----------------------------------------
-    async getRunningAgents() {
-        const allAgents = await this.agentRegistry.listAgents({
-            sessionStatus: 'running',
-        });
-        return allAgents;
-    }
-    getOrCreateTracker(agentId) {
-        let tracker = this.activityTrackers.get(agentId);
-        if (!tracker) {
-            tracker = {
-                agentId,
-                errorTimestamps: [],
-                outputTimestamps: [],
-                pingAttempts: 0,
-            };
-            this.activityTrackers.set(agentId, tracker);
-        }
-        return tracker;
-    }
-    createIssue(agentId, agentName, agentRole, issueType, context) {
-        const now = createTimestamp();
-        const severity = this.determineSeverity(issueType, context);
-        return {
-            id: `health-${++this.issueCounter}-${Date.now()}`,
-            agentId,
-            agentName,
-            agentRole,
-            issueType,
-            severity,
-            description: this.getIssueDescription(issueType, context),
-            detectedAt: now,
-            lastSeenAt: now,
-            occurrenceCount: 1,
-            sessionId: context?.sessionId,
-            context,
-        };
-    }
-    createUnhealthyStatus(agentId, agentName, agentRole, issues) {
-        return {
-            agentId,
-            agentName,
-            agentRole,
-            isHealthy: false,
-            issues,
-            recentErrorCount: 0,
-            recentOutputCount: 0,
-        };
-    }
-    determineSeverity(issueType, context) {
-        switch (issueType) {
-            case 'process_crashed':
-                return 'critical';
-            case 'repeated_errors':
-                const errorCount = context?.errorCount ?? 0;
-                return errorCount > 10 ? 'critical' : 'error';
-            case 'high_error_rate':
-                return 'error';
-            case 'no_output':
-                const timeSinceOutput = context?.timeSinceOutputMs ?? 0;
-                return timeSinceOutput > 15 * 60 * 1000 ? 'error' : 'warning';
-            case 'session_stale':
-                return 'warning';
-            case 'unresponsive':
-                return 'error';
-            default:
-                return 'warning';
-        }
-    }
-    getIssueDescription(issueType, context) {
-        switch (issueType) {
-            case 'no_output':
-                const mins = Math.round((context?.timeSinceOutputMs ?? 0) / 60000);
-                return `Agent has produced no output for ${mins} minutes`;
-            case 'repeated_errors':
-                return `Agent has encountered ${context?.errorCount ?? 'multiple'} errors in the last ${Math.round((context?.windowMs ?? 600000) / 60000)} minutes`;
-            case 'process_crashed':
-                return `Agent process crashed with exit code ${context?.exitCode ?? 'unknown'}`;
-            case 'high_error_rate':
-                const rate = (context?.errorRate ?? 0) * 100;
-                return `Agent has a ${rate.toFixed(1)}% error rate`;
-            case 'session_stale':
-                const staleMins = Math.round((context?.timeSinceActivityMs ?? 0) / 60000);
-                return `Agent session has been inactive for ${staleMins} minutes`;
-            case 'unresponsive':
-                return 'Agent is not responding to health check pings';
-            default:
-                return 'Unknown health issue';
-        }
-    }
-    async determineAction(issue) {
-        const tracker = this.activityTrackers.get(issue.agentId);
-        switch (issue.issueType) {
-            case 'process_crashed':
-                // For crashes, try to reassign if auto-reassign is enabled
-                if (this.config.autoReassign && issue.taskId) {
-                    return 'reassign_task';
-                }
-                return 'notify_director';
-            case 'no_output':
-            case 'session_stale':
-                // First try pinging
-                if (tracker && tracker.pingAttempts < this.config.maxPingAttempts) {
-                    return 'send_ping';
-                }
-                // Then try restart
-                if (this.config.autoRestart) {
-                    return 'restart';
-                }
-                return 'notify_director';
-            case 'repeated_errors':
-            case 'high_error_rate':
-                // Notify Director about error patterns
-                if (this.config.notifyDirector) {
-                    return 'notify_director';
-                }
-                return 'monitor';
-            case 'unresponsive':
-                // Escalate unresponsive agents
-                if (issue.severity === 'critical') {
-                    return 'escalate';
-                }
-                if (this.config.autoRestart) {
-                    return 'restart';
-                }
-                return 'notify_director';
-            default:
-                return 'monitor';
-        }
-    }
-    getRecommendedActionDescription(issue) {
-        switch (issue.issueType) {
-            case 'process_crashed':
-                return 'Restart the agent and reassign any incomplete tasks.';
-            case 'no_output':
-                return 'Check if the agent is stuck and consider restarting.';
-            case 'repeated_errors':
-                return 'Review the task requirements and agent logs to identify the root cause.';
-            case 'high_error_rate':
-                return 'The agent may be struggling with the current task. Consider reassignment.';
-            case 'session_stale':
-                return 'The agent session may be hung. Try restarting the session.';
-            case 'unresponsive':
-                return 'The agent is not responding. Force terminate and reassign task.';
-            default:
-                return 'Monitor the situation and take action if it persists.';
-        }
-    }
-    findExistingIssue(agentId, issueType) {
-        for (const issue of this.activeIssues.values()) {
-            if (issue.agentId === agentId && issue.issueType === issueType) {
-                return issue;
-            }
-        }
-        return undefined;
-    }
-    async issueStillApplies(issue) {
-        const tracker = this.activityTrackers.get(issue.agentId);
-        if (!tracker) {
-            return false;
-        }
-        const now = Date.now();
-        switch (issue.issueType) {
-            case 'no_output':
-                if (!tracker.lastOutputAt)
-                    return true;
-                const timeSinceOutput = now - this.getTimestampMs(tracker.lastOutputAt);
-                return timeSinceOutput > this.config.noOutputThresholdMs;
-            case 'repeated_errors':
-                const recentErrors = this.countRecentEvents(tracker.errorTimestamps, this.config.errorWindowMs);
-                return recentErrors >= this.config.errorCountThreshold;
-            case 'process_crashed':
-                // Crashes are resolved by explicit restart/reassign
-                return true;
-            case 'high_error_rate':
-                const errors = this.countRecentEvents(tracker.errorTimestamps, this.config.errorWindowMs);
-                const outputs = this.countRecentEvents(tracker.outputTimestamps, this.config.errorWindowMs);
-                if (outputs === 0)
-                    return false;
-                return (errors / (errors + outputs)) > 0.5;
-            case 'session_stale':
-                const session = this.sessionManager.getActiveSession(issue.agentId);
-                if (!session?.lastActivityAt)
-                    return false;
-                const timeSinceActivity = now - this.getTimestampMs(session.lastActivityAt);
-                return timeSinceActivity > this.config.staleSessionThresholdMs;
-            default:
-                return false;
-        }
-    }
-    countRecentEvents(timestamps, windowMs) {
-        const now = Date.now();
-        const windowStart = now - windowMs;
-        return timestamps.filter((t) => this.getTimestampMs(t) >= windowStart).length;
-    }
-    pruneTimestamps(tracker) {
-        const now = Date.now();
-        const windowStart = now - this.config.errorWindowMs;
-        tracker.errorTimestamps = tracker.errorTimestamps.filter((t) => this.getTimestampMs(t) >= windowStart);
-        tracker.outputTimestamps = tracker.outputTimestamps.filter((t) => this.getTimestampMs(t) >= windowStart);
-    }
-    getTimestampMs(timestamp) {
-        return typeof timestamp === 'number' ? timestamp : new Date(timestamp).getTime();
-    }
-}
-// ============================================================================
-// Factory Function
-// ============================================================================
-/**
- * Creates a HealthStewardService instance
- */
-export function createHealthStewardService(api, agentRegistry, sessionManager, taskAssignment, dispatchService, config) {
-    return new HealthStewardServiceImpl(api, agentRegistry, sessionManager, taskAssignment, dispatchService, config);
-}
-//# sourceMappingURL=health-steward-service.js.map