aicodeman 0.2.8 → 0.3.0

package/dist/respawn-controller.js

@@ -38,18 +38,15 @@ import { randomUUID } from 'node:crypto';
 import { AiIdleChecker } from './ai-idle-checker.js';
 import { AiPlanChecker } from './ai-plan-checker.js';
 import { BufferAccumulator } from './utils/buffer-accumulator.js';
-import { ANSI_ESCAPE_PATTERN_SIMPLE, TOKEN_PATTERN, assertNever } from './utils/index.js';
+import { ANSI_ESCAPE_PATTERN_SIMPLE, assertNever, CleanupManager } from './utils/index.js';
 import { MAX_RESPAWN_BUFFER_SIZE, TRIM_RESPAWN_BUFFER_TO as RESPAWN_BUFFER_TRIM_SIZE } from './config/buffer-limits.js';
+import { isCompletionMessage, hasWorkingPattern, extractTokenCount, PROMPT_PATTERNS, WORKING_PATTERNS, } from './respawn-patterns.js';
+import { RespawnAdaptiveTiming } from './respawn-adaptive-timing.js';
+import { RespawnCycleMetricsTracker } from './respawn-metrics.js';
+import { calculateHealthScore, shouldSkipClear } from './respawn-health.js';
+import { AI_CHECK_MODEL, AI_IDLE_CHECK_MAX_CONTEXT, AI_PLAN_CHECK_MAX_CONTEXT } from './config/ai-defaults.js';
 // ========== Constants ==========
-/**
- * Pattern to detect completion messages from Claude Code.
- * Requires "Worked for" prefix to avoid false positives from bare time durations
- * in regular text (e.g., "wait for 5s", "run for 2m").
- *
- * Matches: "✻ Worked for 2m 46s", "Worked for 46s", "Worked for 1h 2m 3s"
- * Does NOT match: "wait for 5s", "run for 2m", "for 3s the system..."
- */
-const COMPLETION_TIME_PATTERN = /\bWorked\s+for\s+\d+[hms](\s*\d+[hms])*/i;
+// COMPLETION_TIME_PATTERN moved to ./respawn-patterns.ts
 /** Pre-filter: numbered option pattern for plan mode detection */
 const PLAN_MODE_OPTION_PATTERN = /\d+\.\s+(Yes|No|Type|Cancel|Skip|Proceed|Approve|Reject)/i;
 /** Pre-filter: selection indicator arrow for plan mode detection */
