instar 0.7.49 → 0.7.51

package/dist/monitoring/MemoryPressureMonitor.js

@@ -0,0 +1,242 @@
+/**
+ * MemoryPressureMonitor - Detect and respond to system memory pressure.
+ *
+ * Platform-aware: uses macOS `vm_stat` or Linux `/proc/meminfo`.
+ * EventEmitter pattern consistent with Instar conventions.
+ *
+ * Thresholds:
+ *   - normal   (< 60%): all operations allowed
+ *   - warning  (60-75%): log trend, notify
+ *   - elevated (75-90%): restrict session spawning
+ *   - critical (90%+): block all spawns, alert
+ *
+ * Includes trend tracking via ring buffer + linear regression.
+ */
+import { EventEmitter } from 'node:events';
+import { execSync } from 'node:child_process';
+import * as fs from 'node:fs';
+const DEFAULT_THRESHOLDS = {
+    warning: 60,
+    elevated: 75,
+    critical: 90,
+};
+const RING_BUFFER_SIZE = 20;
+const TREND_WINDOW = 6;
+const PAGE_SIZE_BYTES = 16384; // macOS Apple Silicon
+// Adaptive intervals
+const INTERVALS = {
+    normal: 30_000,
+    warning: 15_000,
+    elevated: 10_000,
+    critical: 5_000,
+};
+export class MemoryPressureMonitor extends EventEmitter {
+    timeout = null;
+    currentState = 'normal';
+    stateChangedAt = new Date().toISOString();
+    lastChecked = new Date().toISOString();
+    lastPressurePercent = 0;
+    lastFreeGB = 0;
+    lastTotalGB = 0;
+    ringBuffer = [];
+    currentTrend = 'stable';
+    currentRatePerMin = 0;
+    thresholds;
+    baseIntervalMs;
+    constructor(config = {}) {
+        super();
+        this.thresholds = {
+            ...DEFAULT_THRESHOLDS,
+            ...config.thresholds,
+        };
+        this.baseIntervalMs = config.checkIntervalMs ?? 30_000;
+    }
+    start() {
+        if (this.timeout)
+            return;
+        this.check();
+        this.scheduleNext();
+        console.log(`[MemoryPressureMonitor] Started (platform: ${process.platform}, thresholds: ${JSON.stringify(this.thresholds)})`);
+    }
+    stop() {
+        if (this.timeout) {
+            clearTimeout(this.timeout);
+            this.timeout = null;
+        }
+    }
+    getState() {
+        return {
+            pressurePercent: this.lastPressurePercent,
+            freeGB: this.lastFreeGB,
+            totalGB: this.lastTotalGB,
+            state: this.currentState,
+            trend: this.currentTrend,
+            ratePerMin: this.currentRatePerMin,
+            lastChecked: this.lastChecked,
+            stateChangedAt: this.stateChangedAt,
+            platform: process.platform,
+        };
+    }
+    /**
+     * Can a new session be spawned?
+     */
+    canSpawnSession() {
+        switch (this.currentState) {
+            case 'normal':
+            case 'warning':
+                return { allowed: true };
+            case 'elevated':
+                return {
+                    allowed: false,
+                    reason: `Memory pressure elevated (${this.lastPressurePercent.toFixed(1)}%) — session spawn blocked`,
+                };
+            case 'critical':
+                return {
+                    allowed: false,
+                    reason: `Memory pressure critical (${this.lastPressurePercent.toFixed(1)}%) — all spawns blocked`,
+                };
+        }
+    }
+    scheduleNext() {
+        const intervalMs = INTERVALS[this.currentState] || this.baseIntervalMs;
+        this.timeout = setTimeout(() => {
+            this.check();
+            this.scheduleNext();
+        }, intervalMs);
+        this.timeout.unref(); // Don't prevent process exit
+    }
+    check() {
+        try {
+            const { pressurePercent, freeGB, totalGB } = this.readSystemMemory();
+            this.lastPressurePercent = pressurePercent;
+            this.lastFreeGB = freeGB;
+            this.lastTotalGB = totalGB;
+            this.lastChecked = new Date().toISOString();
+            // Ring buffer
+            this.ringBuffer.push({ timestamp: Date.now(), pressurePercent });
+            if (this.ringBuffer.length > RING_BUFFER_SIZE) {
+                this.ringBuffer.shift();
+            }
+            // Trend
+            const { trend, ratePerMin } = this.detectTrend();
+            this.currentTrend = trend;
+            this.currentRatePerMin = ratePerMin;
+            const newState = this.classifyState(pressurePercent);
+            if (newState !== this.currentState) {
+                const from = this.currentState;
+                this.currentState = newState;
+                this.stateChangedAt = new Date().toISOString();
+                console.log(`[MemoryPressureMonitor] ${from} -> ${newState} (${pressurePercent.toFixed(1)}%, ${freeGB.toFixed(1)}GB free, trend: ${trend})`);
+                this.emit('stateChange', { from, to: newState, state: this.getState() });
+            }
+        }
+        catch (error) {
+            console.error('[MemoryPressureMonitor] Check failed:', error);
+        }
+    }
+    classifyState(pressurePercent) {
+        if (pressurePercent >= this.thresholds.critical)
+            return 'critical';
+        if (pressurePercent >= this.thresholds.elevated)
+            return 'elevated';
+        if (pressurePercent >= this.thresholds.warning)
+            return 'warning';
+        return 'normal';
+    }
+    /**
+     * Read system memory — platform-aware.
+     */
+    readSystemMemory() {
+        if (process.platform === 'darwin') {
+            return this.parseVmStat();
+        }
+        else if (process.platform === 'linux') {
+            return this.parseProcMeminfo();
+        }
+        else {
+            // Fallback: use Node's process.memoryUsage (very rough)
+            const mem = process.memoryUsage();
+            const totalGB = require('os').totalmem() / (1024 ** 3);
+            const usedGB = mem.rss / (1024 ** 3);
+            return {
+                pressurePercent: (usedGB / totalGB) * 100,
+                freeGB: totalGB - usedGB,
+                totalGB,
+            };
+        }
+    }
+    /**
+     * macOS: parse vm_stat
+     */
+    parseVmStat() {
+        const output = execSync('vm_stat', { encoding: 'utf-8', timeout: 5000 });
+        const pageSizeMatch = output.match(/page size of (\d+) bytes/);
+        const pageSize = pageSizeMatch ? parseInt(pageSizeMatch[1], 10) : PAGE_SIZE_BYTES;
+        const parsePages = (label) => {
+            const match = output.match(new RegExp(`${label}:\\s+(\\d+)`));
+            return match ? parseInt(match[1], 10) : 0;
+        };
+        const freePages = parsePages('Pages free');
+        const activePages = parsePages('Pages active');
+        const inactivePages = parsePages('Pages inactive');
+        const wiredPages = parsePages('Pages wired down');
+        const compressorPages = parsePages('Pages occupied by compressor');
+        const purgeablePages = parsePages('Pages purgeable');
+        const totalPages = freePages + activePages + inactivePages + wiredPages + compressorPages;
+        const totalBytes = totalPages * pageSize;
+        const totalGB = totalBytes / (1024 ** 3);
+        const availablePages = freePages + inactivePages + purgeablePages;
+        const availableBytes = availablePages * pageSize;
+        const freeGB = availableBytes / (1024 ** 3);
+        const usedPages = totalPages - availablePages;
+        const pressurePercent = totalPages > 0 ? (usedPages / totalPages) * 100 : 0;
+        return { pressurePercent, freeGB, totalGB };
+    }
+    /**
+     * Linux: parse /proc/meminfo
+     */
+    parseProcMeminfo() {
+        const content = fs.readFileSync('/proc/meminfo', 'utf-8');
+        const parseKB = (key) => {
+            const match = content.match(new RegExp(`${key}:\\s+(\\d+)`));
+            return match ? parseInt(match[1], 10) : 0;
+        };
+        const totalKB = parseKB('MemTotal');
+        const availableKB = parseKB('MemAvailable') || (parseKB('MemFree') + parseKB('Buffers') + parseKB('Cached'));
+        const totalGB = totalKB / (1024 * 1024);
+        const freeGB = availableKB / (1024 * 1024);
+        const pressurePercent = totalKB > 0 ? ((totalKB - availableKB) / totalKB) * 100 : 0;
+        return { pressurePercent, freeGB, totalGB };
+    }
+    /**
+     * Linear regression over recent readings.
+     */
+    detectTrend() {
+        if (this.ringBuffer.length < 3) {
+            return { trend: 'stable', ratePerMin: 0 };
+        }
+        const readings = this.ringBuffer.slice(-TREND_WINDOW);
+        const n = readings.length;
+        const firstTs = readings[0].timestamp;
+        const xs = readings.map(r => (r.timestamp - firstTs) / 1000);
+        const ys = readings.map(r => r.pressurePercent);
+        const sumX = xs.reduce((a, b) => a + b, 0);
+        const sumY = ys.reduce((a, b) => a + b, 0);
+        const sumXY = xs.reduce((a, x, i) => a + x * ys[i], 0);
+        const sumX2 = xs.reduce((a, x) => a + x * x, 0);
+        const denom = n * sumX2 - sumX * sumX;
+        if (denom === 0)
+            return { trend: 'stable', ratePerMin: 0 };
+        const slope = (n * sumXY - sumX * sumY) / denom;
+        const ratePerMin = slope * 60;
+        let trend;
+        if (ratePerMin > 0.5)
+            trend = 'rising';
+        else if (ratePerMin < -0.5)
+            trend = 'falling';
+        else
+            trend = 'stable';
+        return { trend, ratePerMin };
+    }
+}
+//# sourceMappingURL=MemoryPressureMonitor.js.map

