instar 0.4.8 → 0.4.10

package/dist/cli.js

@@ -25,6 +25,7 @@ import { addUser, listUsers } from './commands/user.js';
 import { addJob, listJobs } from './commands/job.js';
 import pc from 'picocolors';
 import { getInstarVersion } from './core/Config.js';
+import { listInstances } from './core/PortRegistry.js';
 /**
  * Add or update Telegram configuration in the project config.
  */
@@ -405,5 +406,100 @@ jobCmd
     .description('List all jobs')
     .option('-d, --dir <path>', 'Project directory')
     .action(listJobs);
+// ── Lifeline ──────────────────────────────────────────────────────
+const lifelineCmd = program
+    .command('lifeline')
+    .description('Manage the Telegram lifeline (persistent Telegram connection)');
+lifelineCmd
+    .command('start')
+    .description('Start the Telegram lifeline (owns Telegram polling, supervises server)')
+    .option('-d, --dir <path>', 'Project directory')
+    .action(async (opts) => {
+    const { TelegramLifeline } = await import('./lifeline/TelegramLifeline.js');
+    try {
+        const lifeline = new TelegramLifeline(opts.dir);
+        await lifeline.start();
+    }
+    catch (err) {
+        console.error(pc.red(`Failed to start lifeline: ${err instanceof Error ? err.message : err}`));
+        process.exit(1);
+    }
+});
+lifelineCmd
+    .command('stop')
+    .description('Stop the Telegram lifeline')
+    .option('-d, --dir <path>', 'Project directory')
+    .action(async (opts) => {
+    // The lifeline runs in a tmux session — kill it
+    const { loadConfig, detectTmuxPath } = await import('./core/Config.js');
+    const config = loadConfig(opts.dir);
+    const tmuxPath = detectTmuxPath();
+    const sessionName = `${config.projectName}-lifeline`;
+    if (!tmuxPath) {
+        console.log(pc.red('tmux not found'));
+        process.exit(1);
+    }
+    try {
+        const { execFileSync } = await import('node:child_process');
+        execFileSync(tmuxPath, ['has-session', '-t', `=${sessionName}`], { stdio: 'ignore' });
+        execFileSync(tmuxPath, ['send-keys', '-t', `=${sessionName}:`, 'C-c'], { stdio: 'ignore' });
+        // Wait briefly for graceful shutdown
+        await new Promise(r => setTimeout(r, 3000));
+        try {
+            execFileSync(tmuxPath, ['kill-session', '-t', `=${sessionName}`], { stdio: 'ignore' });
+        }
+        catch { /* already dead */ }
+        console.log(pc.green(`Lifeline stopped (session: ${sessionName})`));
+    }
+    catch {
+        console.log(pc.yellow(`No lifeline running (no tmux session: ${sessionName})`));
+    }
+});
+lifelineCmd
+    .command('status')
+    .description('Check lifeline status')
+    .option('-d, --dir <path>', 'Project directory')
+    .action(async (opts) => {
+    const { loadConfig, detectTmuxPath } = await import('./core/Config.js');
+    const config = loadConfig(opts.dir);
+    const tmuxPath = detectTmuxPath();
+    const sessionName = `${config.projectName}-lifeline`;
+    if (!tmuxPath) {
+        console.log(pc.red('tmux not found'));
+        process.exit(1);
+    }
+    try {
+        const { execFileSync } = await import('node:child_process');
+        execFileSync(tmuxPath, ['has-session', '-t', `=${sessionName}`], { stdio: 'ignore' });
+        console.log(pc.green(`Lifeline is running (tmux session: ${sessionName})`));
+        console.log(`  Attach: tmux attach -t '=${sessionName}'`);
+    }
+    catch {
+        console.log(pc.yellow('Lifeline is not running'));
+        console.log(`  Start: instar lifeline start`);
+    }
+});
+// ── Instances ─────────────────────────────────────────────────────
+program
+    .command('instances')
+    .description('List all Instar instances running on this machine')
+    .action(async () => {
+    const instances = listInstances();
+    if (instances.length === 0) {
+        console.log(pc.dim('No Instar instances registered.'));
+        console.log(pc.dim('Start a server with: instar server start'));
+        return;
+    }
+    console.log(pc.bold(`\n  Instar Instances (${instances.length})\n`));
+    for (const entry of instances) {
+        const age = Math.round((Date.now() - new Date(entry.registeredAt).getTime()) / 60000);
+        const heartbeatAge = Math.round((Date.now() - new Date(entry.lastHeartbeat).getTime()) / 60000);
+        const alive = heartbeatAge < 3 ? pc.green('●') : pc.yellow('○');
+        console.log(`  ${alive} ${pc.bold(entry.projectName)}`);
+        console.log(`    Port: ${pc.cyan(String(entry.port))}  PID: ${entry.pid}  Up: ${age}m  Heartbeat: ${heartbeatAge}m ago`);
+        console.log(`    Dir:  ${pc.dim(entry.projectDir)}`);
+        console.log();
+    }
+});
 program.parse();
 //# sourceMappingURL=cli.js.map

