instar 0.7.49 → 0.7.50

package/.claude/skills/setup-wizard/skill.md

@@ -646,50 +646,19 @@ If Telegram was set up in Phase 3, install the relay script that lets Claude ses
 mkdir -p .claude/scripts
 ```
 
-Write `.claude/scripts/telegram-reply.sh`:
+**IMPORTANT: Do NOT write a custom telegram-reply.sh.** Instead, copy the canonical version from the instar package:
 
 ```bash
-#!/bin/bash
-# telegram-reply.sh — Send a message back to a Telegram topic via instar server.
-#
-# Usage:
-#   .claude/scripts/telegram-reply.sh TOPIC_ID "message text"
-#   echo "message text" | .claude/scripts/telegram-reply.sh TOPIC_ID
-#   cat <<'EOF' | .claude/scripts/telegram-reply.sh TOPIC_ID
-#   Multi-line message here
-#   EOF
-
-TOPIC_ID=$1
-shift
-
-if [ -z "$TOPIC_ID" ]; then
-  echo "Usage: telegram-reply.sh TOPIC_ID [message]" >&2
-  exit 1
-fi
-
-PORT=<PORT>
-
-# Get message from args or stdin
-if [ $# -gt 0 ]; then
-  MESSAGE="$*"
-else
-  MESSAGE=$(cat)
-fi
-
-if [ -z "$MESSAGE" ]; then
-  echo "No message provided" >&2
-  exit 1
-fi
-
-# Send via instar server API
-curl -s -X POST "http://localhost:${PORT}/telegram/topic/${TOPIC_ID}/send" \
-  -H 'Content-Type: application/json' \
-  -d "$(jq -n --arg text "$MESSAGE" '{text: $text}')" > /dev/null 2>&1
-
-echo "Sent $(echo "$MESSAGE" | wc -c | tr -d ' ') chars to topic $TOPIC_ID"
+cp "$(dirname "$(which instar 2>/dev/null || echo "$(npm root -g)/instar")")/templates/scripts/telegram-reply.sh" .claude/scripts/telegram-reply.sh 2>/dev/null
 ```
 
-Replace `<PORT>` with the actual server port. Then make it executable:
+If the copy fails (e.g., npx install), write the script using the template at `node_modules/instar/dist/templates/scripts/telegram-reply.sh` as the source. The key details:
+- **Endpoint**: `POST http://localhost:PORT/telegram/reply/TOPIC_ID` (NOT `/telegram/topic/TOPIC_ID/send`)
+- **Auth**: Must read authToken from `.instar/config.json` and include `Authorization: Bearer TOKEN` header
+- **JSON escaping**: Use python3 for proper JSON escaping, not jq (which may not be installed)
+- **Error reporting**: Do NOT pipe curl output to `/dev/null` — check the HTTP status code and report failures
+
+Then make it executable:
 
 ```bash
 chmod +x .claude/scripts/telegram-reply.sh

package/.vercel/README.txt

@@ -0,0 +1,11 @@
+> 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

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

package/dist/commands/server.js

@@ -9,6 +9,7 @@
  */
 import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import pc from 'picocolors';
 import { loadConfig, ensureStateDir, detectTmuxPath } from '../core/Config.js';
@@ -35,6 +36,24 @@ 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 { installAutoStart } from './setup.js';
+/**
+ * Check if autostart is installed for this project.
+ * Extracted from the CLI `autostart status` handler for programmatic use.
+ */
+function isAutostartInstalled(projectName) {
+    if (process.platform === 'darwin') {
+        const label = `ai.instar.${projectName}`;
+        const plistPath = path.join(os.homedir(), 'Library', 'LaunchAgents', `${label}.plist`);
+        return fs.existsSync(plistPath);
+    }
+    else if (process.platform === 'linux') {
+        const serviceName = `instar-${projectName}.service`;
+        const servicePath = path.join(os.homedir(), '.config', 'systemd', 'user', serviceName);
+        return fs.existsSync(servicePath);
+    }
+    return false;
+}
 /**
  * Respawn a session for a topic, including thread history in the bootstrap.
  * This prevents "thread drift" where respawned sessions lose context.
@@ -710,6 +729,77 @@ export async function startServer(options) {
             ...(config.evolution || {}),
         });
         console.log(pc.green('  Evolution system enabled'));
+        // Start MemoryPressureMonitor (platform-aware memory tracking)
+        const { MemoryPressureMonitor } = await import('../monitoring/MemoryPressureMonitor.js');
+        const memoryMonitor = new MemoryPressureMonitor({});
+        memoryMonitor.on('stateChange', ({ from, to, state: memState }) => {
+            // Gate scheduler spawning on memory pressure
+            if (scheduler && (to === 'elevated' || to === 'critical')) {
+                console.log(`[MemoryPressure] ${from} -> ${to} — scheduler should respect canSpawnSession()`);
+            }
+            // Alert via Telegram attention topic
+            if (telegram && to !== 'normal') {
+                const attentionTopicId = state.get('agent-attention-topic');
+                if (attentionTopicId) {
+                    telegram.sendToTopic(attentionTopicId, `Memory ${to}: ${memState.pressurePercent.toFixed(1)}% used, ${memState.freeGB.toFixed(1)}GB free (trend: ${memState.trend})`).catch(() => { });
+                }
+            }
+        });
+        memoryMonitor.start();
+        // Wire memory gate into scheduler
+        if (scheduler) {
+            const originalCanRun = scheduler.canRunJob;
+            scheduler.canRunJob = (priority) => {
+                // Check memory first
+                const memCheck = memoryMonitor.canSpawnSession();
+                if (!memCheck.allowed) {
+                    return false;
+                }
+                // Then check original gate (quota, etc.)
+                return originalCanRun(priority);
+            };
+        }
+        // Start CaffeinateManager (prevents macOS system sleep)
+        const { CaffeinateManager } = await import('../core/CaffeinateManager.js');
+        const caffeinateManager = new CaffeinateManager({ stateDir: config.stateDir });
+        caffeinateManager.start();
+        // Start SleepWakeDetector (re-validate sessions on wake)
+        const { SleepWakeDetector } = await import('../core/SleepWakeDetector.js');
+        const sleepWakeDetector = new SleepWakeDetector();
+        sleepWakeDetector.on('wake', async (event) => {
+            console.log(`[SleepWake] Wake detected after ~${event.sleepDurationSeconds}s sleep`);
+            // Re-validate tmux sessions
+            try {
+                const tmuxPath = detectTmuxPath();
+                if (tmuxPath) {
+                    const { execFileSync } = await import('child_process');
+                    const result = execFileSync(tmuxPath, ['list-sessions'], { encoding: 'utf-8', timeout: 5000 }).trim();
+                    console.log(`[SleepWake] tmux sessions after wake: ${result.split('\n').length}`);
+                }
+            }
+            catch {
+                console.warn('[SleepWake] tmux check failed after wake');
+            }
+            // Restart tunnel if configured
+            if (tunnel) {
+                try {
+                    await tunnel.stop();
+                    const tunnelUrl = await tunnel.start();
+                    console.log(`[SleepWake] Tunnel restarted: ${tunnelUrl}`);
+                }
+                catch (err) {
+                    console.error(`[SleepWake] Tunnel restart failed:`, err);
+                }
+            }
+            // Notify via Telegram attention topic
+            if (telegram) {
+                const attentionTopicId = state.get('agent-attention-topic');
+                if (attentionTopicId) {
+                    telegram.sendToTopic(attentionTopicId, `Wake detected after ~${event.sleepDurationSeconds}s sleep. Sessions re-validated.`).catch(() => { });
+                }
+            }
+        });
+        sleepWakeDetector.start();
         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
@@ -723,9 +813,33 @@ export async function startServer(options) {
                 console.log(pc.yellow(`  Server running locally without tunnel. Fix tunnel config and restart.`));
             }
         }
+        // Self-healing: ensure autostart is installed so the server always restarts
+        // This is a non-negotiable requirement — the user must always be able to reach their agent remotely.
+        // If autostart isn't installed, install it silently. The agent should never require human intervention
+        // to ensure its own resilience.
+        try {
+            const hasTelegram = !!telegram;
+            const autostartInstalled = isAutostartInstalled(config.projectName);
+            if (!autostartInstalled) {
+                const installed = installAutoStart(config.projectName, config.projectDir, hasTelegram);
+                if (installed) {
+                    console.log(pc.green(`  Auto-start self-healed: installed ${process.platform === 'darwin' ? 'LaunchAgent' : 'systemd service'}`));
+                }
+                else {
+                    console.log(pc.yellow(`  Auto-start not available on ${process.platform}`));
+                }
+            }
+        }
+        catch (err) {
+            // Non-critical — don't crash the server over autostart
+            console.error(`  Auto-start check failed: ${err instanceof Error ? err.message : err}`);
+        }
         // Graceful shutdown
         const shutdown = async () => {
             console.log('\nShutting down...');
+            memoryMonitor.stop();
+            caffeinateManager.stop();
+            sleepWakeDetector.stop();
             autoUpdater.stop();
             autoDispatcher?.stop();
             if (tunnel)

package/dist/core/AutoUpdater.js

@@ -122,7 +122,8 @@ 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 ? `Changes: ${info.changeSummary}\n\n` : '') +
+                    (info.changeSummary ? `What changed:\n${info.changeSummary}\n\n` : '') +
+                    `Details: ${info.changelogUrl || 'https://github.com/SageMindAI/instar/releases'}\n\n` +
                     `Auto-apply is disabled. Apply manually:\n` +
                     `curl -X POST http://localhost:${this.getPort()}/updates/apply`);
                 return;
@@ -147,13 +148,19 @@ 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
-                ? 'Server is restarting now...'
+                ? '\nServer is restarting now...'
                 : result.restartNeeded
-                    ? 'A server restart is needed to use the new version.'
+                    ? '\nA 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` +
-                (info.changeSummary ? `What changed:\n${info.changeSummary}\n\n` : '') +
-                restartNote);
+                changeSummary +
+                `Details: ${detailsUrl}\n` +
+                restartNote +
+                `\n\nTo disable auto-updates, set "autoApply": false in .instar/config.json under "updates".`);
             // 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/CaffeinateManager.d.ts

