instar 0.7.50 → 0.7.51

package/dist/commands/server.js

@@ -36,6 +36,7 @@ import { QuotaTracker } from '../monitoring/QuotaTracker.js';
 import { AccountSwitcher } from '../monitoring/AccountSwitcher.js';
 import { QuotaNotifier } from '../monitoring/QuotaNotifier.js';
 import { classifySessionDeath } from '../monitoring/QuotaExhaustionDetector.js';
+import { SessionWatchdog } from '../monitoring/SessionWatchdog.js';
 import { installAutoStart } from './setup.js';
 /**
  * Check if autostart is installed for this project.
@@ -646,6 +647,31 @@ export async function startServer(options) {
                 scheduler.notifyJobComplete(session.id, session.tmuxSession);
             });
         }
+        // Session Watchdog — auto-remediation for stuck commands
+        let watchdog;
+        if (config.monitoring.watchdog?.enabled) {
+            watchdog = new SessionWatchdog(config, sessionManager, state);
+            watchdog.on('intervention', (event) => {
+                if (telegram) {
+                    const topicId = telegram.getTopicForSession(event.sessionName);
+                    if (topicId) {
+                        const levelNames = ['Monitoring', 'Ctrl+C', 'SIGTERM', 'SIGKILL', 'Kill Session'];
+                        const levelName = levelNames[event.level] || `Level ${event.level}`;
+                        telegram.sendToTopic(topicId, `🔧 Watchdog [${levelName}]: ${event.action}\nStuck: \`${event.stuckCommand.slice(0, 60)}\``).catch(() => { });
+                    }
+                }
+            });
+            watchdog.on('recovery', (sessionName, fromLevel) => {
+                if (telegram) {
+                    const topicId = telegram.getTopicForSession(sessionName);
+                    if (topicId) {
+                        telegram.sendToTopic(topicId, `✅ Watchdog: session recovered (was at escalation level ${fromLevel})`).catch(() => { });
+                    }
+                }
+            });
+            watchdog.start();
+            console.log(pc.green('  Session Watchdog enabled'));
+        }
         // Set up feedback and update checking
         let feedback;
         if (config.feedback) {
@@ -800,7 +826,7 @@ export async function startServer(options) {
             }
         });
         sleepWakeDetector.start();
-        const server = new AgentServer({ config, sessionManager, state, scheduler, telegram, relationships, feedback, dispatches, updateChecker, autoUpdater, autoDispatcher, quotaTracker, publisher, viewer, tunnel, evolution });
+        const server = new AgentServer({ config, sessionManager, state, scheduler, telegram, relationships, feedback, dispatches, updateChecker, autoUpdater, autoDispatcher, quotaTracker, publisher, viewer, tunnel, evolution, watchdog });
         await server.start();
         // Start tunnel AFTER server is listening
         if (tunnel) {

package/dist/core/SessionManager.d.ts

@@ -68,6 +68,12 @@ export declare class SessionManager extends EventEmitter {
      * Send input to a running tmux session.
      */
     sendInput(tmuxSession: string, input: string): boolean;
