instar 0.7.51 → 0.7.52

package/dist/commands/server.js

@@ -36,7 +36,6 @@ 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.
@@ -647,31 +646,6 @@ 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) {
@@ -826,7 +800,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, watchdog });
+        const server = new AgentServer({ config, sessionManager, state, scheduler, telegram, relationships, feedback, dispatches, updateChecker, autoUpdater, autoDispatcher, quotaTracker, publisher, viewer, tunnel, evolution });
         await server.start();
         // Start tunnel AFTER server is listening
         if (tunnel) {

package/dist/core/AutoUpdater.js

@@ -54,11 +54,17 @@ export class AutoUpdater {
         if (this.interval)
             return;
         const intervalMs = this.config.checkIntervalMinutes * 60 * 1000;
-        // Warn if running from npx cache (auto-updates won't work properly)
+        // Detect npx cache — auto-apply and restart cause infinite loops when
+        // running from npx because the cache still resolves to the old version
+        // after npm installs the update. The restart finds the update again,
+        // applies it again, restarts again — forever, killing all sessions each time.
         const scriptPath = process.argv[1] || '';
-        if (scriptPath.includes('.npm/_npx') || scriptPath.includes('/_npx/')) {
-            console.warn('[AutoUpdater] WARNING: Running from npx cache. Auto-updates require a global install.\n' +
-                '[AutoUpdater] Run: npm install -g instar');
+        const runningFromNpx = scriptPath.includes('.npm/_npx') || scriptPath.includes('/_npx/');
+        if (runningFromNpx) {
+            this.config.autoApply = false;
+            this.config.autoRestart = false;
+            console.warn('[AutoUpdater] Running from npx cache. Auto-apply and auto-restart disabled to prevent restart loops.\n' +
+                '[AutoUpdater] Run: npm install -g instar  (then restart with: instar server start)');
         }
         console.log(`[AutoUpdater] Started (every ${this.config.checkIntervalMinutes}m, ` +
             `autoApply: ${this.config.autoApply}, autoRestart: ${this.config.autoRestart})`);
@@ -122,8 +128,7 @@ export class AutoUpdater {
             if (!this.config.autoApply) {
                 // Just notify — don't apply
                 await this.notify(`Update available: v${info.currentVersion} → v${info.latestVersion}\n\n` +
-                    (info.changeSummary ? `What changed:\n${info.changeSummary}\n\n` : '') +
-                    `Details: ${info.changelogUrl || 'https://github.com/SageMindAI/instar/releases'}\n\n` +
+                    (info.changeSummary ? `Changes: ${info.changeSummary}\n\n` : '') +
                     `Auto-apply is disabled. Apply manually:\n` +
                     `curl -X POST http://localhost:${this.getPort()}/updates/apply`);
                 return;
@@ -148,19 +153,13 @@ export class AutoUpdater {
             console.log(`[AutoUpdater] Updated: v${result.previousVersion} → v${result.newVersion}`);
             // Step 5: Notify via Telegram
             const restartNote = result.restartNeeded && this.config.autoRestart
-                ? '\nServer is restarting now...'
+                ? 'Server is restarting now...'
                 : result.restartNeeded
-                    ? '\nA server restart is needed to use the new version.'
+                    ? 'A server restart is needed to use the new version.'
                     : '';
-            const changeSummary = info.changeSummary
-                ? `What changed:\n${info.changeSummary}\n`
-                : '';
-            const detailsUrl = info.changelogUrl || 'https://github.com/SageMindAI/instar/releases';
             await this.notify(`Updated: v${result.previousVersion} → v${result.newVersion}\n\n` +
-                changeSummary +
-                `Details: ${detailsUrl}\n` +
-                restartNote +
-                `\n\nTo disable auto-updates, set "autoApply": false in .instar/config.json under "updates".`);
+                (info.changeSummary ? `What changed:\n${info.changeSummary}\n\n` : '') +
+                restartNote);
             // Step 6: Self-restart if needed and configured
             if (result.restartNeeded && this.config.autoRestart) {
                 // Brief delay to let the Telegram notification send

package/dist/core/SessionManager.d.ts

@@ -68,12 +68,6 @@ 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,20 +297,6 @@ 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.
@@ -478,25 +464,35 @@ export class SessionManager extends EventEmitter {
         const exactTarget = `=${tmuxSession}:`;
         try {
             if (text.includes('\n')) {
-                // Multi-line: pipe into tmux load-buffer via stdin, then paste into pane.
+                // Multi-line: write to temp file, load into tmux buffer, paste into pane.
                 // This avoids newlines being treated as Enter keypresses which would
                 // fragment the message into multiple Claude prompts.
-                // 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,
-                });
+                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 */ }
+                }
             }
             else {
                 // Single-line: simple send-keys

package/dist/core/UpdateChecker.d.ts

@@ -60,8 +60,7 @@ export declare class UpdateChecker {
         updatedAt: string;
     } | null;
     /**
-     * Fetch human-readable changelog from GitHub releases, falling back to
-     * recent commit messages if no release exists for this version.
+     * Fetch human-readable changelog from GitHub releases.
      */
     fetchChangelog(version: string): Promise<string | undefined>;
     /**

package/dist/core/UpdateChecker.js

@@ -226,11 +226,9 @@ export class UpdateChecker {
         }
     }
     /**
-     * Fetch human-readable changelog from GitHub releases, falling back to
-     * recent commit messages if no release exists for this version.
+     * Fetch human-readable changelog from GitHub releases.
      */
     async fetchChangelog(version) {
-        // Try GitHub release first
         try {
             const tag = version.startsWith('v') ? version : `v${version}`;
             const response = await fetch(`${GITHUB_RELEASES_URL}/tags/${tag}`, {
@@ -240,41 +238,16 @@ export class UpdateChecker {
                 },
                 signal: AbortSignal.timeout(10000),
             });
-            if (response.ok) {
-                const release = await response.json();
-                if (release.body) {
-                    const summary = release.body.slice(0, 500);
-                    return summary.length < release.body.length ? summary + '...' : summary;
-                }
-                if (release.name)
-                    return release.name;
-            }
-        }
-        catch {
-            // Non-critical — try commit fallback
-        }
-        // Fallback: fetch recent commits from GitHub
-        try {
-            const response = await fetch('https://api.github.com/repos/SageMindAI/instar/commits?per_page=5', {
-                headers: {
-                    'Accept': 'application/vnd.github.v3+json',
-                    'User-Agent': 'instar-update-checker',
-                },
-                signal: AbortSignal.timeout(10000),
-            });
-            if (response.ok) {
-                const commits = await response.json();
-                if (commits.length > 0) {
-                    const lines = commits
-                        .map(c => {
-                        // Take first line of commit message only
-                        const firstLine = c.commit.message.split('\n')[0];
-                        return `• ${firstLine}`;
-                    })
-                        .join('\n');
-                    return `Recent changes:\n${lines}`;
-                }
+            if (!response.ok)
+                return undefined;
+            const release = await response.json();
+            if (release.body) {
+                // Truncate to first 500 chars for concise summary
+                const summary = release.body.slice(0, 500);
+                return summary.length < release.body.length ? summary + '...' : summary;
             }
+            if (release.name)
+                return release.name;
         }
         catch {
             // Non-critical

package/dist/core/types.d.ts

@@ -712,14 +712,6 @@ 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/monitoring/HealthChecker.d.ts

@@ -7,15 +7,13 @@
 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, watchdog?: SessionWatchdog | null);
+    constructor(config: InstarConfig, sessionManager: SessionManager, scheduler?: JobScheduler | null);
     /**
      * Run all health checks and return aggregated status.
      */

package/dist/monitoring/HealthChecker.js

@@ -11,14 +11,12 @@ export class HealthChecker {
     config;
     sessionManager;
     scheduler;
-    watchdog;
     checkInterval = null;
     lastStatus = null;
-    constructor(config, sessionManager, scheduler = null, watchdog = null) {
+    constructor(config, sessionManager, scheduler = null) {
         this.config = config;
         this.sessionManager = sessionManager;
         this.scheduler = scheduler;
-        this.watchdog = watchdog;
     }
     /**
      * Run all health checks and return aggregated status.
@@ -32,17 +30,6 @@ 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/server/AgentServer.d.ts

@@ -21,7 +21,6 @@ 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;
@@ -44,7 +43,6 @@ export declare class AgentServer {
         viewer?: PrivateViewer;
         tunnel?: TunnelManager;
         evolution?: EvolutionManager;
-        watchdog?: SessionWatchdog;
     });
     /**
      * Start the HTTP server.

package/dist/server/AgentServer.js

@@ -39,7 +39,6 @@ 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,7 +21,6 @@ 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;
@@ -39,7 +38,6 @@ 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

@@ -8,6 +8,7 @@ import { Router } from 'express';
 import { execFileSync } from 'node:child_process';
 import { createHash, timingSafeEqual } from 'node:crypto';
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import { rateLimiter, signViewPath } from './middleware.js';
 // Validation patterns for route parameters
@@ -64,7 +65,6 @@ export function createRoutes(ctx) {
                 heapTotal: Math.round(mem.heapTotal / 1024 / 1024),
             };
             // System-wide memory state
-            const os = require('node:os');
             const totalMem = os.totalmem();
             const freeMem = os.freemem();
             base.systemMemory = {
@@ -1695,27 +1695,6 @@ 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.51",
+  "version": "0.7.52",
   "description": "Persistent autonomy infrastructure for AI agents",
   "type": "module",
   "main": "dist/index.js",

package/.vercel/README.txt

@@ -1,11 +0,0 @@
-> Why do I have a folder named ".vercel" in my project?
-The ".vercel" folder is created when you link a directory to a Vercel project.
-
-> What does the "project.json" file contain?
-The "project.json" file contains:
-- The ID of the Vercel project that you linked ("projectId")
-- The ID of the user or team your Vercel project is owned by ("orgId")
-
-> Should I commit the ".vercel" folder?
-No, you should not share the ".vercel" folder with anyone.
-Upon creation, it will be automatically added to your ".gitignore" file.

package/.vercel/project.json

@@ -1 +0,0 @@
-{"projectId":"prj_evM5LcItYL3IAmw8zNvEPGrHeaya","orgId":"team_dHctwIDcV3X9ydapQlCPHFGI","projectName":"claude-agent-kit"}

package/dist/monitoring/SessionWatchdog.d.ts

@@ -1,83 +0,0 @@
-/**
- * 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

@@ -1,326 +0,0 @@
-/**
- * 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