@@ -0,0 +1,50 @@
+/**
+ * CaffeinateManager - Prevent macOS system sleep for Instar server lifetime.
+ *
+ * Maintains a `caffeinate -s` child process that prevents system sleep.
+ * A watchdog verifies it's alive every 30s and restarts if dead.
+ * PID is written to <stateDir>/caffeinate.pid for crash recovery.
+ *
+ * Only activates on macOS (process.platform === 'darwin').
+ * Uses EventEmitter pattern consistent with Instar conventions.
+ */
+import { EventEmitter } from 'node:events';
+export interface CaffeinateManagerConfig {
+    /** State directory for PID file storage */
+    stateDir: string;
+}
+export interface CaffeinateStatus {
+    running: boolean;
+    pid: number | null;
+    startedAt: string | null;
+    restartCount: number;
+    lastWatchdogCheck: string;
+}
+export declare class CaffeinateManager extends EventEmitter {
+    private process;
+    private watchdogInterval;
+    private pid;
+    private startedAt;
+    private restartCount;
+    private lastWatchdogCheck;
+    private stopping;
+    private pidFile;
+    constructor(config: CaffeinateManagerConfig);
+    /**
+     * Start caffeinate and the watchdog.
+     * Only activates on macOS.
+     */
+    start(): void;
+    /**
+     * Stop caffeinate and the watchdog cleanly.
+     */
+    stop(): void;
+    getStatus(): CaffeinateStatus;
+    private spawnCaffeinate;
+    private killCaffeinate;
+    private watchdog;
+    private cleanupStale;
+    private writePidFile;
+    private removePidFile;
+}
+//# sourceMappingURL=CaffeinateManager.d.ts.map

