instar 0.23.15 → 0.23.16

package/dashboard/index.html

@@ -1881,6 +1881,9 @@
     let activeSession = null;
     let term = null;
     let fitAddon = null;
+    let historyLinesLoaded = 2000; // matches initial subscribe capture
+    let historyLoading = false;
+    let historyExhausted = false; // true when we've loaded all available history
 
     // ── Auth ─────────────────────────────────────────────────
     function authenticate() {
@@ -2004,6 +2007,26 @@
           }
           break;
 
+        case 'history':
+          if (msg.session === activeSession && term) {
+            const prevLineCount = historyLinesLoaded;
+            historyLinesLoaded = msg.lines;
+            // Check if we got more content than before
+            const newLineCount = (msg.data || '').split('\n').length;
+            const oldLineCount = prevLineCount;
+            if (newLineCount <= oldLineCount + 10) {
+              // No meaningful new content — we've hit the buffer limit
+              historyExhausted = true;
+            }
+            // Rewrite terminal with expanded history
+            term.clear();
+            term.write(msg.data);
+            // Don't auto-scroll — user is reading history
+            historyLoading = false;
+            hideHistorySpinner();
+          }
+          break;
+
         case 'session_ended':
           if (msg.session === activeSession) {
             // Session ended — show in terminal

package/dist/commands/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/commands/server.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAwPH,UAAU,YAAY;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;2DACuD;IACvD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAoiCD,wBAAsB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAk3EtE;AAED,wBAAsB,UAAU,CAAC,OAAO,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAsDzE;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAuD5E"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/commands/server.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAwPH,UAAU,YAAY;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;2DACuD;IACvD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAgkCD,wBAAsB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAy5EtE;AAED,wBAAsB,UAAU,CAAC,OAAO,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAsDzE;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAuD5E"}

package/dist/commands/server.js