package/dist/commands/init.js

@@ -32,6 +32,7 @@ import pc from 'picocolors';
 import { randomUUID } from 'node:crypto';
 import { detectTmuxPath, detectClaudePath, ensureStateDir } from '../core/Config.js';
 import { ensurePrerequisites } from '../core/Prerequisites.js';
+import { allocatePort } from '../core/PortRegistry.js';
 import { defaultIdentity } from '../scaffold/bootstrap.js';
 import { generateAgentMd, generateUserMd, generateMemoryMd, generateClaudeMd, } from '../scaffold/templates.js';
 /**
@@ -93,7 +94,20 @@ async function initFreshProject(projectName, options) {
     }
     // Create project directory
     fs.mkdirSync(projectDir, { recursive: true });
-    const port = options.port || 4040;
+    // Auto-allocate a port if not explicitly specified (multi-instance support)
+    let port;
+    if (options.port) {
+        port = options.port;
+    }
+    else {
+        try {
+            port = allocatePort(projectName);
+            console.log(`  ${pc.green('✓')} Auto-allocated port ${port} (from ~/.instar/port-registry.json)`);
+        }
+        catch {
+            port = 4040; // Fallback to default
+        }
+    }
     // Generate identity (non-interactive for init, interactive for setup)
     const identity = defaultIdentity(projectName);
     // Create .instar/ state directory
@@ -225,7 +239,19 @@ node_modules/
 async function initExistingProject(options) {
     const projectDir = path.resolve(options.dir || process.cwd());
     const projectName = options.name || path.basename(projectDir);
-    const port = options.port || 4040;
+    // Auto-allocate a port if not explicitly specified (multi-instance support)
+    let port;
+    if (options.port) {
+        port = options.port;
+    }
+    else {
+        try {
+            port = allocatePort(projectName);
+        }
+        catch {
+            port = 4040;
+        }
+    }
     console.log(pc.bold(`\nInitializing instar in: ${pc.cyan(projectDir)}`));
     console.log();
     // Check and install prerequisites
@@ -825,7 +851,11 @@ Types: \`bug\`, \`feature\`, \`improvement\`, \`question\`
         additions.push(`
 ## Telegram Relay
 
-When user input starts with \`[telegram:N]\`, the message came from a user via Telegram topic N. After responding, relay the response back:
+When user input starts with \`[telegram:N]\` (e.g., \`[telegram:26] hello\`), the message came from a user via Telegram topic N.
+
+**IMMEDIATE ACKNOWLEDGMENT (MANDATORY):** When you receive a Telegram message, your FIRST action — before reading files, searching code, or doing any work — must be sending a brief acknowledgment back. This confirms the message was received and you haven't stalled. Examples: "Got it, looking into this now." / "On it — checking the scheduler." / "Received, working on the sync." Then do the work, then send the full response.
+
+**Response relay:** After completing your work, relay your response back:
 
 \`\`\`bash
 cat <<'EOF' | .claude/scripts/telegram-reply.sh N
@@ -833,7 +863,7 @@ Your response text here
 EOF
 \`\`\`
 
-Strip the \`[telegram:N]\` prefix before interpreting the message. Only relay conversational text — not tool output.
+Strip the \`[telegram:N]\` prefix before interpreting the message. Respond naturally, then relay. Only relay your conversational text — not tool output or internal reasoning.
 `);
     }
     if (additions.length > 0) {

package/dist/commands/server.js

@@ -21,6 +21,7 @@ import { RelationshipManager } from '../core/RelationshipManager.js';
 import { FeedbackManager } from '../core/FeedbackManager.js';
 import { DispatchManager } from '../core/DispatchManager.js';
 import { UpdateChecker } from '../core/UpdateChecker.js';
+import { registerPort, unregisterPort, startHeartbeat } from '../core/PortRegistry.js';
 /**
  * Respawn a session for a topic, including thread history in the bootstrap.
  * This prevents "thread drift" where respawned sessions lose context.
@@ -177,11 +178,14 @@ function wireTelegramRouting(telegram, sessionManager) {
             if (sessionManager.isSessionAlive(targetSession)) {
                 console.log(`[telegram→session] Injecting into ${targetSession}: "${text.slice(0, 80)}"`);
                 sessionManager.injectTelegramMessage(targetSession, topicId, text);
+                // Delivery confirmation — let the user know the message reached the session
+                telegram.sendToTopic(topicId, `✓ Delivered`).catch(() => { });
                 // Track for stall detection
                 telegram.trackMessageInjection(topicId, targetSession, text);
             }
             else {
                 // Session died — respawn with thread history
+                telegram.sendToTopic(topicId, `🔄 Session restarting — message queued.`).catch(() => { });
                 respawnSessionForTopic(sessionManager, telegram, targetSession, topicId, text).catch(err => {
                     console.error(`[telegram→session] Respawn failed:`, err);
                 });
@@ -285,6 +289,16 @@ export async function startServer(options) {
         console.log();
         // Clean up stale Telegram temp files on startup
         cleanupTelegramTempFiles();
+        // Register this instance in the port registry (multi-instance support)
+        try {
+            registerPort(config.projectName, config.port, config.projectDir);
+            console.log(pc.green(`  Registered port ${config.port} for "${config.projectName}"`));
+        }
+        catch (err) {
+            console.log(pc.red(`  Port conflict: ${err instanceof Error ? err.message : err}`));
+            process.exit(1);
+        }
+        const stopHeartbeat = startHeartbeat(config.projectName);
         // Warn if no auth token configured — server allows unauthenticated access
         if (!config.authToken) {
             console.log(pc.yellow(pc.bold('  ⚠ WARNING: No auth token configured — all API endpoints are unauthenticated!')));
@@ -371,6 +385,8 @@ export async function startServer(options) {
         // Graceful shutdown
         const shutdown = async () => {
             console.log('\nShutting down...');
+            stopHeartbeat();
+            unregisterPort(config.projectName);
             scheduler?.stop();
             if (telegram)
                 await telegram.stop();

package/dist/commands/setup.js

@@ -894,7 +894,11 @@ Every user's feedback makes the platform better for everyone. Report issues when
         section += `
 ## Telegram Relay
 
-When user input starts with \`[telegram:N]\` (e.g., \`[telegram:26] hello\`), the message came from a user via Telegram topic N. **After responding**, relay your response back:
+When user input starts with \`[telegram:N]\` (e.g., \`[telegram:26] hello\`), the message came from a user via Telegram topic N.
+
+**IMMEDIATE ACKNOWLEDGMENT (MANDATORY):** When you receive a Telegram message, your FIRST action — before reading files, searching code, or doing any work — must be sending a brief acknowledgment back. This confirms the message was received and you haven't stalled. Examples: "Got it, looking into this now." / "On it — checking the scheduler." / "Received, working on the sync." Then do the work, then send the full response.
+
+**Response relay:** After completing your work, relay your response back:
 
 \`\`\`bash
 cat <<'EOF' | .claude/scripts/telegram-reply.sh N

package/dist/core/PortRegistry.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Port Registry — shared multi-instance port allocation and discovery.
+ *
+ * Maintains a machine-wide registry at ~/.instar/port-registry.json so
+ * multiple Instar installations can coexist without port conflicts.
+ *
+ * Features:
+ *   - Auto-allocate a free port from a configurable range
+ *   - Detect and reclaim stale entries (process no longer running)
+ *   - Discover all running Instar instances on this machine
+ *   - Atomic file writes to prevent corruption from concurrent access
+ */
+export interface PortEntry {
+    /** Project name (from config.json) */
+    projectName: string;
+    /** Allocated port */
+    port: number;
+    /** Process ID of the server */
+    pid: number;
+    /** Absolute path to the project directory */
+    projectDir: string;
+    /** When this entry was registered */
+    registeredAt: string;
+    /** Last heartbeat timestamp (updated periodically) */
+    lastHeartbeat: string;
+}
+export interface PortRegistry {
+    entries: PortEntry[];
+}
+/**
+ * Load the port registry from disk.
+ * Returns an empty registry if the file doesn't exist.
+ */
+export declare function loadPortRegistry(): PortRegistry;
+/**
+ * Remove stale entries where the process is no longer running.
+ * Returns the cleaned registry.
+ */
+export declare function cleanStaleEntries(registry: PortRegistry): PortRegistry;
+/**
+ * Register a port for a project. Overwrites any existing entry for the same project.
+ */
+export declare function registerPort(projectName: string, port: number, projectDir: string, pid?: number): void;
+/**
+ * Unregister a project's port entry.
+ */
+export declare function unregisterPort(projectName: string): void;
+/**
+ * Update the heartbeat for a project's entry.
+ */
+export declare function heartbeat(projectName: string): void;
+/**
+ * Allocate a free port from the range, avoiding conflicts.
+ * Returns the first available port not in use by another instance.
+ */
+export declare function allocatePort(projectName: string, rangeStart?: number, rangeEnd?: number): number;
+/**
+ * List all registered instances (after cleaning stale entries).
+ */
+export declare function listInstances(): PortEntry[];
+/**
+ * Get a specific project's entry.
+ */
+export declare function getEntry(projectName: string): PortEntry | null;
+/**
+ * Start a periodic heartbeat that updates the registry entry.
+ * Returns a cleanup function to stop the interval.
+ */
+export declare function startHeartbeat(projectName: string, intervalMs?: number): () => void;
+//# sourceMappingURL=PortRegistry.d.ts.map