package/dist/core/CaffeinateManager.js

@@ -0,0 +1,180 @@
+/**
+ * CaffeinateManager - Prevent macOS system sleep for Instar server lifetime.
+ *
+ * Maintains a `caffeinate -s` child process that prevents system sleep.
+ * A watchdog verifies it's alive every 30s and restarts if dead.
+ * PID is written to <stateDir>/caffeinate.pid for crash recovery.
+ *
+ * Only activates on macOS (process.platform === 'darwin').
+ * Uses EventEmitter pattern consistent with Instar conventions.
+ */
+import { EventEmitter } from 'node:events';
+import { spawn, execSync } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+const WATCHDOG_INTERVAL_MS = 30_000; // 30 seconds
+export class CaffeinateManager extends EventEmitter {
+    process = null;
+    watchdogInterval = null;
+    pid = null;
+    startedAt = null;
+    restartCount = 0;
+    lastWatchdogCheck = new Date().toISOString();
+    stopping = false;
+    pidFile;
+    constructor(config) {
+        super();
+        this.pidFile = path.join(config.stateDir, 'caffeinate.pid');
+    }
+    /**
+     * Start caffeinate and the watchdog.
+     * Only activates on macOS.
+     */
+    start() {
+        if (this.watchdogInterval)
+            return;
+        if (process.platform !== 'darwin') {
+            console.log('[CaffeinateManager] Not macOS — skipping sleep prevention');
+            return;
+        }
+        this.stopping = false;
+        this.cleanupStale();
+        this.spawnCaffeinate();
+        this.watchdogInterval = setInterval(() => this.watchdog(), WATCHDOG_INTERVAL_MS);
+        this.watchdogInterval.unref(); // Don't prevent process exit
+        console.log(`[CaffeinateManager] Started (watchdog: ${WATCHDOG_INTERVAL_MS / 1000}s)`);
+    }
+    /**
+     * Stop caffeinate and the watchdog cleanly.
+     */
+    stop() {
+        this.stopping = true;
+        if (this.watchdogInterval) {
+            clearInterval(this.watchdogInterval);
+            this.watchdogInterval = null;
+        }
+        this.killCaffeinate();
+        this.removePidFile();
+        console.log('[CaffeinateManager] Stopped');
+    }
+    getStatus() {
+        return {
+            running: this.process !== null && this.pid !== null,
+            pid: this.pid,
+            startedAt: this.startedAt,
+            restartCount: this.restartCount,
+            lastWatchdogCheck: this.lastWatchdogCheck,
+        };
+    }
+    spawnCaffeinate() {
+        try {
+            const proc = spawn('caffeinate', ['-s'], {
+                detached: true,
+                stdio: 'ignore',
+            });
+            proc.unref();
+            this.process = proc;
+            this.pid = proc.pid ?? null;
+            this.startedAt = new Date().toISOString();
+            this.writePidFile();
+            proc.on('exit', (code, signal) => {
+                if (!this.stopping) {
+                    console.warn(`[CaffeinateManager] caffeinate exited (code: ${code}, signal: ${signal})`);
+                    this.emit('died', { code, signal });
+                }
+                this.process = null;
+                this.pid = null;
+            });
+            proc.on('error', (err) => {
+                console.error('[CaffeinateManager] caffeinate spawn error:', err.message);
+                this.process = null;
+                this.pid = null;
+            });
+            console.log(`[CaffeinateManager] caffeinate spawned (PID: ${this.pid})`);
+            this.emit('started', { pid: this.pid });
+        }
+        catch (err) {
+            console.error('[CaffeinateManager] Failed to spawn caffeinate:', err);
+        }
+    }
+    killCaffeinate() {
+        if (this.pid) {
+            try {
+                process.kill(this.pid, 'SIGTERM');
+            }
+            catch {
+                // Already dead
+            }
+        }
+        this.process = null;
+        this.pid = null;
+    }
+    watchdog() {
+        this.lastWatchdogCheck = new Date().toISOString();
+        if (this.stopping)
+            return;
+        if (this.pid) {
+            try {
+                process.kill(this.pid, 0);
+                return; // Still alive
+            }
+            catch {
+                console.warn(`[CaffeinateManager] caffeinate PID ${this.pid} is dead`);
+                this.process = null;
+                this.pid = null;
+            }
+        }
+        this.restartCount++;
+        console.log(`[CaffeinateManager] Restarting caffeinate (restart #${this.restartCount})`);
+        this.spawnCaffeinate();
+        this.emit('restarted', { restartCount: this.restartCount });
+    }
+    cleanupStale() {
+        try {
+            if (fs.existsSync(this.pidFile)) {
+                const stalePid = parseInt(fs.readFileSync(this.pidFile, 'utf-8').trim(), 10);
+                if (!isNaN(stalePid) && stalePid > 0) {
+                    try {
+                        const cmdline = execSync(`ps -p ${stalePid} -o comm= 2>/dev/null`, {
+                            encoding: 'utf-8',
+                            timeout: 3000,
+                        }).trim();
+                        if (cmdline.includes('caffeinate')) {
+                            process.kill(stalePid, 'SIGTERM');
+                            console.log(`[CaffeinateManager] Killed stale caffeinate (PID: ${stalePid})`);
+                        }
+                    }
+                    catch {
+                        // Process doesn't exist
+                    }
+                }
+                this.removePidFile();
+            }
+        }
+        catch {
+            // PID file doesn't exist or can't be read
+        }
+    }
+    writePidFile() {
+        if (!this.pid)
+            return;
+        try {
+            fs.mkdirSync(path.dirname(this.pidFile), { recursive: true });
+            fs.writeFileSync(this.pidFile, String(this.pid));
+        }
+        catch (err) {
+            console.error('[CaffeinateManager] Failed to write PID file:', err);
+        }
+    }
+    removePidFile() {
+        try {
+            if (fs.existsSync(this.pidFile)) {
+                fs.unlinkSync(this.pidFile);
+            }
+        }
+        catch {
+            // Not critical
+        }
+    }
+}
+//# sourceMappingURL=CaffeinateManager.js.map