+    /**
+     * Send a tmux key sequence (without -l literal flag).
+     * Use for special keys like 'C-c' (Ctrl+C), 'Enter', 'Escape'.
+     * Unlike sendInput() which uses -l (literal), this sends key names directly.
+     */
+    sendKey(tmuxSession: string, key: string): boolean;
     /**
      * List all sessions that are currently running.
      * Pure filter — does not mutate state. The monitor tick handles lifecycle transitions.

package/dist/core/SessionManager.js

@@ -297,6 +297,20 @@ export class SessionManager extends EventEmitter {
             return false;
         }
     }
+    /**
+     * Send a tmux key sequence (without -l literal flag).
+     * Use for special keys like 'C-c' (Ctrl+C), 'Enter', 'Escape'.
+     * Unlike sendInput() which uses -l (literal), this sends key names directly.
+     */
+    sendKey(tmuxSession, key) {
+        try {
+            execFileSync(this.config.tmuxPath, ['send-keys', '-t', `=${tmuxSession}:`, key], { encoding: 'utf-8', timeout: 5000 });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
     /**
      * List all sessions that are currently running.
      * Pure filter — does not mutate state. The monitor tick handles lifecycle transitions.
@@ -464,35 +478,25 @@ export class SessionManager extends EventEmitter {
         const exactTarget = `=${tmuxSession}:`;
         try {
             if (text.includes('\n')) {
-                // Multi-line: write to temp file, load into tmux buffer, paste into pane.
+                // Multi-line: pipe into tmux load-buffer via stdin, then paste into pane.
                 // This avoids newlines being treated as Enter keypresses which would
                 // fragment the message into multiple Claude prompts.
-                const tmpDir = path.join('/tmp', 'instar-inject');
-                fs.mkdirSync(tmpDir, { recursive: true });
-                const tmpPath = path.join(tmpDir, `msg-${Date.now()}-${process.pid}.txt`);
-                fs.writeFileSync(tmpPath, text);
-                try {
-                    execFileSync(this.config.tmuxPath, ['load-buffer', tmpPath], {
-                        encoding: 'utf-8', timeout: 5000,
-                    });
-                    execFileSync(this.config.tmuxPath, ['paste-buffer', '-t', exactTarget, '-p'], {
-                        encoding: 'utf-8', timeout: 5000,
-                    });
-                    // Brief delay to let the terminal process the paste before sending Enter.
-                    // Without this, the Enter arrives before paste processing completes and
-                    // the message sits in the input buffer without being submitted.
-                    execFileSync('/bin/sleep', ['0.3'], { timeout: 2000 });
-                    // Send Enter to submit
-                    execFileSync(this.config.tmuxPath, ['send-keys', '-t', exactTarget, 'Enter'], {
-                        encoding: 'utf-8', timeout: 5000,
-                    });
-                }
-                finally {
-                    try {
-                        fs.unlinkSync(tmpPath);
-                    }
-                    catch { /* ignore */ }
-                }
+                // Uses stdin pipe (load-buffer -) instead of temp files to avoid
+                // macOS TCC "access data from other apps" permission prompts.
+                execFileSync(this.config.tmuxPath, ['load-buffer', '-'], {
+                    encoding: 'utf-8', timeout: 5000, input: text,
+                });
+                execFileSync(this.config.tmuxPath, ['paste-buffer', '-t', exactTarget, '-p'], {
+                    encoding: 'utf-8', timeout: 5000,
+                });
+                // Brief delay to let the terminal process the paste before sending Enter.
+                // Without this, the Enter arrives before paste processing completes and
+                // the message sits in the input buffer without being submitted.
+                execFileSync('/bin/sleep', ['0.3'], { timeout: 2000 });
+                // Send Enter to submit
+                execFileSync(this.config.tmuxPath, ['send-keys', '-t', exactTarget, 'Enter'], {
+                    encoding: 'utf-8', timeout: 5000,
+                });
             }
             else {
                 // Single-line: simple send-keys

package/dist/core/types.d.ts

@@ -712,6 +712,14 @@ export interface MonitoringConfig {
     memoryMonitoring: boolean;
     /** Health check interval in ms */
     healthCheckIntervalMs: number;
+    /** Session watchdog — auto-remediation for stuck commands */
+    watchdog?: {
+        enabled: boolean;
+        /** Seconds before a command is considered stuck (default: 180) */
+        stuckCommandSec?: number;
+        /** Poll interval in ms (default: 30000) */
+        pollIntervalMs?: number;
+    };
 }
 /** @deprecated Use InstarConfig instead */
 export type AgentKitConfig = InstarConfig;

package/dist/lifeline/TelegramLifeline.js

@@ -241,8 +241,23 @@ export class TelegramLifeline {
         // Forward to server if healthy
         if (this.supervisor.healthy) {
             const forwarded = await this.forwardToServer(topicId, text, msg);
-            if (forwarded)
+            if (forwarded) {
+                // Delivery confirmation — user knows message reached the server
+                await this.sendToTopic(topicId, '✓ Delivered');
                 return;
+            }
+            // Server appears healthy but forward failed — queue with accurate message
+            this.queue.enqueue({
+                id: `tg-${msg.message_id}`,
+                topicId,
+                text,
+                fromUserId: msg.from.id,
+                fromUsername: msg.from.username,
+                fromFirstName: msg.from.first_name,
+                timestamp: new Date(msg.date * 1000).toISOString(),
+            });
+            await this.sendToTopic(topicId, `Server is restarting. Your message has been queued (${this.queue.length} in queue). It will be delivered when the server recovers.`);
+            return;
         }
         // Server is down — queue the message
         this.queue.enqueue({

package/dist/monitoring/HealthChecker.d.ts

@@ -7,13 +7,15 @@
 import type { SessionManager } from '../core/SessionManager.js';
 import type { JobScheduler } from '../scheduler/JobScheduler.js';
 import type { HealthStatus, InstarConfig } from '../core/types.js';
+import type { SessionWatchdog } from './SessionWatchdog.js';
 export declare class HealthChecker {
     private config;
     private sessionManager;
     private scheduler;
+    private watchdog;
     private checkInterval;
     private lastStatus;
-    constructor(config: InstarConfig, sessionManager: SessionManager, scheduler?: JobScheduler | null);
+    constructor(config: InstarConfig, sessionManager: SessionManager, scheduler?: JobScheduler | null, watchdog?: SessionWatchdog | null);
     /**
      * Run all health checks and return aggregated status.
      */

package/dist/monitoring/HealthChecker.js

@@ -11,12 +11,14 @@ export class HealthChecker {
     config;
     sessionManager;
     scheduler;
+    watchdog;
     checkInterval = null;
     lastStatus = null;
-    constructor(config, sessionManager, scheduler = null) {
+    constructor(config, sessionManager, scheduler = null, watchdog = null) {
         this.config = config;
         this.sessionManager = sessionManager;
         this.scheduler = scheduler;
+        this.watchdog = watchdog;
     }
     /**
      * Run all health checks and return aggregated status.
@@ -30,6 +32,17 @@ export class HealthChecker {
         if (this.scheduler) {
             components.scheduler = this.checkScheduler();
         }
+        if (this.watchdog) {
+            const wdStatus = this.watchdog.getStatus();
+            const intervening = wdStatus.sessions.filter(s => s.escalation && s.escalation.level > 0);
+            components.watchdog = {
+                status: intervening.length > 0 ? 'degraded' : 'healthy',
+                message: intervening.length > 0
+                    ? `Intervening on ${intervening.length} session(s)`
+                    : `Monitoring${wdStatus.enabled ? '' : ' (disabled)'}`,
+                lastCheck: new Date().toISOString(),
+            };
+        }
         // Aggregate: worst component status becomes overall status
         const statuses = Object.values(components).map(c => c.status);
         let overall = 'healthy';

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

package/dist/server/AgentServer.d.ts

@@ -21,6 +21,7 @@ import type { TelegraphService } from '../publishing/TelegraphService.js';
 import type { PrivateViewer } from '../publishing/PrivateViewer.js';
 import type { TunnelManager } from '../tunnel/TunnelManager.js';
 import type { EvolutionManager } from '../core/EvolutionManager.js';
+import type { SessionWatchdog } from '../monitoring/SessionWatchdog.js';
 export declare class AgentServer {
     private app;
     private server;
@@ -43,6 +44,7 @@ export declare class AgentServer {
         viewer?: PrivateViewer;
         tunnel?: TunnelManager;
         evolution?: EvolutionManager;
+        watchdog?: SessionWatchdog;
     });
     /**
      * Start the HTTP server.

package/dist/server/AgentServer.js

@@ -39,6 +39,7 @@ export class AgentServer {
             viewer: options.viewer ?? null,
             tunnel: options.tunnel ?? null,
             evolution: options.evolution ?? null,
+            watchdog: options.watchdog ?? null,
             startTime: this.startTime,
         });
         this.app.use(routes);

package/dist/server/routes.d.ts

@@ -21,6 +21,7 @@ import type { TelegraphService } from '../publishing/TelegraphService.js';
 import type { PrivateViewer } from '../publishing/PrivateViewer.js';
 import type { TunnelManager } from '../tunnel/TunnelManager.js';
 import type { EvolutionManager } from '../core/EvolutionManager.js';
+import type { SessionWatchdog } from '../monitoring/SessionWatchdog.js';
 export interface RouteContext {
     config: InstarConfig;
     sessionManager: SessionManager;
@@ -38,6 +39,7 @@ export interface RouteContext {
     viewer: PrivateViewer | null;
     tunnel: TunnelManager | null;
     evolution: EvolutionManager | null;
+    watchdog: SessionWatchdog | null;
     startTime: Date;
 }
 export declare function createRoutes(ctx: RouteContext): Router;

package/dist/server/routes.js

@@ -1695,6 +1695,27 @@ export function createRoutes(ctx) {
         }
         res.json({ ok: true, id: req.params.id, status });
     });
+    // ── Watchdog ──────────────────────────────────────────────────
+    router.get('/watchdog/status', (req, res) => {
+        if (!ctx.watchdog) {
+            res.json({ enabled: false, sessions: [], interventionHistory: [] });
+            return;
+        }
+        res.json(ctx.watchdog.getStatus());
+    });
+    router.post('/watchdog/toggle', (req, res) => {
+        if (!ctx.watchdog) {
+            res.status(404).json({ error: 'Watchdog not configured' });
+            return;
+        }
+        const { enabled } = req.body;
+        if (typeof enabled !== 'boolean') {
+            res.status(400).json({ error: 'enabled (boolean) required' });
+            return;
+        }
+        ctx.watchdog.setEnabled(enabled);
+        res.json({ enabled: ctx.watchdog.isEnabled() });
+    });
     return router;
 }
 export function formatUptime(ms) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "instar",
-  "version": "0.7.50",
+  "version": "0.7.51",
   "description": "Persistent autonomy infrastructure for AI agents",
   "type": "module",
   "main": "dist/index.js",