package/dist/core/PortRegistry.js

@@ -0,0 +1,205 @@
+/**
+ * Port Registry — shared multi-instance port allocation and discovery.
+ *
+ * Maintains a machine-wide registry at ~/.instar/port-registry.json so
+ * multiple Instar installations can coexist without port conflicts.
+ *
+ * Features:
+ *   - Auto-allocate a free port from a configurable range
+ *   - Detect and reclaim stale entries (process no longer running)
+ *   - Discover all running Instar instances on this machine
+ *   - Atomic file writes to prevent corruption from concurrent access
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+const REGISTRY_DIR = path.join(os.homedir(), '.instar');
+const REGISTRY_PATH = path.join(REGISTRY_DIR, 'port-registry.json');
+const DEFAULT_PORT_RANGE_START = 4040;
+const DEFAULT_PORT_RANGE_END = 4099;
+const STALE_THRESHOLD_MS = 5 * 60 * 1000; // 5 minutes without heartbeat = stale
+/**
+ * Load the port registry from disk.
+ * Returns an empty registry if the file doesn't exist.
+ */
+export function loadPortRegistry() {
+    try {
+        if (!fs.existsSync(REGISTRY_PATH)) {
+            return { entries: [] };
+        }
+        const data = JSON.parse(fs.readFileSync(REGISTRY_PATH, 'utf-8'));
+        return { entries: Array.isArray(data.entries) ? data.entries : [] };
+    }
+    catch {
+        return { entries: [] };
+    }
+}
+/**
+ * Save the port registry to disk (atomic write).
+ */
+function savePortRegistry(registry) {
+    fs.mkdirSync(REGISTRY_DIR, { recursive: true });
+    const tmpPath = `${REGISTRY_PATH}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+    try {
+        fs.writeFileSync(tmpPath, JSON.stringify(registry, null, 2));
+        fs.renameSync(tmpPath, REGISTRY_PATH);
+    }
+    catch (err) {
+        try {
+            fs.unlinkSync(tmpPath);
+        }
+        catch { /* ignore */ }
+        throw err;
+    }
+}
+/**
+ * Check if a process with the given PID is running.
+ */
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0); // Signal 0 = check existence
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if a port is actually in use by trying to connect to it.
+ */
+async function isPortInUse(port) {
+    try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), 2000);
+        try {
+            const response = await fetch(`http://127.0.0.1:${port}/health`, {
+                signal: controller.signal,
+            });
+            return response.ok;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Remove stale entries where the process is no longer running.
+ * Returns the cleaned registry.
+ */
+export function cleanStaleEntries(registry) {
+    const cleaned = registry.entries.filter(entry => {
+        if (!isProcessAlive(entry.pid)) {
+            console.log(`[PortRegistry] Removing stale entry: ${entry.projectName} (port ${entry.port}, pid ${entry.pid} dead)`);
+            return false;
+        }
+        return true;
+    });
+    return { entries: cleaned };
+}
+/**
+ * Register a port for a project. Overwrites any existing entry for the same project.
+ */
+export function registerPort(projectName, port, projectDir, pid) {
+    let registry = loadPortRegistry();
+    registry = cleanStaleEntries(registry);
+    // Check for port conflicts with other projects
+    const conflict = registry.entries.find(e => e.port === port && e.projectName !== projectName);
+    if (conflict) {
+        throw new Error(`Port ${port} is already in use by "${conflict.projectName}" (pid ${conflict.pid}). ` +
+            `Change the port in .instar/config.json or use a different port.`);
+    }
+    // Remove existing entry for this project (will be replaced)
+    registry.entries = registry.entries.filter(e => e.projectName !== projectName);
+    const now = new Date().toISOString();
+    registry.entries.push({
+        projectName,
+        port,
+        pid: pid ?? process.pid,
+        projectDir,
+        registeredAt: now,
+        lastHeartbeat: now,
+    });
+    savePortRegistry(registry);
+}
+/**
+ * Unregister a project's port entry.
+ */
+export function unregisterPort(projectName) {
+    const registry = loadPortRegistry();
+    registry.entries = registry.entries.filter(e => e.projectName !== projectName);
+    savePortRegistry(registry);
+}
+/**
+ * Update the heartbeat for a project's entry.
+ */
+export function heartbeat(projectName) {
+    const registry = loadPortRegistry();
+    const entry = registry.entries.find(e => e.projectName === projectName);
+    if (entry) {
+        entry.lastHeartbeat = new Date().toISOString();
+        entry.pid = process.pid; // Update PID in case of restart
+        savePortRegistry(registry);
+    }
+}
+/**
+ * Allocate a free port from the range, avoiding conflicts.
+ * Returns the first available port not in use by another instance.
+ */
+export function allocatePort(projectName, rangeStart = DEFAULT_PORT_RANGE_START, rangeEnd = DEFAULT_PORT_RANGE_END) {
+    let registry = loadPortRegistry();
+    registry = cleanStaleEntries(registry);
+    // Check if this project already has a port
+    const existing = registry.entries.find(e => e.projectName === projectName);
+    if (existing) {
+        return existing.port;
+    }
+    // Find the first free port in range
+    const usedPorts = new Set(registry.entries.map(e => e.port));
+    for (let port = rangeStart; port <= rangeEnd; port++) {
+        if (!usedPorts.has(port)) {
+            return port;
+        }
+    }
+    throw new Error(`No free ports available in range ${rangeStart}-${rangeEnd}. ` +
+        `${registry.entries.length} Instar instances are running.`);
+}
+/**
+ * List all registered instances (after cleaning stale entries).
+ */
+export function listInstances() {
+    let registry = loadPortRegistry();
+    registry = cleanStaleEntries(registry);
+    savePortRegistry(registry);
+    return registry.entries;
+}
+/**
+ * Get a specific project's entry.
+ */
+export function getEntry(projectName) {
+    const registry = loadPortRegistry();
+    return registry.entries.find(e => e.projectName === projectName) ?? null;
+}
+/**
+ * Start a periodic heartbeat that updates the registry entry.
+ * Returns a cleanup function to stop the interval.
+ */
+export function startHeartbeat(projectName, intervalMs = 60_000) {
+    const interval = setInterval(() => {
+        try {
+            heartbeat(projectName);
+        }
+        catch (err) {
+            console.error(`[PortRegistry] Heartbeat failed: ${err}`);
+        }
+    }, intervalMs);
+    // Initial heartbeat
+    try {
+        heartbeat(projectName);
+    }
+    catch { /* ignore */ }
+    return () => clearInterval(interval);
+}
+//# sourceMappingURL=PortRegistry.js.map