package/dist/core/UpdateChecker.d.ts

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

package/dist/core/UpdateChecker.js

@@ -226,9 +226,11 @@ export class UpdateChecker {
         }
     }
     /**
-     * Fetch human-readable changelog from GitHub releases.
+     * Fetch human-readable changelog from GitHub releases, falling back to
+     * recent commit messages if no release exists for this version.
      */
     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}`, {
@@ -238,16 +240,41 @@ export class UpdateChecker {
                 },
                 signal: AbortSignal.timeout(10000),
             });
-            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 (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 (release.name)
-                return release.name;
         }
         catch {
             // Non-critical

package/dist/lifeline/ServerSupervisor.d.ts

@@ -25,6 +25,8 @@ export declare class ServerSupervisor extends EventEmitter {
     private restartBackoffMs;
     private isRunning;
     private lastHealthy;
+    private startupGraceMs;
+    private spawnedAt;
     constructor(options: {
         projectDir: string;
         projectName: string;

package/dist/lifeline/ServerSupervisor.js

@@ -22,6 +22,8 @@ export class ServerSupervisor extends EventEmitter {
     restartBackoffMs = 5000;
     isRunning = false;
     lastHealthy = 0;
+    startupGraceMs = 20_000; // 20 seconds grace period after spawn before health checks
+    spawnedAt = 0;
     constructor(options) {
         super();
         this.projectDir = options.projectDir;
@@ -95,7 +97,7 @@ export class ServerSupervisor extends EventEmitter {
             return false;
         try {
             // Get the instar CLI path
-            const cliPath = new URL('../../cli.js', import.meta.url).pathname;
+            const cliPath = new URL('../cli.js', import.meta.url).pathname;
             // --no-telegram: lifeline owns the Telegram connection, server should not poll
             const nodeCmd = ['node', cliPath, 'server', 'start', '--foreground', '--no-telegram']
                 .map(arg => `'${arg.replace(/'/g, "'\\''")}'`)