@@ -283,7 +283,7 @@ async function spawnSessionForTopic(sessionManager, telegram, sessionName, topic
     let usedFallback = false;
     if (topicMemory?.isReady()) {
         try {
-            contextContent = topicMemory.formatContextForSession(topicId, 30);
+            contextContent = topicMemory.formatContextForSession(topicId, 50);
         }
         catch (err) {
             // @silent-fallback-ok — TopicMemory format, JSONL fallback
@@ -294,12 +294,16 @@ async function spawnSessionForTopic(sessionManager, telegram, sessionName, topic
     if (!contextContent) {
         usedFallback = true;
         try {
-            const history = telegram.getTopicHistory(topicId, 20);
+            const history = telegram.getTopicHistory(topicId, 50);
             if (history.length > 0) {
                 const lines = [];
                 lines.push(`--- Thread History (last ${history.length} messages) ---`);
                 lines.push(`IMPORTANT: Read this history carefully before taking any action.`);
                 lines.push(`Your task is to continue THIS conversation, not start something new.`);
+                const topicName = telegram.getTopicName?.(topicId);
+                if (topicName) {
+                    lines.push(`Topic: ${topicName}`);
+                }
                 lines.push(``);
                 for (const m of history) {
                     // Use actual sender name if available (multi-user topics), fall back to generic
@@ -307,7 +311,7 @@ async function spawnSessionForTopic(sessionManager, telegram, sessionName, topic
                         ? (m.senderName || 'User')
                         : 'Agent';
                     const ts = m.timestamp ? new Date(m.timestamp).toISOString().slice(11, 19) : '??:??';
-                    const text = (m.text || '').slice(0, 300);
+                    const text = (m.text || '').slice(0, 2000);
                     lines.push(`[${ts}] ${sender}: ${text}`);
                 }
                 lines.push(``);
@@ -434,13 +438,30 @@ async function spawnSessionForTopic(sessionManager, telegram, sessionName, topic
     if (resumeSessionId) {
         _topicResumeMap?.remove(topicId);
     }
+    // Proactive UUID save — schedule an immediate discovery attempt after spawn.
+    // The JSONL file appears ~3-5 seconds after Claude Code starts.
+    // This is belt-and-suspenders alongside the 60s heartbeat and beforeSessionKill.
+    if (_topicResumeMap && !resumeSessionId) {
+        setTimeout(() => {
+            try {
+                const uuid = _topicResumeMap.findClaudeSessionUuid();
+                if (uuid) {
+                    _topicResumeMap.save(topicId, uuid, newSessionName);
+                    console.log(`[spawnSessionForTopic] Proactive UUID save: ${uuid} for topic ${topicId}`);
+                }
+            }
+            catch (err) {
+                console.error(`[spawnSessionForTopic] Proactive UUID save failed:`, err);
+            }
+        }, 8000);
+    }
     return newSessionName;
 }
 /**
  * Respawn a session for a topic, including thread history in the bootstrap.
  * This prevents "thread drift" where respawned sessions lose context.
  */
-async function respawnSessionForTopic(sessionManager, telegram, targetSession, topicId, latestMessage, topicMemory, userProfile) {
+async function respawnSessionForTopic(sessionManager, telegram, targetSession, topicId, latestMessage, topicMemory, userProfile, recoveryPrompt) {
     console.log(`[telegram→session] Session "${targetSession}" needs respawn for topic ${topicId}`);
     // Save the old session's Claude UUID before respawning so --resume can reattach context
     if (_topicResumeMap) {
@@ -459,7 +480,12 @@ async function respawnSessionForTopic(sessionManager, telegram, targetSession, t
     // Use topic name, not tmux session name — tmux names include the project prefix
     // which causes cascading names like ai-guy-ai-guy-ai-guy-topic-1 on each respawn.
     const topicName = storedName || `topic-${topicId}`;
-    const newSessionName = await spawnSessionForTopic(sessionManager, telegram, topicName, topicId, latestMessage, topicMemory, userProfile);
+    // If this is a recovery respawn, prepend the recovery context to the message
+    // so the session knows what happened and can avoid repeating the failure.
+    const effectiveMessage = recoveryPrompt
+        ? `${recoveryPrompt}\n\n${latestMessage || 'Session recovered — continue where you left off.'}`
+        : latestMessage;
+    const newSessionName = await spawnSessionForTopic(sessionManager, telegram, topicName, topicId, effectiveMessage, topicMemory, userProfile);
     telegram.registerTopicSession(topicId, newSessionName, topicName);
     await telegram.sendToTopic(topicId, `Session respawned.`);
     console.log(`[telegram→session] Respawned "${newSessionName}" for topic ${topicId}`);
@@ -2013,6 +2039,26 @@ export async function startServer(options) {
             resumeHeartbeatInterval.unref();
             console.log(pc.green('  Resume heartbeat: active (60s interval)'));
         }
+        // Save Claude session UUID before any session kill so the topic can be
+        // resumed later with --resume. This fires BEFORE the tmux session is
+        // destroyed, so the UUID can still be discovered from the JSONL mtime.
+        if (_topicResumeMap && telegram) {
+            sessionManager.on('beforeSessionKill', (session) => {
+                try {
+                    const topicId = telegram.getTopicForSession(session.tmuxSession);
+                    if (!topicId)
+                        return;
+                    const uuid = _topicResumeMap.findUuidForSession(session.tmuxSession);
+                    if (uuid) {
+                        _topicResumeMap.save(topicId, uuid, session.tmuxSession);
+                        console.log(`[beforeSessionKill] Saved resume UUID ${uuid} for topic ${topicId} (session: ${session.name})`);
+                    }
+                }
+                catch (err) {
+                    console.error(`[beforeSessionKill] Failed to save resume UUID:`, err);
+                }
+            });
+        }
         if (scheduler) {
             sessionManager.on('sessionComplete', (session) => {
                 scheduler.processQueue();
@@ -2450,6 +2496,25 @@ export async function startServer(options) {
         const { SubagentTracker } = await import('../monitoring/SubagentTracker.js');
         const subagentTracker = new SubagentTracker({ stateDir: config.stateDir });
         console.log(pc.green('  Subagent tracker enabled'));
+        // Wire subagent awareness into zombie cleanup — prevents killing sessions
+        // that are idle at the prompt but waiting for subagent results.
+        const MAX_SUBAGENT_WAIT_MS = 60 * 60_000; // 60 minutes — stale subagent safety cap
+        sessionManager.setSubagentChecker((session) => {
+            if (!session.claudeSessionId)
+                return false;
+            const active = subagentTracker.getActiveSubagents(session.claudeSessionId);
+            if (active.length === 0)
+                return false;
+            // Safety cap: if ALL active subagents have been running > 60 minutes,
+            // treat them as stale (likely missed a SubagentStop event) and allow the kill.
+            const now = Date.now();
+            const allStale = active.every(a => now - new Date(a.startedAt).getTime() > MAX_SUBAGENT_WAIT_MS);
+            if (allStale) {
+                console.warn(`[SessionManager] Session "${session.name}" has ${active.length} stale subagent(s) (>60m). Allowing zombie kill.`);
+                return false;
+            }
+            return true;
+        });
         // Worktree Monitor — detects orphaned worktrees after sessions complete
         const { WorktreeMonitor } = await import('../monitoring/WorktreeMonitor.js');
         const worktreeMonitor = new WorktreeMonitor({