package/dist/core/PostUpdateMigrator.js

@@ -131,7 +131,11 @@ This returns your full capability matrix: scripts, hooks, Telegram status, jobs,
             const section = `
 ## Telegram Relay
 
-When user input starts with \`[telegram:N]\` (e.g., \`[telegram:26] hello\`), the message came from a user via Telegram topic N. **After responding**, relay your response back:
+When user input starts with \`[telegram:N]\` (e.g., \`[telegram:26] hello\`), the message came from a user via Telegram topic N.
+
+**IMMEDIATE ACKNOWLEDGMENT (MANDATORY):** When you receive a Telegram message, your FIRST action — before reading files, searching code, or doing any work — must be sending a brief acknowledgment back. This confirms the message was received and you haven't stalled. Examples: "Got it, looking into this now." / "On it — checking the scheduler." / "Received, working on the sync." Then do the work, then send the full response.
+
+**Response relay:** After completing your work, relay your response back:
 
 \`\`\`bash
 cat <<'EOF' | .claude/scripts/telegram-reply.sh N
@@ -145,6 +149,20 @@ Strip the \`[telegram:N]\` prefix before interpreting the message. Respond natur
             patched = true;
             result.upgraded.push('CLAUDE.md: added Telegram Relay section');
         }
+        // Upgrade existing Telegram Relay sections to include mandatory acknowledgment
+        if (this.config.hasTelegram && content.includes('Telegram Relay') && !content.includes('IMMEDIATE ACKNOWLEDGMENT')) {
+            const ackBlock = `\n**IMMEDIATE ACKNOWLEDGMENT (MANDATORY):** When you receive a Telegram message, your FIRST action — before reading files, searching code, or doing any work — must be sending a brief acknowledgment back. This confirms the message was received and you haven't stalled. Examples: "Got it, looking into this now." / "On it — checking the scheduler." / "Received, working on the sync." Then do the work, then send the full response.\n`;
+            // Insert after the first line of the Telegram Relay section
+            const relayIdx = content.indexOf('## Telegram Relay');
+            if (relayIdx >= 0) {
+                const nextNewline = content.indexOf('\n\n', relayIdx + 18);
+                if (nextNewline >= 0) {
+                    content = content.slice(0, nextNewline + 1) + ackBlock + content.slice(nextNewline + 1);
+                    patched = true;
+                    result.upgraded.push('CLAUDE.md: added mandatory acknowledgment to Telegram Relay');
+                }
+            }
+        }
         if (patched) {
             try {
                 fs.writeFileSync(claudeMdPath, content);

package/dist/core/SessionManager.d.ts

@@ -42,7 +42,8 @@ export declare class SessionManager extends EventEmitter {
         maxDurationMinutes?: number;
     }): Promise<Session>;
     /**
-     * Check if a session is still running by checking tmux (sync version).
+     * Check if a session is still running by checking tmux AND verifying
+     * that the Claude process is running inside (not a zombie tmux pane).
      */
     isSessionAlive(tmuxSession: string): boolean;
     /**

package/dist/core/SessionManager.js

@@ -142,10 +142,30 @@ export class SessionManager extends EventEmitter {
         return session;
     }
     /**
-     * Check if a session is still running by checking tmux (sync version).
+     * Check if a session is still running by checking tmux AND verifying
+     * that the Claude process is running inside (not a zombie tmux pane).
      */
     isSessionAlive(tmuxSession) {
-        return this.tmuxSessionExists(tmuxSession);
+        if (!this.tmuxSessionExists(tmuxSession))
+            return false;
+        // Verify Claude process is running inside the tmux session
+        try {
+            const paneCmd = execFileSync(this.config.tmuxPath, ['display-message', '-t', `=${tmuxSession}:`, '-p', '#{pane_current_command}'], { encoding: 'utf-8', timeout: 5000 }).trim();
+            // Claude Code runs as 'claude' or 'node' process
+            if (paneCmd && (paneCmd.includes('claude') || paneCmd.includes('node'))) {
+                return true;
+            }
+            // If pane command is bash/zsh/sh, Claude may have exited — session is dead
+            if (paneCmd === 'bash' || paneCmd === 'zsh' || paneCmd === 'sh') {
+                return false;
+            }
+            // For any other command, assume alive (could be a Claude subprocess)
+            return true;
+        }
+        catch {
+            // If we can't check, fall back to tmux session existence
+            return true;
+        }
     }
     /**
      * Check if a session is still running by checking tmux (async version).

package/dist/lifeline/MessageQueue.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Message Queue — buffers Telegram messages when the server is down.
+ *
+ * Messages are persisted to disk so they survive lifeline restarts.
+ * When the server comes back, queued messages are replayed in order.
+ */
+export interface QueuedMessage {
+    id: string;
+    topicId: number;
+    text: string;
+    fromUserId: number;
+    fromUsername?: string;
+    fromFirstName: string;
+    timestamp: string;
+    voiceFile?: string;
+    photoPath?: string;
+}
+export declare class MessageQueue {
+    private queuePath;
+    private queue;
+    constructor(stateDir: string);
+    /**
+     * Add a message to the queue.
+     */
+    enqueue(msg: QueuedMessage): void;
+    /**
+     * Get all queued messages and clear the queue.
+     */
+    drain(): QueuedMessage[];
+    /**
+     * Peek at the queue without draining.
+     */
+    peek(): QueuedMessage[];
+    get length(): number;
+    private load;
+    private save;
+}
+//# sourceMappingURL=MessageQueue.d.ts.map