instar 0.4.2 → 0.4.4

package/dist/commands/server.js

@@ -55,15 +55,16 @@ async function respawnSessionForTopic(sessionManager, telegram, targetSession, t
     const tmpDir = '/tmp/instar-telegram';
     fs.mkdirSync(tmpDir, { recursive: true });
     let bootstrapMessage;
+    const relayNote = `You MUST relay your response via: cat <<'EOF' | .claude/scripts/telegram-reply.sh ${topicId}\nYour response\nEOF`;
     if (historyLines.length > 0) {
         const historyContent = historyLines.join('\n');
         const filepath = path.join(tmpDir, `history-${topicId}-${Date.now()}-${process.pid}.txt`);
         fs.writeFileSync(filepath, historyContent);
-        // Single-line: user message + file reference for history
-        bootstrapMessage = `[telegram:${topicId}] ${msg} (Session respawned. Thread history at ${filepath} — read it for context before responding.)`;
+        // Single-line: user message + file reference for history + relay instructions
+        bootstrapMessage = `[telegram:${topicId}] ${msg} (Session respawned. Thread history at ${filepath} — read it for context before responding. ${relayNote})`;
     }
     else {
-        bootstrapMessage = `[telegram:${topicId}] ${msg}`;
+        bootstrapMessage = `[telegram:${topicId}] ${msg} (${relayNote})`;
     }
     const storedName = telegram.getTopicName(topicId);
     const topicName = storedName || targetSession;
@@ -113,6 +114,27 @@ function wireTelegramCallbacks(telegram, sessionManager, state) {
     telegram.onIsSessionAlive = (sessionName) => {
         return sessionManager.isSessionAlive(sessionName);
     };
+    // Stall verification — check if session has recent output activity
+    telegram.onIsSessionActive = async (sessionName) => {
+        const output = sessionManager.captureOutput(sessionName, 20);
+        if (!output)
+            return false;
+        const lines = output.trim().split('\n').slice(-15);
+        // Look for signs of Claude Code activity in recent output
+        const activePatterns = [
+            /\bRead\b|\bWrite\b|\bEdit\b|\bBash\b|\bGrep\b|\bGlob\b/, // Tool names
+            /⠋|⠙|⠹|⠸|⠼|⠴|⠦|⠧|⠇|⠏/, // Spinner characters
+            /\d+\s*tokens?/i, // Token counts
+            /Sent \d+ chars/, // Telegram reply confirmation
+        ];
+        for (const line of lines) {
+            for (const pattern of activePatterns) {
+                if (pattern.test(line))
+                    return true;
+            }
+        }
+        return false;
+    };
 }
 /**
  * Wire up Telegram message routing: topic messages → Claude sessions.
@@ -133,7 +155,7 @@ function wireTelegramRouting(telegram, sessionManager) {
             (async () => {
                 try {
                     const topic = await telegram.createForumTopic(topicName, 9367192); // Green
-                    const newSession = await sessionManager.spawnInteractiveSession(`[telegram:${topic.topicId}] New session started.`, topicName);
+                    const newSession = await sessionManager.spawnInteractiveSession(`[telegram:${topic.topicId}] New session started. (IMPORTANT: Relay all responses back via: cat <<'EOF' | .claude/scripts/telegram-reply.sh ${topic.topicId}\nYour response\nEOF)`, topicName);
                     telegram.registerTopicSession(topic.topicId, newSession);
                     await telegram.sendToTopic(topic.topicId, `Session created. I'm here.`);
                     await telegram.sendToTopic(topicId, `New session created: "${topicName}" — check the new topic above.`);
@@ -167,19 +189,26 @@ function wireTelegramRouting(telegram, sessionManager) {
             // No session mapped — auto-spawn one
             console.log(`[telegram→session] No session for topic ${topicId}, auto-spawning...`);
             const storedName = telegram.getTopicName(topicId) || `topic-${topicId}`;
-            // Single-line bootstrap to avoid tmux send-keys newline issues.
-            // Multi-line context is written to a temp file for Claude to read.
+            // Write relay instructions to a temp file and reference it in the bootstrap message.
+            // The session needs to know HOW to respond back to Telegram.
             const contextLines = [
                 `This session was auto-created for Telegram topic ${topicId}.`,
-                `Respond to the user's message via Telegram relay: cat <<'EOF' | .claude/scripts/telegram-reply.sh ${topicId}`,
-                `Your response here`,
+                ``,
+                `CRITICAL: You MUST relay your response back to Telegram after responding.`,
+                `Use the relay script:`,
+                ``,
+                `cat <<'EOF' | .claude/scripts/telegram-reply.sh ${topicId}`,
+                `Your response text here`,
                 `EOF`,
+                ``,
+                `Strip the [telegram:${topicId}] prefix before interpreting the message.`,
+                `Only relay conversational text — not tool output or internal reasoning.`,
             ];
             const tmpDir = '/tmp/instar-telegram';
             fs.mkdirSync(tmpDir, { recursive: true });
             const ctxPath = path.join(tmpDir, `ctx-${topicId}-${Date.now()}.txt`);
             fs.writeFileSync(ctxPath, contextLines.join('\n'));
-            const bootstrapMessage = `[telegram:${topicId}] ${text}`;
+            const bootstrapMessage = `[telegram:${topicId}] ${text} (IMPORTANT: Read ${ctxPath} for Telegram relay instructions — you MUST relay your response back.)`;
             sessionManager.spawnInteractiveSession(bootstrapMessage, storedName).then((newSessionName) => {
                 telegram.registerTopicSession(topicId, newSessionName);
                 telegram.sendToTopic(topicId, `Session created.`).catch(() => { });

package/dist/messaging/TelegramAdapter.d.ts

@@ -65,6 +65,7 @@ export declare class TelegramAdapter implements MessagingAdapter {
         alive: boolean;
     }>) | null;
     onIsSessionAlive: ((tmuxSession: string) => boolean) | null;
+    onIsSessionActive: ((tmuxSession: string) => Promise<boolean>) | null;
     constructor(config: TelegramConfig, stateDir: string);
     start(): Promise<void>;
     stop(): Promise<void>;

package/dist/messaging/TelegramAdapter.js

@@ -37,6 +37,7 @@ export class TelegramAdapter {
     onRestartSession = null;
     onListSessions = null;
     onIsSessionAlive = null;
+    onIsSessionActive = null;
     constructor(config, stateDir) {
         this.config = config;
         this.stateDir = stateDir;
@@ -237,7 +238,7 @@ export class TelegramAdapter {
             }
         }
     }
-    checkForStalls() {
+    async checkForStalls() {
         const stallMinutes = this.config.stallTimeoutMinutes ?? 5;
         const stallThresholdMs = stallMinutes * 60 * 1000;
         const now = Date.now();
@@ -250,6 +251,21 @@ export class TelegramAdapter {
             const alive = this.onIsSessionAlive
                 ? this.onIsSessionAlive(pending.sessionName)
                 : true; // assume alive if no checker
+            // If alive, verify the session is truly stalled (not just responding through a different path)
+            if (alive && this.onIsSessionActive) {
+                try {
+                    const active = await this.onIsSessionActive(pending.sessionName);
+                    if (active) {
+                        // Session is producing output — false alarm, clear it
+                        console.log(`[telegram] Session "${pending.sessionName}" verified active, clearing stall`);
+                        this.pendingMessages.delete(key);
+                        continue;
+                    }
+                }
+                catch {
+                    // Verifier failed — fall through to alert
+                }
+            }
             pending.alerted = true;
             const status = alive ? 'running but not responding' : 'no longer running';
             const minutesAgo = Math.round((now - pending.injectedAt) / 60000);
@@ -278,20 +294,36 @@ export class TelegramAdapter {
      * Download a file from Telegram by file_id.
      */
     async downloadFile(fileId, destPath) {
-        const fileInfo = await this.apiCall('getFile', { file_id: fileId });
-        const fileUrl = `https://api.telegram.org/file/bot${this.config.token}/${fileInfo.file_path}`;
-        const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), 60_000);
-        try {
-            const response = await fetch(fileUrl, { signal: controller.signal });
-            if (!response.ok)
-                throw new Error(`Download failed: ${response.status}`);
-            const buffer = Buffer.from(await response.arrayBuffer());
-            fs.writeFileSync(destPath, buffer);
-        }
-        finally {
-            clearTimeout(timer);
+        const maxRetries = 3;
+        let lastError;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                const fileInfo = await this.apiCall('getFile', { file_id: fileId });
+                const fileUrl = `https://api.telegram.org/file/bot${this.config.token}/${fileInfo.file_path}`;
+                const controller = new AbortController();
+                const timer = setTimeout(() => controller.abort(), 60_000);
+                try {
+                    const response = await fetch(fileUrl, { signal: controller.signal });
+                    if (!response.ok)
+                        throw new Error(`Download failed: ${response.status}`);
+                    const buffer = Buffer.from(await response.arrayBuffer());
+                    fs.writeFileSync(destPath, buffer);
+                    return; // Success
+                }
+                finally {
+                    clearTimeout(timer);
+                }
+            }
+            catch (err) {
+                lastError = err instanceof Error ? err : new Error(String(err));
+                if (attempt < maxRetries) {
+                    const delay = attempt * 1000;
+                    console.warn(`[telegram] File download attempt ${attempt}/${maxRetries} failed, retrying in ${delay}ms...`);
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                }
+            }
         }
+        throw lastError;
     }
     /**
      * Resolve voice transcription provider from config or environment.

package/package.json

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