package/dist/monitoring/SessionWatchdog.d.ts

@@ -0,0 +1,83 @@
+/**
+ * SessionWatchdog — Auto-remediation for stuck Claude sessions (Instar port).
+ *
+ * Detects when a Claude session has a long-running bash command and escalates
+ * from gentle (Ctrl+C) to forceful (SIGKILL + session kill). Adapted from
+ * Dawn Server's SessionWatchdog for Instar's self-contained architecture.
+ *
+ * Escalation pipeline:
+ *   Level 0: Monitoring (default)
+ *   Level 1: Ctrl+C via tmux send-keys
+ *   Level 2: SIGTERM the stuck child PID
+ *   Level 3: SIGKILL the stuck child PID
+ *   Level 4: Kill tmux session
+ */
+import { EventEmitter } from 'node:events';
+import type { SessionManager } from '../core/SessionManager.js';
+import type { StateManager } from '../core/StateManager.js';
+import type { InstarConfig } from '../core/types.js';
+export declare enum EscalationLevel {
+    Monitoring = 0,
+    CtrlC = 1,
+    SigTerm = 2,
+    SigKill = 3,
+    KillSession = 4
+}
+interface EscalationState {
+    level: EscalationLevel;
+    levelEnteredAt: number;
+    stuckChildPid: number;
+    stuckCommand: string;
+    retryCount: number;
+}
+export interface InterventionEvent {
+    sessionName: string;
+    level: EscalationLevel;
+    action: string;
+    stuckCommand: string;
+    stuckPid: number;
+    timestamp: number;
+}
+export interface WatchdogEvents {
+    intervention: [event: InterventionEvent];
+    recovery: [sessionName: string, fromLevel: EscalationLevel];
+}
+export declare class SessionWatchdog extends EventEmitter {
+    private config;
+    private sessionManager;
+    private state;
+    private interval;
+    private escalationState;
+    private interventionHistory;
+    private enabled;
+    private running;
+    private stuckThresholdMs;
+    private pollIntervalMs;
+    constructor(config: InstarConfig, sessionManager: SessionManager, state: StateManager);
+    start(): void;
+    stop(): void;
+    setEnabled(enabled: boolean): void;
+    isEnabled(): boolean;
+    isManaging(sessionName: string): boolean;
+    getStatus(): {
+        enabled: boolean;
+        sessions: Array<{
+            name: string;
+            escalation: EscalationState | null;
+        }>;
+        interventionHistory: InterventionEvent[];
+    };
+    private poll;
+    private checkSession;
+    private handleEscalation;
+    private getClaudePid;
+    private getChildProcesses;
+    private isExcluded;
+    private parseElapsed;
+    private sendSignal;
+    private isProcessAlive;
+    private killTmuxSession;
+    private recordIntervention;
+}
+export {};
+//# sourceMappingURL=SessionWatchdog.d.ts.map

