instar 0.25.2 → 0.25.4

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;AA0PH,UAAU,YAAY;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;2DACuD;IACvD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAsnCD,wBAAsB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAy9GtE;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;AA0PH,UAAU,YAAY;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;2DACuD;IACvD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAsnCD,wBAAsB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAslHtE;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

@@ -2515,10 +2515,15 @@ export async function startServer(options) {
                         clearTimeout(timer);
                     }
                 };
-                // Start stall detection timer
+                // Wire intelligence provider for LLM-gated stall confirmation
+                if (sharedIntelligence) {
+                    slackAdapter.intelligence = sharedIntelligence;
+                }
+                // Start stall detection timer (with promise tracking)
                 const stallTimeout = slackConfig.config.stallTimeoutMinutes ?? 5;
+                const promiseTimeout = slackConfig.config.promiseTimeoutMinutes ?? 10;
                 if (stallTimeout > 0) {
-                    slackAdapter.startStallDetection(stallTimeout * 60 * 1000);
+                    slackAdapter.startStallDetection(stallTimeout * 60 * 1000, promiseTimeout * 60 * 1000);
                 }
                 // Wire session management callbacks for slash commands
                 slackAdapter.onInterruptSession = async (sessionName) => {
@@ -2559,7 +2564,7 @@ export async function startServer(options) {
                     sessionManager.sendKey(sessionName, value);
                     console.log(`[slack] Prompt response injected: session="${sessionName}" key="${value}"`);
                 };
-                // Standby commands will be wired after PresenceProxy is initialized (below)
+                // Standby commands and triage status will be wired after PresenceProxy/TriageOrchestrator (below)
             }
             catch (err) {
                 const reason = err instanceof Error ? err.message : String(err);
@@ -2856,32 +2861,63 @@ export async function startServer(options) {
             console.log(pc.green('  Session Watchdog enabled'));
         }
         // StallTriageNurse — LLM-powered session recovery (uses shared intelligence)
+        // Platform-aware: works with Telegram topics AND Slack channels
         let triageNurse;
-        if (config.monitoring.triage?.enabled && telegram) {
+        if (config.monitoring.triage?.enabled && (telegram || _slackAdapter)) {
             triageNurse = new StallTriageNurse({
                 captureSessionOutput: (name, lines) => sessionManager.captureOutput(name, lines),
                 isSessionAlive: (name) => sessionManager.isSessionAlive(name),
                 sendKey: (name, key) => sessionManager.sendKey(name, key),
                 sendInput: (name, text) => sessionManager.sendInput(name, text),
                 getTopicHistory: (topicId, limit) => {
-                    const entries = telegram.getTopicHistory(topicId, limit);
-                    return entries.map(e => ({
-                        text: e.text,
-                        fromUser: e.fromUser,
-                        timestamp: e.timestamp,
-                    }));
+                    // Check if this is a Slack synthetic ID
+                    const slackChId = slackProxyChannelMap.get(topicId);
+                    if (slackChId && _slackAdapter) {
+                        const msgs = _slackAdapter.getChannelMessages(slackChId, limit);
+                        return msgs.map(m => ({ text: m.text, fromUser: true, timestamp: new Date(parseFloat(m.ts) * 1000).toISOString() }));
+                    }
+                    if (telegram) {
+                        const entries = telegram.getTopicHistory(topicId, limit);
+                        return entries.map(e => ({ text: e.text, fromUser: e.fromUser, timestamp: e.timestamp }));
+                    }
+                    return [];
+                },
+                sendToTopic: async (topicId, text) => {
+                    const slackChId = slackProxyChannelMap.get(topicId);
+                    if (slackChId && _slackAdapter) {
+                        await _slackAdapter.sendToChannel(slackChId, text);
+                        return;
+                    }
+                    if (telegram)
+                        await telegram.sendToTopic(topicId, text);
+                },
+                respawnSession: (name, topicId, options) => {
+                    if (telegram) {
+                        return respawnSessionForTopic(sessionManager, telegram, name, topicId, undefined, topicMemory, undefined, undefined, options);
+                    }
+                    // Slack respawn: kill and let next message trigger fresh session
+                    const stuckSession = sessionManager.listRunningSessions().find(s => s.tmuxSession === name);
+                    if (stuckSession)
+                        sessionManager.killSession(stuckSession.id);
+                    return Promise.resolve();
+                },
+                clearStallForTopic: (topicId) => {
+                    const slackChId = slackProxyChannelMap.get(topicId);
+                    if (slackChId && _slackAdapter) {
+                        _slackAdapter.clearStallTracking(slackChId);
+                        return;
+                    }
+                    if (telegram)
+                        telegram.clearStallTracking(topicId);
                 },
-                sendToTopic: (topicId, text) => telegram.sendToTopic(topicId, text),
-                respawnSession: (name, topicId, options) => respawnSessionForTopic(sessionManager, telegram, name, topicId, undefined, topicMemory, undefined, undefined, options),
-                clearStallForTopic: (topicId) => telegram.clearStallTracking(topicId),
             }, {
                 config: config.monitoring.triage,
                 state,
                 intelligence: sharedIntelligence,
             });
-            // Wire nurse into TelegramAdapter stall detection
+            // Wire nurse into stall detection — both Telegram and Slack
             // Note: presenceProxy may be set later — use late-binding check
-            telegram.onStallDetected = async (topicId, sessionName, messageText, injectedAt) => {
+            const stallTriageHandler = async (topicId, sessionName, messageText, injectedAt) => {
                 // If PresenceProxy Tier 3 is actively handling this topic, defer to it
                 if (presenceProxy) {
                     const proxyState = presenceProxy.getState(topicId);
@@ -2896,27 +2932,58 @@ export async function startServer(options) {
                 const result = await triageNurse.triage(topicId, sessionName, messageText, injectedAt, 'telegram_stall');
                 return { resolved: result.resolved };
             };
+            if (telegram) {
+                telegram.onStallDetected = stallTriageHandler;
+            }
             console.log(pc.green('  Stall Triage Nurse enabled'));
         }
         // TriageOrchestrator — next-gen session recovery with scoped Claude Code sessions
+        // Platform-aware: works with Telegram topics AND Slack channels
         let triageOrchestrator;
-        if (config.monitoring.triageOrchestrator?.enabled && telegram) {
+        if (config.monitoring.triageOrchestrator?.enabled && (telegram || _slackAdapter)) {
             triageOrchestrator = new TriageOrchestrator({
                 captureSessionOutput: (name, lines) => sessionManager.captureOutput(name, lines),
                 isSessionAlive: (name) => sessionManager.isSessionAlive(name),
                 sendKey: (name, key) => sessionManager.sendKey(name, key),
                 sendInput: (name, text) => sessionManager.sendInput(name, text),
                 getTopicHistory: (topicId, limit) => {
-                    const entries = telegram.getTopicHistory(topicId, limit);
-                    return entries.map(e => ({
-                        text: e.text,
-                        fromUser: e.fromUser,
-                        timestamp: e.timestamp,
-                    }));
+                    const slackChId = slackProxyChannelMap.get(topicId);
+                    if (slackChId && _slackAdapter) {
+                        const msgs = _slackAdapter.getChannelMessages(slackChId, limit);
+                        return msgs.map(m => ({ text: m.text, fromUser: true, timestamp: new Date(parseFloat(m.ts) * 1000).toISOString() }));
+                    }
+                    if (telegram) {
+                        const entries = telegram.getTopicHistory(topicId, limit);
+                        return entries.map(e => ({ text: e.text, fromUser: e.fromUser, timestamp: e.timestamp }));
+                    }
+                    return [];
+                },
+                sendToTopic: async (topicId, text) => {
+                    const slackChId = slackProxyChannelMap.get(topicId);
+                    if (slackChId && _slackAdapter) {
+                        await _slackAdapter.sendToChannel(slackChId, text);
+                        return;
+                    }
+                    if (telegram)
+                        await telegram.sendToTopic(topicId, text);
+                },
+                respawnSession: (name, topicId, options) => {
+                    if (telegram)
+                        return respawnSessionForTopic(sessionManager, telegram, name, topicId, undefined, topicMemory, undefined, undefined, options);
+                    const stuckSession = sessionManager.listRunningSessions().find(s => s.tmuxSession === name);
+                    if (stuckSession)
+                        sessionManager.killSession(stuckSession.id);
+                    return Promise.resolve();
+                },
+                clearStallForTopic: (topicId) => {
+                    const slackChId = slackProxyChannelMap.get(topicId);
+                    if (slackChId && _slackAdapter) {
+                        _slackAdapter.clearStallTracking(slackChId);
+                        return;
+                    }
+                    if (telegram)
+                        telegram.clearStallTracking(topicId);
                 },
-                sendToTopic: (topicId, text) => telegram.sendToTopic(topicId, text),
-                respawnSession: (name, topicId, options) => respawnSessionForTopic(sessionManager, telegram, name, topicId, undefined, topicMemory, undefined, undefined, options),
-                clearStallForTopic: (topicId) => telegram.clearStallTracking(topicId),
                 spawnTriageSession: (name, options) => sessionManager.spawnTriageSession(name, options),
                 getTriageSessionUuid: (sessionName) => {
                     return _topicResumeMap?.findUuidForSession(sessionName) ?? undefined;
@@ -2957,33 +3024,37 @@ export async function startServer(options) {
                 state,
             });
             // TriageOrchestrator takes over stall detection from StallTriageNurse
-            telegram.onStallDetected = async (topicId, sessionName, messageText, injectedAt) => {
+            const triageStallHandler = async (topicId, sessionName, messageText, injectedAt) => {
                 const result = await triageOrchestrator.activate(topicId, sessionName, 'stall_detector', messageText, injectedAt);
                 return { resolved: result.resolved };
             };
-            // Cancel triage when stall tracking clears (session responded)
-            const origClearStall = telegram.clearStallTracking.bind(telegram);
-            telegram.clearStallTracking = (topicId) => {
-                origClearStall(topicId);
-                triageOrchestrator.onTargetSessionResponded(topicId);
-            };
-            // Wire /triage command
-            telegram.onGetTriageStatus = (topicId) => {
-                const ts = triageOrchestrator.getTriageState(topicId);
-                if (!ts)
-                    return null;
-                return {
-                    active: true,
-                    classification: ts.classification,
-                    checkCount: ts.checkCount,
-                    lastCheck: new Date(ts.lastCheckAt).toISOString(),
+            if (telegram) {
+                telegram.onStallDetected = triageStallHandler;
+                // Cancel triage when stall tracking clears (session responded)
+                const origClearStall = telegram.clearStallTracking.bind(telegram);
+                telegram.clearStallTracking = (topicId) => {
+                    origClearStall(topicId);
+                    triageOrchestrator.onTargetSessionResponded(topicId);
                 };
-            };
+                // Wire /triage command
+                telegram.onGetTriageStatus = (topicId) => {
+                    const ts = triageOrchestrator.getTriageState(topicId);
+                    if (!ts)
+                        return null;
+                    return {
+                        active: true,
+                        classification: ts.classification,
+                        checkCount: ts.checkCount,
+                        lastCheck: new Date(ts.lastCheckAt).toISOString(),
+                    };
+                };
+            }
             console.log(pc.green('  Triage Orchestrator enabled (replaces Stall Triage Nurse for stall detection)'));
         }
         // SessionRecovery — fast mechanical recovery (JSONL analysis, no LLM)
+        // Platform-aware: works with Telegram topics AND Slack channels
         let sessionRecovery;
-        if (telegram) {
+        if (telegram || _slackAdapter) {
             sessionRecovery = new SessionRecovery({ enabled: true, projectDir: config.projectDir }, {
                 isSessionAlive: (name) => sessionManager.isSessionAlive(name),
                 getPanePid: (name) => {
@@ -2999,6 +3070,13 @@ export async function startServer(options) {
                     }
                 },
                 killSession: (name) => {
+                    // Route through SessionManager to fire beforeSessionKill hook
+                    const session = sessionManager.listRunningSessions().find(s => s.tmuxSession === name);
+                    if (session) {
+                        sessionManager.killSession(session.id);
+                        return;
+                    }
+                    // Fallback: direct tmux kill for untracked sessions
                     try {
                         const tmux = detectTmuxPath();
                         if (!tmux)
@@ -3008,32 +3086,86 @@ export async function startServer(options) {
                     catch { /* may already be dead */ }
                 },
                 respawnSession: async (topicId, _sessionName, recoveryPrompt) => {
-                    const targetSession = telegram.getSessionForTopic(topicId);
-                    if (!targetSession)
+                    // Check Slack first (synthetic IDs are negative)
+                    const slackChId = slackProxyChannelMap.get(topicId);
+                    if (slackChId && _slackAdapter) {
+                        // Slack respawn: kill existing, next message triggers fresh session
+                        const session = sessionManager.listRunningSessions().find(s => s.tmuxSession === _sessionName);
+                        if (session)
+                            sessionManager.killSession(session.id);
                         return;
-                    await respawnSessionForTopic(sessionManager, telegram, targetSession, topicId, undefined, topicMemory, undefined, recoveryPrompt, { silent: true });
+                    }
+                    if (telegram) {
+                        const targetSession = telegram.getSessionForTopic(topicId);
+                        if (!targetSession)
+                            return;
+                        await respawnSessionForTopic(sessionManager, telegram, targetSession, topicId, undefined, topicMemory, undefined, recoveryPrompt, { silent: true });
+                    }
+                },
+                sendToTopic: async (topicId, message) => {
+                    const slackChId = slackProxyChannelMap.get(topicId);
+                    if (slackChId && _slackAdapter) {
+                        await _slackAdapter.sendToChannel(slackChId, message);
+                        return;
+                    }
+                    if (telegram)
+                        await telegram.sendToTopic(topicId, message);
                 },
-                sendToTopic: async (topicId, message) => { await telegram.sendToTopic(topicId, message); },
             });
             console.log(pc.green('  Session Recovery enabled (mechanical fast-path)'));
         }
         // SessionMonitor — proactive session health monitoring
+        // Platform-aware: monitors both Telegram and Slack sessions
         let sessionMonitor;
-        if (telegram) {
+        if (telegram || _slackAdapter) {
             sessionMonitor = new SessionMonitor({
-                getActiveTopicSessions: () => telegram.getActiveTopicSessions(),
+                getActiveTopicSessions: () => {
+                    const sessions = new Map();
+                    // Telegram topic sessions
+                    if (telegram && telegram.getActiveTopicSessions) {
+                        const telegramSessions = telegram.getActiveTopicSessions();
+                        for (const [topicId, sessionName] of telegramSessions) {
+                            sessions.set(topicId, sessionName);
+                        }
+                    }
+                    // Slack channel sessions (using synthetic IDs)
+                    if (_slackAdapter) {
+                        const registry = _slackAdapter.getChannelRegistry();
+                        for (const [channelId, entry] of Object.entries(registry)) {
+                            const syntheticId = slackChannelToSyntheticId(channelId);
+                            sessions.set(syntheticId, entry.sessionName);
+                        }
+                    }
+                    return sessions;
+                },
                 captureSessionOutput: (name, lines) => sessionManager.captureOutput(name, lines),
                 isSessionAlive: (name) => sessionManager.isSessionAlive(name),
                 getTopicHistory: (topicId, limit) => {
-                    const history = telegram.getMessageLog?.();
-                    if (!history)
-                        return [];
-                    return history
-                        .filter((m) => m.topicId === topicId)
-                        .slice(-limit)
-                        .map((m) => ({ text: m.text, fromUser: m.fromUser, timestamp: m.timestamp }));
+                    const slackChId = slackProxyChannelMap.get(topicId);
+                    if (slackChId && _slackAdapter) {
+                        const msgs = _slackAdapter.getChannelMessages(slackChId, limit);
+                        return msgs.map(m => ({ text: m.text, fromUser: true, timestamp: new Date(parseFloat(m.ts) * 1000).toISOString() }));
+                    }
+                    if (telegram) {
+                        const history = telegram.getMessageLog?.();
+                        if (!history)
+                            return [];
+                        return history
+                            .filter((m) => m.topicId === topicId)
+                            .slice(-limit)
+                            .map((m) => ({ text: m.text, fromUser: m.fromUser, timestamp: m.timestamp }));
+                    }
+                    return [];
+                },
+                sendToTopic: async (topicId, text) => {
+                    const slackChId = slackProxyChannelMap.get(topicId);
+                    if (slackChId && _slackAdapter) {
+                        await _slackAdapter.sendToChannel(slackChId, text);
+                        return;
+                    }
+                    if (telegram)
+                        await telegram.sendToTopic(topicId, text);
                 },
-                sendToTopic: (topicId, text) => telegram.sendToTopic(topicId, text),
                 triggerTriage: triageOrchestrator
                     ? async (topicId, sessionName, reason) => {
                         const result = await triageOrchestrator.activate(topicId, sessionName, 'watchdog', reason, Date.now());
@@ -3535,6 +3667,21 @@ export async function startServer(options) {
                         const syntheticId = slackChannelToSyntheticId(channelId);
                         return presenceProxy.handleCommand(syntheticId, command, parseInt(userId, 10) || 0);
                     };
+                    // Wire triage status for Slack !triage command
+                    if (triageOrchestrator) {
+                        _slackAdapter.onGetTriageStatus = (channelId) => {
+                            const syntheticId = slackChannelToSyntheticId(channelId);
+                            const ts = triageOrchestrator.getTriageState(syntheticId);
+                            if (!ts)
+                                return null;
+                            return {
+                                active: true,
+                                classification: ts.classification,
+                                checkCount: ts.checkCount,
+                                lastCheck: new Date(ts.lastCheckAt).toISOString(),
+                            };
+                        };
+                    }
                 }
                 console.log(pc.green('  Presence Proxy enabled (🔭 [Standby])'));
             }