@@ -108,6 +110,7 @@ export class ServerSupervisor extends EventEmitter {
             ], { stdio: 'ignore' });
             console.log(`[Supervisor] Server started in tmux session: ${this.serverSessionName}`);
             this.isRunning = true;
+            this.spawnedAt = Date.now();
             this.startHealthChecks();
             return true;
         }
@@ -133,6 +136,10 @@ export class ServerSupervisor extends EventEmitter {
         if (this.healthCheckInterval)
             return;
         this.healthCheckInterval = setInterval(async () => {
+            // Skip health checks during startup grace period — server needs time to boot
+            if (this.spawnedAt > 0 && (Date.now() - this.spawnedAt) < this.startupGraceMs) {
+                return;
+            }
             try {
                 const healthy = await this.checkHealth();
                 if (healthy) {

package/dist/lifeline/TelegramLifeline.d.ts

@@ -30,6 +30,7 @@ export declare class TelegramLifeline {
     private stopHeartbeat;
     private replayInterval;
     private lifelineTopicId;
+    private lockPath;
     constructor(projectDir?: string);
     /**
      * Start the lifeline — begins Telegram polling and server supervision.
@@ -44,6 +45,10 @@ export declare class TelegramLifeline {
     private handleLifelineCommand;
     private replayQueue;
     private notifyServerDown;
+    /**
+     * Check if OS-level autostart is installed for this project.
+     */
+    private isAutostartInstalled;
     /**
      * Ensure the Lifeline topic exists. Recreates if deleted.
      */