@@ -67,13 +64,13 @@ const DEFAULT_CONFIG = {
     autoAcceptPrompts: true, // auto-accept plan mode prompts (not questions)
     autoAcceptDelayMs: 8000, // 8 seconds before auto-accepting
     aiIdleCheckEnabled: true, // use AI to confirm idle state
-    aiIdleCheckModel: 'claude-opus-4-5-20251101',
-    aiIdleCheckMaxContext: 16000, // ~4k tokens
+    aiIdleCheckModel: AI_CHECK_MODEL,
+    aiIdleCheckMaxContext: AI_IDLE_CHECK_MAX_CONTEXT,
     aiIdleCheckTimeoutMs: 90000, // 90 seconds (thinking can be slow)
     aiIdleCheckCooldownMs: 180000, // 3 minutes after WORKING verdict
     aiPlanCheckEnabled: true, // use AI to confirm plan mode before auto-accept
-    aiPlanCheckModel: 'claude-opus-4-5-20251101',
-    aiPlanCheckMaxContext: 8000, // ~2k tokens (plan mode UI is compact)
+    aiPlanCheckModel: AI_CHECK_MODEL,
+    aiPlanCheckMaxContext: AI_PLAN_CHECK_MAX_CONTEXT,
     aiPlanCheckTimeoutMs: 60000, // 60 seconds (thinking can be slow)
     aiPlanCheckCooldownMs: 30000, // 30 seconds after NOT_PLAN_MODE
     stuckStateDetectionEnabled: true, // detect stuck states
@@ -157,18 +154,12 @@ export class RespawnController extends EventEmitter {
     config;
     /** Current state machine state */
     _state = 'stopped';
-    /** Timer for step delays */
-    stepTimer = null;
-    /** Timer for completion confirmation (Layer 2) */
-    completionConfirmTimer = null;
-    /** Timer for no-output fallback (Layer 5) */
-    noOutputTimer = null;
-    /** Timer for periodic detection status updates */
-    detectionUpdateTimer = null;
-    /** Timer for auto-accepting plan mode prompts */
-    autoAcceptTimer = null;
-    /** Timer for pre-filter silence detection (triggers AI check) */
-    preFilterTimer = null;
+    /** Centralized timer lifecycle manager — disposed and recreated on clearTimers() */
+    cleanup = new CleanupManager();
+    /** Maps timer names to CleanupManager registration IDs (for individual cancel) */
+    timerIds = new Map();
+    /** Cached key fields from last emitted detection status (for dedup) */
+    lastEmittedDetectionKey = '';
     /** Whether any terminal output has been received since start/last-auto-accept */
     hasReceivedOutput = false;
     /** Whether an elicitation dialog (AskUserQuestion) was detected via hook signal */
@@ -182,8 +173,6 @@ export class RespawnController extends EventEmitter {
     idlePromptReceived = false;
     /** Timestamp when idle_prompt was received */
     idlePromptTime = null;
-    /** Timer for short confirmation after hook signal (handles race conditions) */
-    hookConfirmTimer = null;
     /** Confirmation delay after hook signal before confirming idle (ms) */
     static HOOK_CONFIRM_DELAY_MS = 3000;
     /** Number of completed respawn cycles */
@@ -206,10 +195,6 @@ export class RespawnController extends EventEmitter {
     planCheckStartTime = 0;
     /** Unique ID for current AI check request (to detect stale results) */
     _currentAiCheckId = null;
-    /** Timer for /clear step fallback (sends /init if no prompt detected) */
-    clearFallbackTimer = null;
-    /** Timer for step completion confirmation (waits for silence after completion) */
-    stepConfirmTimer = null;
     /** Fallback timeout for /clear step (ms) - sends /init without waiting for prompt */
     static CLEAR_FALLBACK_TIMEOUT_MS = 10000;
     // ========== Timer Tracking for UI Countdown Display ==========
@@ -220,44 +205,18 @@ export class RespawnController extends EventEmitter {
     // ========== Stuck-State Detection State ==========
     /** Timestamp when the current state was entered */
     stateEnteredAt = 0;
-    /** Timer for stuck-state detection */
-    stuckStateTimer = null;
     /** Whether a stuck-state warning has been emitted for current state */
     stuckStateWarned = false;
     /** Number of stuck-state recovery attempts */
     stuckRecoveryCount = 0;
-    // ========== P2-001: Adaptive Timing State ==========
-    /** Historical timing data for adaptive adjustments */
-    timingHistory = {
-        recentIdleDetectionMs: [],
-        recentCycleDurationMs: [],
-        adaptiveCompletionConfirmMs: 10000, // Start with default
-        sampleCount: 0,
-        maxSamples: 20, // Keep last 20 samples for rolling average
-        lastUpdatedAt: Date.now(),
-    };
-    // ========== P2-004: Cycle Metrics State ==========
-    /** Current cycle being tracked */
-    currentCycleMetrics = null;
+    // ========== P2-001: Adaptive Timing (delegated to RespawnAdaptiveTiming) ==========
+    /** Adaptive timing controller */
+    adaptiveTiming;
+    // ========== P2-004: Cycle Metrics (delegated to RespawnCycleMetricsTracker) ==========
+    /** Cycle metrics tracker */
+    cycleMetrics = new RespawnCycleMetricsTracker();
     /** Timestamp when idle detection started for current cycle */
     idleDetectionStartTime = 0;
-    /** Recent cycle metrics (rolling window for aggregate calculation) */
-    recentCycleMetrics = [];
-    /** Maximum number of cycle metrics to keep in memory */
-    static MAX_CYCLE_METRICS_IN_MEMORY = 100;
-    /** Aggregate metrics across all tracked cycles */
-    aggregateMetrics = {
-        totalCycles: 0,
-        successfulCycles: 0,
-        stuckRecoveryCycles: 0,
-        blockedCycles: 0,
-        errorCycles: 0,
-        avgCycleDurationMs: 0,
-        avgIdleDetectionMs: 0,
-        p90CycleDurationMs: 0,
-        successRate: 100,
-        lastUpdatedAt: Date.now(),
-    };
     // ========== Multi-Layer Detection State ==========
     /** Layer 1: Timestamp when completion message was detected */
     completionMessageTime = null;
@@ -269,71 +228,7 @@ export class RespawnController extends EventEmitter {
     lastTokenChangeTime = 0;
     /** Layer 4: Timestamp when last working pattern was seen */
     lastWorkingPatternTime = 0;
-    /**
-     * Patterns indicating Claude is ready for input (legacy fallback).
-     * Used as secondary signals, not primary detection.
-     */
-    PROMPT_PATTERNS = [
-        '❯', // Standard prompt
-        '\u276f', // Unicode variant
-        '⏵', // Claude Code prompt variant
-    ];
-    /**
-     * Patterns indicating Claude is actively working.
-     * When detected, resets all idle detection timers.
-     * Note: ✻ and ✽ removed - they appear in completion messages too.
-     */
-    WORKING_PATTERNS = [
-        'Thinking',
-        'Writing',
-        'Reading',
-        'Running',
-        'Searching',
-        'Editing',
-        'Creating',
-        'Deleting',
-        'Analyzing',
-        'Executing',
-        'Synthesizing',
-        'Brewing', // Claude's processing indicators
-        'Compiling',
-        'Building',
-        'Installing',
-        'Fetching',
-        'Downloading',
-        'Processing',
-        'Generating',
-        'Loading',
-        'Starting',
-        'Updating',
-        'Checking',
-        'Validating',
-        'Testing',
-        'Formatting',
-        'Linting',
-        '⠋',
-        '⠙',
-        '⠹',
-        '⠸',
-        '⠼',
-        '⠴',
-        '⠦',
-        '⠧',
-        '⠇',
-        '⠏', // Spinner chars
-        '◐',
-        '◓',
-        '◑',
-        '◒', // Alternative spinners
-        '⣾',
-        '⣽',
-        '⣻',
-        '⢿',
-        '⡿',
-        '⣟',
-        '⣯',
-        '⣷', // Braille spinners
-    ];
+    // PROMPT_PATTERNS and WORKING_PATTERNS are now imported from ./respawn-patterns.js
     /**
      * Rolling window buffer for working pattern detection.
      * Prevents split-chunk issues where "Thinking" arrives as "Thin" + "king".
@@ -360,6 +255,11 @@ export class RespawnController extends EventEmitter {
         this.config = { ...DEFAULT_CONFIG, ...filteredConfig };
         // Validate configuration values
         this.validateConfig();
+        // Initialize sub-modules
+        this.adaptiveTiming = new RespawnAdaptiveTiming({
+            adaptiveMinConfirmMs: this.config.adaptiveMinConfirmMs ?? 5000,
+            adaptiveMaxConfirmMs: this.config.adaptiveMaxConfirmMs ?? 30000,
+        });
         this.aiChecker = new AiIdleChecker(session.id, {
             enabled: this.config.aiIdleCheckEnabled,
             model: this.config.aiIdleCheckModel,
@@ -652,25 +552,31 @@ export class RespawnController extends EventEmitter {
         this.stopDetectionUpdates();
         if (this._state === 'stopped')
             return;
-        this.detectionUpdateTimer = setInterval(() => {
+        this.lastEmittedDetectionKey = '';
+        const id = this.cleanup.setInterval(() => {
             try {
                 if (this._state !== 'stopped') {
-                    this.emit('detectionUpdate', this.getDetectionStatus());
+                    const status = this.getDetectionStatus();
+                    // Only emit when status meaningfully changed (confidence, state text, or timer values)
+                    // to avoid broadcasting identical data every 2s for stable/idle sessions.
+                    const key = `${status.confidenceLevel}|${status.statusText}|${this._state}`;
+                    if (key !== this.lastEmittedDetectionKey) {
+                        this.lastEmittedDetectionKey = key;
+                        this.emit('detectionUpdate', status);
+                    }
                 }
             }
             catch (err) {
                 console.error(`[RespawnController] Error in detectionUpdateTimer:`, err);
             }
-        }, 2000);
+        }, 2000, { description: 'detection-update' });
+        this.timerIds.set('detection-update', id);
     }
     /**
      * Stop periodic detection status updates.
      */
     stopDetectionUpdates() {
-        if (this.detectionUpdateTimer) {
-            clearInterval(this.detectionUpdateTimer);
-            this.detectionUpdateTimer = null;
-        }
+        this.cancelTrackedTimer('detection-update');
     }
     /**
      * Transition to a new state.
@@ -781,7 +687,6 @@ export class RespawnController extends EventEmitter {
         this.aiChecker.removeAllListeners();
         this.planChecker.removeAllListeners();
         this.clearTimers();
-        this.stopDetectionUpdates();
         this.recentActions.length = 0;
         this.setState('stopped');
         if (this.terminalHandler) {
@@ -870,7 +775,7 @@ export class RespawnController extends EventEmitter {
             this.planChecker.cancel();
         }
         // Track token count (Layer 3)
-        const tokenCount = this.extractTokenCount(data);
+        const tokenCount = extractTokenCount(data);
         if (tokenCount !== null && tokenCount !== this.lastTokenCount) {
             this.lastTokenCount = tokenCount;
             this.lastTokenChangeTime = now;
@@ -878,7 +783,7 @@ export class RespawnController extends EventEmitter {
         // Detect completion message FIRST (Layer 1) - PRIMARY DETECTION
         // Check this before working patterns because completion message indicates
         // the work is done, even if working patterns are still in the rolling window
-        if (this.isCompletionMessage(data)) {
+        if (isCompletionMessage(data)) {
             // Clear the rolling window - completion marks a transition point
             this.clearWorkingPatternWindow();
             this.workingDetected = false;
@@ -923,7 +828,7 @@ export class RespawnController extends EventEmitter {
             return;
         }
         // Detect working patterns (Layer 4)
-        const isWorking = this.hasWorkingPattern(data);
+        const isWorking = this.checkWorkingPattern(data);
         if (isWorking) {
             this.workingDetected = true;
             this.promptDetected = false;
@@ -931,8 +836,7 @@ export class RespawnController extends EventEmitter {
             this.resetHookState(); // Clear hook signals on new work
             this.lastWorkingPatternTime = now;
             // Cancel hook confirmation timer if running
-            this.cancelTrackedTimer('hook-confirm', this.hookConfirmTimer, 'working patterns detected');
-            this.hookConfirmTimer = null;
+            this.cancelTrackedTimer('hook-confirm', 'working patterns detected');
             // Cancel any pending completion confirmation
             this.cancelCompletionConfirm();
             // Cancel any pending step confirmation (Claude is still working)
@@ -977,7 +881,7 @@ export class RespawnController extends EventEmitter {
             }
         }
         // Legacy fallback: detect prompt characters (still useful for waiting_* states)
-        const hasPrompt = this.PROMPT_PATTERNS.some((pattern) => data.includes(pattern));
+        const hasPrompt = PROMPT_PATTERNS.some((pattern) => data.includes(pattern));
         if (hasPrompt) {
             this.promptDetected = true;
             this.workingDetected = false;
@@ -1027,10 +931,8 @@ export class RespawnController extends EventEmitter {
         this.recordCycleStep('update');
         if (this.config.sendClear) {
             // P2-002: Check if we should skip /clear
-            if (this.shouldSkipClear()) {
-                if (this.currentCycleMetrics) {
-                    this.currentCycleMetrics.clearSkipped = true;
-                }
+            if (this.checkShouldSkipClear()) {
+                this.cycleMetrics.markClearSkipped();
                 // Skip /clear, go directly to /init or complete
                 if (this.config.sendInit) {
                     this.sendInit();
@@ -1057,8 +959,7 @@ export class RespawnController extends EventEmitter {
      */
     checkClearComplete() {
         // Clear the fallback timer since we got prompt detection
-        this.cancelTrackedTimer('clear-fallback', this.clearFallbackTimer, 'prompt detected');
-        this.clearFallbackTimer = null;
+        this.cancelTrackedTimer('clear-fallback', 'prompt detected');
         this.logAction('step', '/clear completed');
         this.emit('stepCompleted', 'clear');
         // P2-004: Record step completion
@@ -1101,8 +1002,7 @@ export class RespawnController extends EventEmitter {
         this.workingDetected = false;
         this.logAction('step', 'Monitoring if /init triggered work...');
         // Give Claude a moment to start working before checking for idle
-        this.stepTimer = this.startTrackedTimer('init-monitor', 3000, () => {
-            this.stepTimer = null;
+        this.startTrackedTimer('init-monitor', 3000, () => {
             // If still in monitoring state and no work detected, consider it idle
             if (this._state === 'monitoring_init' && !this.workingDetected) {
                 this.checkMonitoringInitIdle();
@@ -1115,10 +1015,7 @@ export class RespawnController extends EventEmitter {
      * @fires stepCompleted - With step 'init'
      */
     checkMonitoringInitIdle() {
-        if (this.stepTimer) {
-            clearTimeout(this.stepTimer);
-            this.stepTimer = null;
-        }
+        this.cancelTrackedTimer('init-monitor');
         this.log('/init did not trigger work, sending kickstart prompt');
         this.emit('stepCompleted', 'init');
         this.sendKickstart();
@@ -1131,8 +1028,7 @@ export class RespawnController extends EventEmitter {
         this.setState('sending_kickstart');
         this.terminalBuffer.clear();
         this.clearWorkingPatternWindow();
-        this.stepTimer = this.startTrackedTimer('step-delay', this.config.interStepDelayMs, async () => {
-            this.stepTimer = null;
+        this.startTrackedTimer('step-delay', this.config.interStepDelayMs, async () => {
             if (this._state === 'stopped')
                 return;
             const prompt = this.config.kickstartPrompt;
@@ -1157,48 +1053,10 @@ export class RespawnController extends EventEmitter {
     }
     /** Clear all timers (step, completion confirm, no-output, pre-filter, step confirm, auto-accept, hook confirm, and clear fallback) */
     clearTimers() {
-        // Clear tracked timers map first to avoid stale entries during individual cleanup
         this.activeTimers.clear();
-        if (this.stepTimer) {
-            clearTimeout(this.stepTimer);
-            this.stepTimer = null;
-        }
-        if (this.clearFallbackTimer) {
-            clearTimeout(this.clearFallbackTimer);
-            this.clearFallbackTimer = null;
-        }
-        if (this.completionConfirmTimer) {
-            clearTimeout(this.completionConfirmTimer);
-            this.completionConfirmTimer = null;
-        }
-        if (this.stepConfirmTimer) {
-            clearTimeout(this.stepConfirmTimer);
-            this.stepConfirmTimer = null;
-        }
-        if (this.autoAcceptTimer) {
-            clearTimeout(this.autoAcceptTimer);
-            this.autoAcceptTimer = null;
-        }
-        if (this.preFilterTimer) {
-            clearTimeout(this.preFilterTimer);
-            this.preFilterTimer = null;
-        }
-        if (this.noOutputTimer) {
-            clearTimeout(this.noOutputTimer);
-            this.noOutputTimer = null;
-        }
-        if (this.hookConfirmTimer) {
-            clearTimeout(this.hookConfirmTimer);
-            this.hookConfirmTimer = null;
-        }
-        if (this.stuckStateTimer) {
-            clearInterval(this.stuckStateTimer);
-            this.stuckStateTimer = null;
-        }
-        if (this.detectionUpdateTimer) {
-            clearInterval(this.detectionUpdateTimer);
-            this.detectionUpdateTimer = null;
-        }
+        this.timerIds.clear();
+        this.cleanup.dispose();
+        this.cleanup = new CleanupManager();
     }
     // ========== Stuck-State Detection Methods ==========
     /**
@@ -1211,20 +1069,18 @@ export class RespawnController extends EventEmitter {
         if (this._state === 'stopped')
             return;
         // Clear existing timer
-        if (this.stuckStateTimer) {
-            clearInterval(this.stuckStateTimer);
-            this.stuckStateTimer = null;
-        }
+        this.cancelTrackedTimer('stuck-state');
         // Check interval for stuck state
         const checkIntervalMs = Math.min(this.config.stuckStateWarningMs, 60000); // Check every minute max
-        this.stuckStateTimer = setInterval(() => {
+        const id = this.cleanup.setInterval(() => {
             try {
                 this.checkStuckState();
             }
             catch (err) {
                 console.error(`[RespawnController] Error in stuckStateTimer:`, err);
             }
-        }, checkIntervalMs);
+        }, checkIntervalMs, { description: 'stuck-state' });
+        this.timerIds.set('stuck-state', id);
     }
     /**
      * Check if the controller is stuck in the current state.
@@ -1264,7 +1120,7 @@ export class RespawnController extends EventEmitter {
     handleStuckStateRecovery() {
         const currentState = this._state;
         // P2-004: Complete current cycle metrics with stuck_recovery outcome
-        if (this.currentCycleMetrics) {
+        if (this.cycleMetrics.getCurrentCycle()) {
             this.completeCycleMetrics('stuck_recovery', `Stuck in state: ${currentState}`);
         }
         // Cancel any running AI checks
@@ -1341,23 +1197,29 @@ export class RespawnController extends EventEmitter {
      * Emits timerStarted event and tracks the timer for UI display.
      */
     startTrackedTimer(name, durationMs, callback, reason) {
+        // Cancel any existing timer with this name
+        this.cancelTrackedTimer(name);
         const now = Date.now();
         const endsAt = now + durationMs;
         this.activeTimers.set(name, { name, startedAt: now, durationMs, endsAt });
         this.emit('timerStarted', { name, durationMs, endsAt, reason });
         this.logAction('timer', `Started ${name}: ${Math.round(durationMs / 1000)}s${reason ? ` (${reason})` : ''}`);
-        return setTimeout(() => {
+        const id = this.cleanup.setTimeout(() => {
+            this.timerIds.delete(name);
             this.activeTimers.delete(name);
             this.emit('timerCompleted', name);
             callback();
-        }, durationMs);
+        }, durationMs, { description: name });
+        this.timerIds.set(name, id);
     }
     /**
      * Cancel a tracked timer and emit cancellation event.
      */
-    cancelTrackedTimer(name, timerRef, reason) {
-        if (timerRef) {
-            clearTimeout(timerRef);
+    cancelTrackedTimer(name, reason) {
+        const id = this.timerIds.get(name);
+        if (id) {
+            this.cleanup.unregister(id);
+            this.timerIds.delete(name);
             if (this.activeTimers.has(name)) {
                 this.activeTimers.delete(name);
                 this.emit('timerCancelled', name, reason);
@@ -1395,25 +1257,19 @@ export class RespawnController extends EventEmitter {
         return [...this.recentActions];
     }
     // ========== Multi-Layer Detection Methods ==========
+    // Pattern detection delegated to ./respawn-patterns.js (isCompletionMessage, hasWorkingPattern, extractTokenCount)
     /**
-     * Check if data contains a completion message pattern.
-     * Matches "for Xh Xm Xs" time duration patterns.
-     */
-    isCompletionMessage(data) {
-        return COMPLETION_TIME_PATTERN.test(data);
-    }
-    /**
-     * Check if data contains working patterns.
-     * Uses rolling window to catch patterns split across chunks (e.g., "Thin" + "king").
+     * Check if data contains working patterns using the rolling window.
+     * Updates the window and delegates to the pure function from respawn-patterns.
      */
-    hasWorkingPattern(data) {
+    checkWorkingPattern(data) {
         // Always update the rolling window first to maintain continuity
         this.workingPatternWindow += data;
         if (this.workingPatternWindow.length > RespawnController.WORKING_PATTERN_WINDOW_SIZE) {
             this.workingPatternWindow = this.workingPatternWindow.slice(-RespawnController.WORKING_PATTERN_WINDOW_SIZE);
         }
-        // Check the rolling window (includes current data, catches both complete and split patterns)
-        return this.WORKING_PATTERNS.some((pattern) => this.workingPatternWindow.includes(pattern));
+        // Delegate to pure function
+        return hasWorkingPattern(this.workingPatternWindow);
     }
     /**
      * Clear the working pattern rolling window.
@@ -1422,32 +1278,14 @@ export class RespawnController extends EventEmitter {
     clearWorkingPatternWindow() {
         this.workingPatternWindow = '';
     }
-    /**
-     * Extract token count from data if present.
-     * Returns null if no token pattern found.
-     */
-    extractTokenCount(data) {
-        const match = data.match(TOKEN_PATTERN);
-        if (!match)
-            return null;
-        let count = parseFloat(match[1]);
-        const suffix = match[2]?.toLowerCase();
-        if (suffix === 'k')
-            count *= 1000;
-        else if (suffix === 'm')
-            count *= 1000000;
-        return Math.round(count);
-    }
     /**
      * Start the no-output fallback timer.
      * If no output for noOutputTimeoutMs, triggers idle detection as safety net
      * (used when AI check is disabled or has too many errors).
      */
     startNoOutputTimer() {
-        this.cancelTrackedTimer('no-output-fallback', this.noOutputTimer, 'restarting');
-        this.noOutputTimer = null;
-        this.noOutputTimer = this.startTrackedTimer('no-output-fallback', this.config.noOutputTimeoutMs, () => {
-            this.noOutputTimer = null;
+        this.cancelTrackedTimer('no-output-fallback', 'restarting');
+        this.startTrackedTimer('no-output-fallback', this.config.noOutputTimeoutMs, () => {
             if (this._state === 'watching' || this._state === 'confirming_idle') {
                 const msSinceOutput = Date.now() - this.lastOutputTime;
                 this.logAction('detection', `No-output fallback: ${Math.round(msSinceOutput / 1000)}s silence`);
@@ -1476,13 +1314,11 @@ export class RespawnController extends EventEmitter {
      * This provides an additional path to AI check even without a completion message.
      */
     startPreFilterTimer() {
-        this.cancelTrackedTimer('pre-filter', this.preFilterTimer, 'restarting');
-        this.preFilterTimer = null;
+        this.cancelTrackedTimer('pre-filter', 'restarting');
         // Only set up pre-filter when AI check is enabled
         if (!this.config.aiIdleCheckEnabled)
             return;
-        this.preFilterTimer = this.startTrackedTimer('pre-filter', this.config.completionConfirmMs, () => {
-            this.preFilterTimer = null;
+        this.startTrackedTimer('pre-filter', this.config.completionConfirmMs, () => {
             if (this._state === 'watching') {
                 const now = Date.now();
                 const msSinceOutput = now - this.lastOutputTime;
@@ -1569,18 +1405,15 @@ export class RespawnController extends EventEmitter {
             }
             if (result.verdict === 'IDLE') {
                 // Cancel any pending confirmation timers - AI has spoken
-                this.cancelTrackedTimer('completion-confirm', this.completionConfirmTimer, 'AI verdict: IDLE');
-                this.completionConfirmTimer = null;
-                this.cancelTrackedTimer('pre-filter', this.preFilterTimer, 'AI verdict: IDLE');
-                this.preFilterTimer = null;
+                this.cancelTrackedTimer('completion-confirm', 'AI verdict: IDLE');
+                this.cancelTrackedTimer('pre-filter', 'AI verdict: IDLE');
                 this.logAction('ai-check', `Verdict: IDLE - ${result.reasoning}`);
                 this.emit('aiCheckCompleted', result);
                 this.onIdleConfirmed(`ai-check: idle (${result.reasoning})`);
             }
             else if (result.verdict === 'WORKING') {
                 // Cancel timers and go to cooldown
-                this.cancelTrackedTimer('completion-confirm', this.completionConfirmTimer, 'AI verdict: WORKING');
-                this.completionConfirmTimer = null;
+                this.cancelTrackedTimer('completion-confirm', 'AI verdict: WORKING');
                 this.logAction('ai-check', `Verdict: WORKING - ${result.reasoning}`);
                 this.emit('aiCheckCompleted', result);
                 this.setState('watching');
@@ -1635,10 +1468,8 @@ export class RespawnController extends EventEmitter {
      * and no elicitation dialog was detected. Only handles plan mode approvals.
      */
     startAutoAcceptTimer() {
-        this.cancelTrackedTimer('auto-accept', this.autoAcceptTimer, 'restarting');
-        this.autoAcceptTimer = null;
-        this.autoAcceptTimer = this.startTrackedTimer('auto-accept', this.config.autoAcceptDelayMs, () => {
-            this.autoAcceptTimer = null;
+        this.cancelTrackedTimer('auto-accept', 'restarting');
+        this.startTrackedTimer('auto-accept', this.config.autoAcceptDelayMs, () => {
             this.tryAutoAccept();
         }, 'plan mode detection');
     }
@@ -1647,8 +1478,7 @@ export class RespawnController extends EventEmitter {
      * Called when a completion message is detected (normal idle flow handles it).
      */
     cancelAutoAcceptTimer() {
-        this.cancelTrackedTimer('auto-accept', this.autoAcceptTimer, 'cancelled');
-        this.autoAcceptTimer = null;
+        this.cancelTrackedTimer('auto-accept', 'cancelled');
     }
     /**
      * Attempt to auto-accept a plan mode prompt by sending Enter.
@@ -1729,7 +1559,7 @@ export class RespawnController extends EventEmitter {
         // Working patterns before the selector are from earlier work and don't matter.
         const selectorIndex = stripped.lastIndexOf(selectorMatch[0]);
         const afterSelector = stripped.slice(selectorIndex + selectorMatch[0].length);
-        const hasWorking = this.WORKING_PATTERNS.some((pattern) => afterSelector.includes(pattern));
+        const hasWorking = WORKING_PATTERNS.some((pattern) => afterSelector.includes(pattern));
         if (hasWorking)
             return false;
         return true;
@@ -1796,8 +1626,7 @@ export class RespawnController extends EventEmitter {
             this.aiChecker.cancel();
         }
         // Cancel completion confirmation - auto-accept takes precedence
-        this.cancelTrackedTimer('completion-confirm', this.completionConfirmTimer, 'auto-accept');
-        this.completionConfirmTimer = null;
+        this.cancelTrackedTimer('completion-confirm', 'auto-accept');
         this.completionMessageTime = null;
         // Ensure we're in watching state (not confirming_idle or ai_checking)
         if (this._state !== 'watching') {
@@ -1844,11 +1673,9 @@ export class RespawnController extends EventEmitter {
             this.aiChecker.cancel();
         }
         // Cancel completion confirm timer - hook takes precedence
-        this.cancelTrackedTimer('completion-confirm', this.completionConfirmTimer, 'Stop hook received');
-        this.completionConfirmTimer = null;
+        this.cancelTrackedTimer('completion-confirm', 'Stop hook received');
         // Cancel pre-filter timer - hook takes precedence
-        this.cancelTrackedTimer('pre-filter', this.preFilterTimer, 'Stop hook received');
-        this.preFilterTimer = null;
+        this.cancelTrackedTimer('pre-filter', 'Stop hook received');
         // Start short confirmation timer to handle race conditions
         // (e.g., Stop hook arrives but Claude immediately starts new work)
         this.startHookConfirmTimer('stop');
@@ -1877,12 +1704,9 @@ export class RespawnController extends EventEmitter {
             this.aiChecker.cancel();
         }
         // Cancel all other detection timers - this is definitive
-        this.cancelTrackedTimer('completion-confirm', this.completionConfirmTimer, 'idle_prompt received');
-        this.completionConfirmTimer = null;
-        this.cancelTrackedTimer('pre-filter', this.preFilterTimer, 'idle_prompt received');
-        this.preFilterTimer = null;
-        this.cancelTrackedTimer('no-output-fallback', this.noOutputTimer, 'idle_prompt received');
-        this.noOutputTimer = null;
+        this.cancelTrackedTimer('completion-confirm', 'idle_prompt received');
+        this.cancelTrackedTimer('pre-filter', 'idle_prompt received');
+        this.cancelTrackedTimer('no-output-fallback', 'idle_prompt received');
         // idle_prompt is an even stronger signal than Stop hook (60s+ idle)
         // Skip confirmation and go directly to idle
         this.onIdleConfirmed('idle_prompt hook (60s+ idle)');
@@ -1894,10 +1718,8 @@ export class RespawnController extends EventEmitter {
      * @param hookType - Which hook triggered this ('stop' or 'idle_prompt')
      */
     startHookConfirmTimer(hookType) {
-        this.cancelTrackedTimer('hook-confirm', this.hookConfirmTimer, 'restarting');
-        this.hookConfirmTimer = null;
-        this.hookConfirmTimer = this.startTrackedTimer('hook-confirm', RespawnController.HOOK_CONFIRM_DELAY_MS, () => {
-            this.hookConfirmTimer = null;
+        this.cancelTrackedTimer('hook-confirm', 'restarting');
+        this.startTrackedTimer('hook-confirm', RespawnController.HOOK_CONFIRM_DELAY_MS, () => {
             // Verify we haven't received new output since the hook arrived
             const hookTime = hookType === 'stop' ? this.stopHookTime : this.idlePromptTime;
             if (hookTime && this.lastOutputTime > hookTime) {
@@ -1963,12 +1785,10 @@ export class RespawnController extends EventEmitter {
      * After completion message, waits for output silence then triggers AI check.
      */
     startCompletionConfirmTimer() {
-        this.cancelTrackedTimer('completion-confirm', this.completionConfirmTimer, 'restarting');
-        this.completionConfirmTimer = null;
+        this.cancelTrackedTimer('completion-confirm', 'restarting');
         this.setState('confirming_idle');
         this.logAction('detection', 'Completion message found in output');
-        this.completionConfirmTimer = this.startTrackedTimer('completion-confirm', this.config.completionConfirmMs, () => {
-            this.completionConfirmTimer = null;
+        this.startTrackedTimer('completion-confirm', this.config.completionConfirmMs, () => {
             if (this._state === 'stopped')
                 return;
             const msSinceOutput = Date.now() - this.lastOutputTime;
@@ -1989,8 +1809,7 @@ export class RespawnController extends EventEmitter {
      * Cancel completion confirmation if new activity detected.
      */
     cancelCompletionConfirm() {
-        this.cancelTrackedTimer('completion-confirm', this.completionConfirmTimer, 'activity detected');
-        this.completionConfirmTimer = null;
+        this.cancelTrackedTimer('completion-confirm', 'activity detected');
         if (this._state === 'confirming_idle') {
             this.setState('watching');
             this.completionMessageTime = null;
@@ -2002,10 +1821,8 @@ export class RespawnController extends EventEmitter {
      * This ensures Claude has finished processing before we send the next command.
      */
     startStepConfirmTimer(step) {
-        this.cancelTrackedTimer('step-confirm', this.stepConfirmTimer, 'restarting');
-        this.stepConfirmTimer = null;
-        this.stepConfirmTimer = this.startTrackedTimer('step-confirm', this.config.completionConfirmMs, () => {
-            this.stepConfirmTimer = null;
+        this.cancelTrackedTimer('step-confirm', 'restarting');
+        this.startTrackedTimer('step-confirm', this.config.completionConfirmMs, () => {
             if (this._state === 'stopped')
                 return;
             const msSinceOutput = Date.now() - this.lastOutputTime;
@@ -2035,8 +1852,7 @@ export class RespawnController extends EventEmitter {
      * Cancel step confirmation if working patterns detected.
      */
     cancelStepConfirm() {
-        this.cancelTrackedTimer('step-confirm', this.stepConfirmTimer, 'working detected');
-        this.stepConfirmTimer = null;
+        this.cancelTrackedTimer('step-confirm', 'working detected');
     }
     /**
      * Called when idle is confirmed through any detection layer.
@@ -2178,8 +1994,7 @@ export class RespawnController extends EventEmitter {
         this.setState('sending_update');
         this.terminalBuffer.clear(); // Clear buffer for fresh detection
         this.clearWorkingPatternWindow(); // Clear rolling window
-        this.stepTimer = this.startTrackedTimer('step-delay', this.config.interStepDelayMs, async () => {
-            this.stepTimer = null;
+        this.startTrackedTimer('step-delay', this.config.interStepDelayMs, async () => {
             if (this._state === 'stopped')
                 return;
             // Use RALPH_STATUS RECOMMENDATION if available, otherwise fall back to config
@@ -2210,8 +2025,7 @@ export class RespawnController extends EventEmitter {
         this.setState('sending_clear');
         this.terminalBuffer.clear();
         this.clearWorkingPatternWindow();
-        this.stepTimer = this.startTrackedTimer('step-delay', this.config.interStepDelayMs, async () => {
-            this.stepTimer = null;
+        this.startTrackedTimer('step-delay', this.config.interStepDelayMs, async () => {
             if (this._state === 'stopped')
                 return;
             this.logAction('command', 'Sending: /clear');
@@ -2220,8 +2034,7 @@ export class RespawnController extends EventEmitter {
             this.setState('waiting_clear');
             this.promptDetected = false;
             // Start fallback timer - if no prompt detected after 10s, proceed to /init anyway
-            this.clearFallbackTimer = this.startTrackedTimer('clear-fallback', RespawnController.CLEAR_FALLBACK_TIMEOUT_MS, () => {
-                this.clearFallbackTimer = null;
+            this.startTrackedTimer('clear-fallback', RespawnController.CLEAR_FALLBACK_TIMEOUT_MS, () => {
                 if (this._state === 'waiting_clear') {
                     this.logAction('step', '/clear fallback: proceeding to /init');
                     this.emit('stepCompleted', 'clear');
@@ -2243,8 +2056,7 @@ export class RespawnController extends EventEmitter {
         this.setState('sending_init');
         this.terminalBuffer.clear();
         this.clearWorkingPatternWindow();
-        this.stepTimer = this.startTrackedTimer('step-delay', this.config.interStepDelayMs, async () => {
-            this.stepTimer = null;
+        this.startTrackedTimer('step-delay', this.config.interStepDelayMs, async () => {
             if (this._state === 'stopped')
                 return;
             this.logAction('command', 'Sending: /init');
@@ -2371,7 +2183,7 @@ export class RespawnController extends EventEmitter {
             config: this.config,
         };
     }
-    // ========== P2-001: Adaptive Timing Methods ==========
+    // ========== P2-001: Adaptive Timing (delegated to RespawnAdaptiveTiming) ==========
     /**
      * Get the current completion confirm timeout, potentially adjusted by adaptive timing.
      * Uses historical idle detection durations to calculate an optimal timeout.
@@ -2383,90 +2195,40 @@ export class RespawnController extends EventEmitter {
             return this.config.completionConfirmMs ?? 10000;
         }
         // Need at least 5 samples before adjusting
-        if (this.timingHistory.sampleCount < 5) {
+        const history = this.adaptiveTiming.getTimingHistory();
+        if (history.sampleCount < 5) {
             return this.config.completionConfirmMs ?? 10000;
         }
-        return this.timingHistory.adaptiveCompletionConfirmMs;
-    }
-    /**
-     * Record timing data from a completed cycle for adaptive adjustments.
-     *
-     * @param idleDetectionMs - Time spent detecting idle
-     * @param cycleDurationMs - Total cycle duration
-     */
-    recordTimingData(idleDetectionMs, cycleDurationMs) {
-        if (!this.config.adaptiveTimingEnabled)
-            return;
-        const history = this.timingHistory;
-        // Add to rolling windows
-        history.recentIdleDetectionMs.push(idleDetectionMs);
-        history.recentCycleDurationMs.push(cycleDurationMs);
-        // Trim to max samples
-        if (history.recentIdleDetectionMs.length > history.maxSamples) {
-            history.recentIdleDetectionMs.shift();
-        }
-        if (history.recentCycleDurationMs.length > history.maxSamples) {
-            history.recentCycleDurationMs.shift();
-        }
-        history.sampleCount = history.recentIdleDetectionMs.length;
-        history.lastUpdatedAt = Date.now();
-        // Recalculate adaptive timing
-        this.updateAdaptiveTiming();
-    }
-    /**
-     * Recalculate the adaptive completion confirm timeout based on historical data.
-     * Uses the 75th percentile of recent idle detection times as the new timeout,
-     * with a 20% buffer for safety.
-     */
-    updateAdaptiveTiming() {
-        const history = this.timingHistory;
-        const minMs = this.config.adaptiveMinConfirmMs ?? 5000;
-        const maxMs = this.config.adaptiveMaxConfirmMs ?? 30000;
-        if (history.recentIdleDetectionMs.length < 5)
-            return;
-        // Sort for percentile calculation
-        const sorted = [...history.recentIdleDetectionMs].sort((a, b) => a - b);
-        // Use 75th percentile with 20% buffer
-        const p75Index = Math.floor(sorted.length * 0.75);
-        const p75Value = sorted[p75Index];
-        const withBuffer = Math.round(p75Value * 1.2);
-        // Clamp to configured bounds
-        const clamped = Math.max(minMs, Math.min(maxMs, withBuffer));
-        history.adaptiveCompletionConfirmMs = clamped;
-        this.log(`Adaptive timing updated: ${clamped}ms (p75=${p75Value}ms, samples=${sorted.length})`);
+        return this.adaptiveTiming.getAdaptiveCompletionConfirmMs();
     }
     /**
      * Get the current timing history for monitoring.
      * @returns Copy of timing history
      */
     getTimingHistory() {
-        return { ...this.timingHistory };
+        return this.adaptiveTiming.getTimingHistory();
     }
-    // ========== P2-002: Skip-Clear Optimization Methods ==========
+    // ========== P2-002: Skip-Clear Optimization (delegated to respawn-health.ts) ==========
     /**
      * Determine whether to skip the /clear step based on current context usage.
      * Skips if token count is below the configured threshold percentage.
      *
      * @returns True if /clear should be skipped
      */
-    shouldSkipClear() {
+    checkShouldSkipClear() {
         if (!this.config.skipClearWhenLowContext)
             return false;
         const thresholdPercent = this.config.skipClearThresholdPercent ?? 30;
         const maxContext = 200000; // Approximate max context for Claude
-        // Use the session's token count if available
-        const currentTokens = this.lastTokenCount;
-        if (currentTokens === 0)
-            return false; // Can't determine, don't skip
-        const usagePercent = (currentTokens / maxContext) * 100;
-        if (usagePercent < thresholdPercent) {
-            this.log(`Skip-clear optimization: ${usagePercent.toFixed(1)}% < ${thresholdPercent}% threshold`);
-            this.logAction('optimization', `Skipping /clear (${usagePercent.toFixed(1)}% context used)`);
-            return true;
+        const skip = shouldSkipClear(this.lastTokenCount, thresholdPercent, maxContext);
+        if (skip) {
+            const usagePercent = ((this.lastTokenCount / maxContext) * 100).toFixed(1);
+            this.log(`Skip-clear optimization: ${usagePercent}% < ${thresholdPercent}% threshold`);
+            this.logAction('optimization', `Skipping /clear (${usagePercent}% context used)`);
         }
-        return false;
+        return skip;
     }
-    // ========== P2-004: Cycle Metrics Methods ==========
+    // ========== P2-004: Cycle Metrics (delegated to RespawnCycleMetricsTracker) ==========
     /**
      * Start tracking metrics for a new cycle.
      * Called when a respawn cycle begins.
@@ -2474,28 +2236,16 @@ export class RespawnController extends EventEmitter {
     startCycleMetrics(idleReason) {
         if (!this.config.trackCycleMetrics)
             return;
-        const now = Date.now();
-        this.currentCycleMetrics = {
-            cycleId: `${this.session.id}:${this.cycleCount}`,
-            sessionId: this.session.id,
-            cycleNumber: this.cycleCount,
-            startedAt: now,
-            idleReason,
-            idleDetectionMs: now - this.idleDetectionStartTime,
-            stepsCompleted: [],
-            clearSkipped: false,
-            tokenCountAtStart: this.lastTokenCount,
-            completionConfirmMsUsed: this.getAdaptiveCompletionConfirmMs(),
-        };
+        this.cycleMetrics.startCycle(this.session.id, this.cycleCount, idleReason, this.idleDetectionStartTime, this.lastTokenCount, this.getAdaptiveCompletionConfirmMs());
     }
     /**
      * Record a completed step in the current cycle.
      * @param step - Name of the step (e.g., 'update', 'clear', 'init')
      */
     recordCycleStep(step) {
-        if (!this.config.trackCycleMetrics || !this.currentCycleMetrics)
+        if (!this.config.trackCycleMetrics)
             return;
-        this.currentCycleMetrics.stepsCompleted?.push(step);
+        this.cycleMetrics.recordStep(step);
     }
     /**
      * Complete the current cycle metrics with outcome.
@@ -2505,78 +2255,23 @@ export class RespawnController extends EventEmitter {
      * @param errorMessage - Optional error message if outcome is 'error'
      */
     completeCycleMetrics(outcome, errorMessage) {
-        if (!this.config.trackCycleMetrics || !this.currentCycleMetrics)
+        if (!this.config.trackCycleMetrics)
             return;
-        const now = Date.now();
-        const metrics = {
-            ...this.currentCycleMetrics,
-            completedAt: now,
-            durationMs: now - (this.currentCycleMetrics.startedAt ?? now),
-            outcome,
-            errorMessage,
-            tokenCountAtEnd: this.lastTokenCount,
-        };
-        // Add to recent metrics
-        this.recentCycleMetrics.push(metrics);
-        if (this.recentCycleMetrics.length > RespawnController.MAX_CYCLE_METRICS_IN_MEMORY) {
-            this.recentCycleMetrics.shift();
-        }
-        // Record timing data for adaptive timing
-        this.recordTimingData(metrics.idleDetectionMs, metrics.durationMs);
-        // Update aggregate metrics
-        this.updateAggregateMetrics(metrics);
-        // Clear current cycle
-        this.currentCycleMetrics = null;
-        this.log(`Cycle #${metrics.cycleNumber} metrics: ${outcome}, duration=${metrics.durationMs}ms, idle_detection=${metrics.idleDetectionMs}ms`);
-    }
-    /**
-     * Update aggregate metrics with a new cycle's data.
-     * @param metrics - The completed cycle metrics
-     */
-    updateAggregateMetrics(metrics) {
-        const agg = this.aggregateMetrics;
-        agg.totalCycles++;
-        switch (metrics.outcome) {
-            case 'success':
-                agg.successfulCycles++;
-                break;
-            case 'stuck_recovery':
-                agg.stuckRecoveryCycles++;
-                break;
-            case 'blocked':
-                agg.blockedCycles++;
-                break;
-            case 'error':
-                agg.errorCycles++;
-                break;
-            case 'cancelled':
-                // Cancelled cycles don't count towards any specific category
-                // but are still counted in totalCycles
-                break;
-            default:
-                assertNever(metrics.outcome, `Unhandled CycleOutcome: ${metrics.outcome}`);
-        }
-        // Recalculate averages using all recent metrics
-        const durations = this.recentCycleMetrics.map((m) => m.durationMs);
-        const idleTimes = this.recentCycleMetrics.map((m) => m.idleDetectionMs);
-        if (durations.length > 0) {
-            agg.avgCycleDurationMs = Math.round(durations.reduce((a, b) => a + b, 0) / durations.length);
-            agg.avgIdleDetectionMs = Math.round(idleTimes.reduce((a, b) => a + b, 0) / idleTimes.length);
-            // Calculate P90
-            const sortedDurations = [...durations].sort((a, b) => a - b);
-            const p90Index = Math.floor(sortedDurations.length * 0.9);
-            agg.p90CycleDurationMs = sortedDurations[p90Index];
+        const metrics = this.cycleMetrics.completeCycle(outcome, this.lastTokenCount, errorMessage);
+        if (metrics) {
+            // Record timing data for adaptive timing
+            if (this.config.adaptiveTimingEnabled) {
+                this.adaptiveTiming.recordTimingData(metrics.idleDetectionMs, metrics.durationMs);
+            }
+            this.log(`Cycle #${metrics.cycleNumber} metrics: ${outcome}, duration=${metrics.durationMs}ms, idle_detection=${metrics.idleDetectionMs}ms`);
         }
-        // Calculate success rate
-        agg.successRate = agg.totalCycles > 0 ? Math.round((agg.successfulCycles / agg.totalCycles) * 100) : 100;
-        agg.lastUpdatedAt = Date.now();
     }
     /**
      * Get aggregate metrics for monitoring.
      * @returns Copy of aggregate metrics
      */
     getAggregateMetrics() {
-        return { ...this.aggregateMetrics };
+        return this.cycleMetrics.getAggregate();
     }
     /**
      * Get recent cycle metrics for analysis.
@@ -2584,9 +2279,9 @@ export class RespawnController extends EventEmitter {
      * @returns Recent cycle metrics, newest first
      */
     getRecentCycleMetrics(limit = 20) {
-        return this.recentCycleMetrics.slice(-limit).reverse();
+        return this.cycleMetrics.getRecent(limit);
     }
-    // ========== P2-005: Health Score Methods ==========
+    // ========== P2-005: Health Score (delegated to respawn-health.ts) ==========
     /**
      * Calculate a comprehensive health score for the Ralph Loop system.
      * Aggregates multiple health signals into a single score (0-100).
@@ -2594,161 +2289,27 @@ export class RespawnController extends EventEmitter {
      * @returns Health score with component breakdown
      */
     calculateHealthScore() {
-        const now = Date.now();
-        const components = {
-            cycleSuccess: this.calculateCycleSuccessScore(),
-            circuitBreaker: this.calculateCircuitBreakerScore(),
-            iterationProgress: this.calculateIterationProgressScore(),
-            aiChecker: this.calculateAiCheckerScore(),
-            stuckRecovery: this.calculateStuckRecoveryScore(),
-        };
-        // Weighted average (cycle success is most important)
-        const weights = {
-            cycleSuccess: 0.35,
-            circuitBreaker: 0.2,
-            iterationProgress: 0.2,
-            aiChecker: 0.15,
-            stuckRecovery: 0.1,
-        };
-        const score = Math.round(components.cycleSuccess * weights.cycleSuccess +
-            components.circuitBreaker * weights.circuitBreaker +
-            components.iterationProgress * weights.iterationProgress +
-            components.aiChecker * weights.aiChecker +
-            components.stuckRecovery * weights.stuckRecovery);
-        // Determine status
-        let status;
-        if (score >= 90)
-            status = 'excellent';
-        else if (score >= 70)
-            status = 'good';
-        else if (score >= 50)
-            status = 'degraded';
-        else
-            status = 'critical';
-        // Generate recommendations
-        const recommendations = this.generateHealthRecommendations(components);
-        // Generate summary
-        const summary = this.generateHealthSummary(score, status, components);
-        return {
-            score,
-            status,
-            components,
-            summary,
-            recommendations,
-            calculatedAt: now,
-        };
-    }
-    /**
-     * Calculate score based on recent cycle success rate.
-     */
-    calculateCycleSuccessScore() {
-        if (this.aggregateMetrics.totalCycles === 0)
-            return 100; // No data = assume healthy
-        return this.aggregateMetrics.successRate;
-    }
-    /**
-     * Calculate score based on circuit breaker state.
-     */
-    calculateCircuitBreakerScore() {
         const tracker = this.session.ralphTracker;
-        if (!tracker)
-            return 100;
-        const cb = tracker.circuitBreakerStatus;
-        switch (cb.state) {
-            case 'CLOSED':
-                return 100;
-            case 'HALF_OPEN':
-                return 50;
-            case 'OPEN':
-                return 0;
-            default:
-                return 100;
-        }
-    }
-    /**
-     * Calculate score based on iteration progress.
-     */
-    calculateIterationProgressScore() {
-        const tracker = this.session.ralphTracker;
-        if (!tracker)
-            return 100;
-        const stallMetrics = tracker.getIterationStallMetrics();
-        const { stallDurationMs, warningThresholdMs, criticalThresholdMs } = stallMetrics;
-        if (stallDurationMs >= criticalThresholdMs)
-            return 0;
-        if (stallDurationMs >= warningThresholdMs)
-            return 30;
-        if (stallDurationMs >= warningThresholdMs / 2)
-            return 70;
-        return 100;
-    }
-    /**
-     * Calculate score based on AI checker health.
-     */
-    calculateAiCheckerScore() {
-        const state = this.aiChecker.getState();
-        if (state.status === 'disabled')
-            return 30;
-        if (state.status === 'cooldown')
-            return 70;
-        if (state.consecutiveErrors > 0)
-            return 50;
-        return 100;
-    }
-    /**
-     * Calculate score based on stuck-state recovery count.
-     */
-    calculateStuckRecoveryScore() {
-        const maxRecoveries = this.config.maxStuckRecoveries ?? 3;
-        if (this.stuckRecoveryCount === 0)
-            return 100;
-        if (this.stuckRecoveryCount >= maxRecoveries)
-            return 0;
-        return Math.round(100 - (this.stuckRecoveryCount / maxRecoveries) * 100);
-    }
-    /**
-     * Generate health recommendations based on component scores.
-     */
-    generateHealthRecommendations(components) {
-        const recommendations = [];
-        if (components.cycleSuccess < 70) {
-            recommendations.push('Cycle success rate is low. Check for recurring errors or stuck states.');
-        }
-        if (components.circuitBreaker < 50) {
-            recommendations.push('Circuit breaker is open or half-open. Review recent errors and consider manual reset.');
-        }
-        if (components.iterationProgress < 50) {
-            recommendations.push('Iteration progress has stalled. Check if Claude is stuck on a task.');
-        }
-        if (components.aiChecker < 50) {
-            recommendations.push('AI idle checker has errors. May need to check Claude CLI availability.');
-        }
-        if (components.stuckRecovery < 50) {
-            recommendations.push('Multiple stuck-state recoveries occurred. Consider increasing timeouts.');
-        }
-        if (recommendations.length === 0) {
-            recommendations.push('System is healthy. No action needed.');
-        }
-        return recommendations;
-    }
-    /**
-     * Generate a human-readable health summary.
-     */
-    generateHealthSummary(score, status, components) {
-        const lowest = Object.entries(components).reduce((min, [key, val]) => (val < min.val ? { key, val } : min), {
-            key: '',
-            val: 100,
-        });
-        if (status === 'excellent') {
-            return `Ralph Loop is operating excellently (${score}/100). All systems healthy.`;
-        }
-        if (status === 'good') {
-            return `Ralph Loop is operating well (${score}/100). Minor issues in ${lowest.key}.`;
-        }
-        if (status === 'degraded') {
-            return `Ralph Loop is degraded (${score}/100). Primary issue: ${lowest.key} (${lowest.val}/100).`;
-        }
-        return `Ralph Loop is in critical state (${score}/100). Immediate attention needed: ${lowest.key}.`;
+        const stallMetrics = tracker?.getIterationStallMetrics();
+        const aiState = this.aiChecker.getState();
+        const inputs = {
+            aggregateMetrics: this.cycleMetrics.getAggregate(),
+            circuitBreakerStatus: tracker?.circuitBreakerStatus ?? null,
+            iterationStallMetrics: stallMetrics
+                ? {
+                    stallDurationMs: stallMetrics.stallDurationMs,
+                    warningThresholdMs: stallMetrics.warningThresholdMs,
+                    criticalThresholdMs: stallMetrics.criticalThresholdMs,
+                }
+                : null,
+            aiCheckerState: {
+                status: aiState.status,
+                consecutiveErrors: aiState.consecutiveErrors,
+            },
+            stuckRecoveryCount: this.stuckRecoveryCount,
+            maxStuckRecoveries: this.config.maxStuckRecoveries ?? 3,
+        };
+        return calculateHealthScore(inputs);
     }
 }
 //# sourceMappingURL=respawn-controller.js.map