instar 0.7.49 → 0.7.51

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,25 @@ 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.
+ * 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.
@@ -627,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) {
@@ -710,7 +755,78 @@ export async function startServer(options) {
             ...(config.evolution || {}),
         });
         console.log(pc.green('  Evolution system enabled'));
-        const server = new AgentServer({ config, sessionManager, state, scheduler, telegram, relationships, feedback, dispatches, updateChecker, autoUpdater, autoDispatcher, quotaTracker, publisher, viewer, tunnel, evolution });
+        // 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, watchdog });
         await server.start();
         // Start tunnel AFTER server is listening
         if (tunnel) {
@@ -723,9 +839,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/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/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>;
     /**