package/dist/monitoring/SessionWatchdog.js

@@ -0,0 +1,326 @@
+/**
+ * SessionWatchdog — Auto-remediation for stuck Claude sessions (Instar port).
+ *
+ * Detects when a Claude session has a long-running bash command and escalates
+ * from gentle (Ctrl+C) to forceful (SIGKILL + session kill). Adapted from
+ * Dawn Server's SessionWatchdog for Instar's self-contained architecture.
+ *
+ * Escalation pipeline:
+ *   Level 0: Monitoring (default)
+ *   Level 1: Ctrl+C via tmux send-keys
+ *   Level 2: SIGTERM the stuck child PID
+ *   Level 3: SIGKILL the stuck child PID
+ *   Level 4: Kill tmux session
+ */
+import { execSync } from 'node:child_process';
+import { EventEmitter } from 'node:events';
+export var EscalationLevel;
+(function (EscalationLevel) {
+    EscalationLevel[EscalationLevel["Monitoring"] = 0] = "Monitoring";
+    EscalationLevel[EscalationLevel["CtrlC"] = 1] = "CtrlC";
+    EscalationLevel[EscalationLevel["SigTerm"] = 2] = "SigTerm";
+    EscalationLevel[EscalationLevel["SigKill"] = 3] = "SigKill";
+    EscalationLevel[EscalationLevel["KillSession"] = 4] = "KillSession";
+})(EscalationLevel || (EscalationLevel = {}));
+// Processes that are long-running by design
+const EXCLUDED_PATTERNS = [
+    'playwright-mcp', 'playwright-persistent', '@playwright/mcp',
+    'chrome-native-host', 'claude-in-chrome-mcp', 'payments-mcp',
+    'mcp-remote', '/mcp/', '.mcp/', 'caffeinate', 'exa-mcp-server',
+];
+const EXCLUDED_PREFIXES = [
+    '/bin/zsh -c -l source',
+    '/bin/bash -c -l source',
+];
+// Escalation delays (ms to wait before advancing to next level)
+const ESCALATION_DELAYS = {
+    [EscalationLevel.Monitoring]: 0,
+    [EscalationLevel.CtrlC]: 0,
+    [EscalationLevel.SigTerm]: 15_000,
+    [EscalationLevel.SigKill]: 10_000,
+    [EscalationLevel.KillSession]: 5_000,
+};
+const DEFAULT_STUCK_THRESHOLD_MS = 180_000; // 3 minutes
+const DEFAULT_POLL_INTERVAL_MS = 30_000;
+const MAX_RETRIES = 2;
+export class SessionWatchdog extends EventEmitter {
+    config;
+    sessionManager;
+    state;
+    interval = null;
+    escalationState = new Map();
+    interventionHistory = [];
+    enabled = true;
+    running = false;
+    stuckThresholdMs;
+    pollIntervalMs;
+    constructor(config, sessionManager, state) {
+        super();
+        this.config = config;
+        this.sessionManager = sessionManager;
+        this.state = state;
+        const wdConfig = config.monitoring.watchdog;
+        this.stuckThresholdMs = (wdConfig?.stuckCommandSec ?? 180) * 1000;
+        this.pollIntervalMs = wdConfig?.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    }
+    start() {
+        if (this.interval)
+            return;
+        console.log(`[Watchdog] Starting (poll: ${this.pollIntervalMs / 1000}s, threshold: ${this.stuckThresholdMs / 1000}s)`);
+        this.interval = setInterval(() => this.poll(), this.pollIntervalMs);
+        setTimeout(() => this.poll(), 5000);
+    }
+    stop() {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = null;
+        }
+    }
+    setEnabled(enabled) {
+        this.enabled = enabled;
+        if (!enabled) {
+            this.escalationState.clear();
+        }
+    }
+    isEnabled() {
+        return this.enabled;
+    }
+    isManaging(sessionName) {
+        const s = this.escalationState.get(sessionName);
+        return s !== undefined && s.level > EscalationLevel.Monitoring;
+    }
+    getStatus() {
+        const runningSessions = this.sessionManager.listRunningSessions();
+        const sessions = runningSessions.map(s => ({
+            name: s.tmuxSession,
+            escalation: this.escalationState.get(s.tmuxSession) ?? null,
+        }));
+        return {
+            enabled: this.enabled,
+            sessions,
+            interventionHistory: this.interventionHistory.slice(-20),
+        };
+    }
+    // --- Core polling ---
+    async poll() {
+        if (!this.enabled || this.running)
+            return;
+        this.running = true;
+        try {
+            const sessions = this.sessionManager.listRunningSessions();
+            for (const session of sessions) {
+                try {
+                    this.checkSession(session.tmuxSession);
+                }
+                catch (err) {
+                    console.error(`[Watchdog] Error checking "${session.tmuxSession}":`, err);
+                }
+            }
+        }
+        finally {
+            this.running = false;
+        }
+    }
+    checkSession(tmuxSession) {
+        const existing = this.escalationState.get(tmuxSession);
+        if (existing && existing.level > EscalationLevel.Monitoring) {
+            this.handleEscalation(tmuxSession, existing);
+            return;
+        }
+        // Find Claude PID in the tmux session
+        const claudePid = this.getClaudePid(tmuxSession);
+        if (!claudePid)
+            return;
+        const children = this.getChildProcesses(claudePid);
+        const stuckChild = children.find(c => !this.isExcluded(c.command) && c.elapsedMs > this.stuckThresholdMs);
+        if (stuckChild) {
+            const state = {
+                level: EscalationLevel.CtrlC,
+                levelEnteredAt: Date.now(),
+                stuckChildPid: stuckChild.pid,
+                stuckCommand: stuckChild.command,
+                retryCount: existing?.retryCount ?? 0,
+            };
+            this.escalationState.set(tmuxSession, state);
+            console.log(`[Watchdog] "${tmuxSession}": stuck command (${Math.round(stuckChild.elapsedMs / 1000)}s): ` +
+                `${stuckChild.command.slice(0, 80)} — sending Ctrl+C`);
+            this.sessionManager.sendKey(tmuxSession, 'C-c');
+            this.recordIntervention(tmuxSession, EscalationLevel.CtrlC, 'Sent Ctrl+C', stuckChild);
+        }
+        else if (existing) {
+            this.escalationState.delete(tmuxSession);
+        }
+    }
+    handleEscalation(tmuxSession, state) {
+        const now = Date.now();
+        if (!this.isProcessAlive(state.stuckChildPid)) {
+            console.log(`[Watchdog] "${tmuxSession}": stuck process ${state.stuckChildPid} died — recovered`);
+            this.emit('recovery', tmuxSession, state.level);
+            this.escalationState.delete(tmuxSession);
+            return;
+        }
+        const timeInLevel = now - state.levelEnteredAt;
+        const nextLevel = state.level + 1;
+        if (nextLevel > EscalationLevel.KillSession) {
+            if (state.retryCount >= MAX_RETRIES) {
+                console.log(`[Watchdog] "${tmuxSession}": max retries reached — giving up`);
+                this.escalationState.delete(tmuxSession);
+                return;
+            }
+            state.level = EscalationLevel.CtrlC;
+            state.levelEnteredAt = now;
+            state.retryCount++;
+            this.sessionManager.sendKey(tmuxSession, 'C-c');
+            this.recordIntervention(tmuxSession, EscalationLevel.CtrlC, `Retry ${state.retryCount}: Sent Ctrl+C`, {
+                pid: state.stuckChildPid, command: state.stuckCommand, elapsedMs: 0,
+            });
+            return;
+        }
+        const delayForNext = ESCALATION_DELAYS[nextLevel] ?? 15_000;
+        if (timeInLevel < delayForNext)
+            return;
+        state.level = nextLevel;
+        state.levelEnteredAt = now;
+        const child = { pid: state.stuckChildPid, command: state.stuckCommand, elapsedMs: 0 };
+        switch (state.level) {
+            case EscalationLevel.SigTerm:
+                console.log(`[Watchdog] "${tmuxSession}": sending SIGTERM to ${state.stuckChildPid}`);
+                this.sendSignal(state.stuckChildPid, 'SIGTERM');
+                this.recordIntervention(tmuxSession, EscalationLevel.SigTerm, `SIGTERM ${state.stuckChildPid}`, child);
+                break;
+            case EscalationLevel.SigKill:
+                console.log(`[Watchdog] "${tmuxSession}": sending SIGKILL to ${state.stuckChildPid}`);
+                this.sendSignal(state.stuckChildPid, 'SIGKILL');
+                this.recordIntervention(tmuxSession, EscalationLevel.SigKill, `SIGKILL ${state.stuckChildPid}`, child);
+                break;
+            case EscalationLevel.KillSession:
+                console.log(`[Watchdog] "${tmuxSession}": killing tmux session`);
+                this.killTmuxSession(tmuxSession);
+                this.recordIntervention(tmuxSession, EscalationLevel.KillSession, 'Killed tmux session', child);
+                this.escalationState.delete(tmuxSession);
+                break;
+        }
+    }
+    // --- Process utilities (self-contained, no shared module) ---
+    getClaudePid(tmuxSession) {
+        try {
+            // Get pane PID
+            const panePidStr = execSync(`${this.config.sessions.tmuxPath} list-panes -t "=${tmuxSession}" -F "#{pane_pid}" 2>/dev/null`, { encoding: 'utf-8', timeout: 5000 }).trim().split('\n')[0];
+            if (!panePidStr)
+                return null;
+            const panePid = parseInt(panePidStr, 10);
+            if (isNaN(panePid))
+                return null;
+            // Find claude child
+            const claudePidStr = execSync(`pgrep -P ${panePid} -f claude 2>/dev/null | head -1`, { encoding: 'utf-8', timeout: 5000 }).trim();
+            if (!claudePidStr)
+                return null;
+            const pid = parseInt(claudePidStr, 10);
+            return isNaN(pid) ? null : pid;
+        }
+        catch {
+            return null;
+        }
+    }
+    getChildProcesses(pid) {
+        try {
+            const childPidsStr = execSync(`pgrep -P ${pid} 2>/dev/null`, { encoding: 'utf-8', timeout: 5000 }).trim();
+            if (!childPidsStr)
+                return [];
+            const childPids = childPidsStr.split('\n').filter(Boolean).join(',');
+            if (!childPids)
+                return [];
+            const output = execSync(`ps -o pid=,etime=,command= -p ${childPids} 2>/dev/null`, { encoding: 'utf-8', timeout: 5000 }).trim();
+            if (!output)
+                return [];
+            const results = [];
+            for (const line of output.split('\n')) {
+                const match = line.trim().match(/^(\d+)\s+([\d:.-]+)\s+(.+)$/);
+                if (!match)
+                    continue;
+                const childPid = parseInt(match[1], 10);
+                if (isNaN(childPid))
+                    continue;
+                results.push({
+                    pid: childPid,
+                    command: match[3],
+                    elapsedMs: this.parseElapsed(match[2]),
+                });
+            }
+            return results;
+        }
+        catch {
+            return [];
+        }
+    }
+    isExcluded(command) {
+        for (const pattern of EXCLUDED_PATTERNS) {
+            if (command.includes(pattern))
+                return true;
+        }
+        for (const prefix of EXCLUDED_PREFIXES) {
+            if (command.startsWith(prefix))
+                return true;
+        }
+        return false;
+    }
+    parseElapsed(elapsed) {
+        let days = 0;
+        let timePart = elapsed;
+        if (elapsed.includes('-')) {
+            const [d, t] = elapsed.split('-');
+            days = parseInt(d, 10);
+            timePart = t;
+        }
+        const parts = timePart.split(':').map(Number);
+        let seconds = 0;
+        if (parts.length === 3)
+            seconds = parts[0] * 3600 + parts[1] * 60 + parts[2];
+        else if (parts.length === 2)
+            seconds = parts[0] * 60 + parts[1];
+        else
+            seconds = parts[0];
+        return (days * 86400 + seconds) * 1000;
+    }
+    sendSignal(pid, signal) {
+        try {
+            process.kill(pid, signal);
+        }
+        catch (err) {
+            if (err.code !== 'ESRCH') {
+                console.error(`[Watchdog] Failed to send ${signal} to ${pid}:`, err);
+            }
+        }
+    }
+    isProcessAlive(pid) {
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    killTmuxSession(tmuxSession) {
+        try {
+            execSync(`${this.config.sessions.tmuxPath} kill-session -t "=${tmuxSession}" 2>/dev/null`, { timeout: 5000, stdio: 'ignore' });
+        }
+        catch { }
+    }
+    recordIntervention(sessionName, level, action, child) {
+        const event = {
+            sessionName,
+            level,
+            action,
+            stuckCommand: child.command.slice(0, 200),
+            stuckPid: child.pid,
+            timestamp: Date.now(),
+        };
+        this.interventionHistory.push(event);
+        if (this.interventionHistory.length > 50) {
+            this.interventionHistory = this.interventionHistory.slice(-50);
+        }
+        this.emit('intervention', event);
+    }
+}
+//# sourceMappingURL=SessionWatchdog.js.map