instar 0.25.1 → 0.25.3

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,CAu2GtE;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,CAikHtE;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

@@ -1701,17 +1701,44 @@ export async function startServer(options) {
                         }
                         // If handle() returned false, fall through to relay
                     }
-                    // Relay to Telegram if adapter is available and session has a topic binding
+                    // Relay to messaging platform if adapter is available and session has a binding
                     if (classification.action === 'relay' || classification.action === 'auto-approve') {
+                        let relayed = false;
+                        // Try Telegram first
                         if (telegram) {
                             const topicId = telegram.getTopicForSession(prompt.sessionName);
                             if (topicId) {
                                 try {
                                     await telegram.relayPrompt(topicId, prompt);
-                                    console.log(`[PromptGate] Relayed ${prompt.type} prompt to topic ${topicId}`);
+                                    console.log(`[PromptGate] Relayed ${prompt.type} prompt to Telegram topic ${topicId}`);
+                                    relayed = true;
                                 }
                                 catch (relayErr) {
-                                    console.error(`[PromptGate] Relay failed: ${relayErr instanceof Error ? relayErr.message : relayErr}`);
+                                    console.error(`[PromptGate] Telegram relay failed: ${relayErr instanceof Error ? relayErr.message : relayErr}`);
+                                }
+                            }
+                        }
+                        // Try Slack if not already relayed via Telegram
+                        if (!relayed && _slackAdapter) {
+                            const channelId = _slackAdapter.getChannelForSession(prompt.sessionName);
+                            if (channelId) {
+                                try {
+                                    const question = prompt.summary || 'Agent needs your input';
+                                    const options = (prompt.options || []).map((opt, i) => ({
+                                        label: opt.label.slice(0, 75),
+                                        value: opt.key,
+                                        primary: i === 0,
+                                    }));
+                                    if (options.length > 0) {
+                                        await _slackAdapter.relayPrompt(channelId, prompt.id, question, options);
+                                    }
+                                    else {
+                                        await _slackAdapter.sendToChannel(channelId, `⏳ *Agent needs your input:*\n${question}\n\n_Reply in this channel to respond._`);
+                                    }
+                                    console.log(`[PromptGate] Relayed ${prompt.type} prompt to Slack channel ${channelId}`);
+                                }
+                                catch (relayErr) {
+                                    console.error(`[PromptGate] Slack relay failed: ${relayErr instanceof Error ? relayErr.message : relayErr}`);
                                 }
                             }
                         }
@@ -1803,6 +1830,29 @@ export async function startServer(options) {
         if (telemetryHeartbeat) {
             telemetryHeartbeat.start();
         }
+        // Helper: resolve pending plan prompts when a prompt response arrives.
+        // Calls the internal route endpoint to mark the plan prompt as resolved,
+        // which unblocks the PreToolUse hook that's polling for the response.
+        const resolvePlanPromptForSession = (sessionName, key) => {
+            const port = config.port ?? 4042;
+            const payload = JSON.stringify({ sessionName, key });
+            const http = require('node:http');
+            const req = http.request({
+                hostname: '127.0.0.1',
+                port,
+                path: '/hooks/plan-prompt/resolve',
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Content-Length': Buffer.byteLength(payload),
+                    'Authorization': `Bearer ${config.authToken}`,
+                },
+                timeout: 2000,
+            });
+            req.on('error', () => { }); // Best-effort
+            req.write(payload);
+            req.end();
+        };
         // Set up Telegram if configured
         // When --no-telegram is set (lifeline owns polling), create adapter in send-only mode
         // so the server can still relay replies via /telegram/reply/:topicId
@@ -1831,6 +1881,8 @@ export async function startServer(options) {
                         console.warn(`[PromptGate] Skipping injection — session "${sessionName}" is no longer alive`);
                         return false;
                     }
+                    // Also resolve any pending plan prompt for this session (unblocks the hook)
+                    resolvePlanPromptForSession(sessionName, key);
                     return sessionManager.sendKey(sessionName, key);
                 };
                 telegram.onPromptTextResponse = (sessionName, text) => {
@@ -1871,6 +1923,8 @@ export async function startServer(options) {
                         console.warn(`[PromptGate] Skipping injection — session "${sessionName}" is no longer alive`);
                         return false;
                     }
+                    // Also resolve any pending plan prompt for this session (unblocks the hook)
+                    resolvePlanPromptForSession(sessionName, key);
                     return sessionManager.sendKey(sessionName, key);
                 };
                 telegram.onPromptTextResponse = (sessionName, text) => {
@@ -2301,14 +2355,14 @@ export async function startServer(options) {
                     lines.push('--- End Thread History ---');
                     lines.push('');
                     lines.push('CRITICAL: You MUST relay your response back to Slack after responding.');
-                    lines.push('Use the relay script:');
+                    lines.push('Use the relay script (write ONLY your reply text — do NOT pipe or cat this file into the script):');
                     lines.push('');
                     lines.push(`cat <<'EOF' | .claude/scripts/slack-reply.sh ${channelId}`);
                     lines.push('Your response text here');
                     lines.push('EOF');
                     lines.push('');
                     lines.push('Strip the [slack:] prefix before interpreting the message.');
-                    lines.push('Only relay conversational text — not tool output or internal reasoning.');
+                    lines.push('Only relay conversational text — not tool output, file contents, or internal reasoning.');
                     const contextData = lines.join('\n');
                     fs.writeFileSync(ctxPath, contextData);
                     // Transform [image:path] and [document:path] tags into explicit read instructions
@@ -2364,8 +2418,7 @@ export async function startServer(options) {
                                     sessionManager.injectMessage(existingSession, bootstrapMessage);
                                     // Track for stall detection
                                     slackAdapter.trackMessageInjection(channelId, existingSession, message.content);
-                                    // Delivery confirmation
-                                    slackAdapter.sendToChannel(channelId, '✓ Delivered').catch(() => { });
+                                    // Delivery confirmation via reaction only (no text message — the ✅ reaction is sufficient)
                                 }
                                 catch (injectErr) {
                                     console.error(`[slack→session] Injection failed: ${injectErr instanceof Error ? injectErr.message : injectErr}`);
@@ -2491,6 +2544,21 @@ export async function startServer(options) {
                 slackAdapter.onIsSessionAlive = (tmuxSession) => {
                     return sessionManager.isSessionAlive(tmuxSession);
                 };
+                // Wire prompt response callback — inject button presses into sessions
+                slackAdapter.onPromptResponse = (channelId, promptId, value) => {
+                    // Look up which session is bound to this channel
+                    const sessionName = slackAdapter.getSessionForChannel(channelId);
+                    if (!sessionName) {
+                        console.warn(`[slack] Prompt response for channel ${channelId} but no session bound`);
+                        return;
+                    }
+                    if (!sessionManager.isSessionAlive(sessionName)) {
+                        console.warn(`[slack] Prompt response for dead session "${sessionName}"`);
+                        return;
+                    }
+                    sessionManager.sendKey(sessionName, value);
+                    console.log(`[slack] Prompt response injected: session="${sessionName}" key="${value}"`);
+                };
                 // Standby commands will be wired after PresenceProxy is initialized (below)
             }
             catch (err) {
@@ -2574,19 +2642,34 @@ export async function startServer(options) {
         sessionManager.startMonitoring();
         // Proactive resume heartbeat: every 60s, update the topic→UUID mapping
         // for all active topic-linked sessions. Ensures crash recovery via --resume.
-        if (_topicResumeMap && telegram) {
+        if (_topicResumeMap && (telegram || _slackAdapter)) {
             const resumeHeartbeatInterval = setInterval(() => {
                 try {
-                    const topicSessions = telegram.getAllTopicSessions();
-                    // Enrich with authoritative Claude session IDs from SessionManager
                     const enriched = new Map();
-                    for (const [topicId, sessionName] of topicSessions) {
-                        const sessions = sessionManager.listRunningSessions();
-                        const session = sessions.find(s => s.tmuxSession === sessionName);
-                        enriched.set(topicId, {
-                            sessionName,
-                            claudeSessionId: session?.claudeSessionId ?? undefined,
-                        });
+                    // Telegram topic-session mappings
+                    if (telegram) {
+                        const topicSessions = telegram.getAllTopicSessions();
+                        for (const [topicId, sessionName] of topicSessions) {
+                            const sessions = sessionManager.listRunningSessions();
+                            const session = sessions.find(s => s.tmuxSession === sessionName);
+                            enriched.set(topicId, {
+                                sessionName,
+                                claudeSessionId: session?.claudeSessionId ?? undefined,
+                            });
+                        }
+                    }
+                    // Slack channel-session mappings (use synthetic IDs for compatibility)
+                    if (_slackAdapter) {
+                        const registry = _slackAdapter.getChannelRegistry();
+                        for (const [channelId, entry] of Object.entries(registry)) {
+                            const syntheticId = slackChannelToSyntheticId(channelId);
+                            const sessions = sessionManager.listRunningSessions();
+                            const session = sessions.find(s => s.tmuxSession === entry.sessionName);
+                            enriched.set(syntheticId, {
+                                sessionName: entry.sessionName,
+                                claudeSessionId: session?.claudeSessionId ?? undefined,
+                            });
+                        }
                     }
                     _topicResumeMap?.refreshResumeMappings(enriched);
                 }
@@ -2601,19 +2684,21 @@ export async function startServer(options) {
         // 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) {
+        if (_topicResumeMap) {
             sessionManager.on('beforeSessionKill', (session) => {
                 try {
-                    // Save Telegram topic resume UUID
-                    const topicId = telegram.getTopicForSession(session.tmuxSession);
-                    if (topicId) {
-                        const uuid = _topicResumeMap.findUuidForSession(session.tmuxSession, session.claudeSessionId ?? undefined);
-                        if (uuid) {
-                            _topicResumeMap.save(topicId, uuid, session.tmuxSession);
-                            console.log(`[beforeSessionKill] Saved resume UUID ${uuid} for topic ${topicId} (session: ${session.name}, source: ${session.claudeSessionId ? 'hook' : 'mtime'})`);
+                    // Save Telegram topic resume UUID (if Telegram is configured)
+                    if (telegram) {
+                        const topicId = telegram.getTopicForSession(session.tmuxSession);
+                        if (topicId) {
+                            const uuid = _topicResumeMap.findUuidForSession(session.tmuxSession, session.claudeSessionId ?? undefined);
+                            if (uuid) {
+                                _topicResumeMap.save(topicId, uuid, session.tmuxSession);
+                                console.log(`[beforeSessionKill] Saved resume UUID ${uuid} for topic ${topicId} (session: ${session.name}, source: ${session.claudeSessionId ? 'hook' : 'mtime'})`);
+                            }
                         }
                     }
-                    // Save Slack channel resume UUID
+                    // Save Slack channel resume UUID (if Slack is configured)
                     if (_slackAdapter) {
                         const channelId = _slackAdapter.getChannelForSession(session.tmuxSession);
                         if (channelId) {
@@ -2740,53 +2825,94 @@ export async function startServer(options) {
             watchdog = new SessionWatchdog(config, sessionManager, state);
             watchdog.intelligence = sharedIntelligence ?? null;
             watchdog.on('intervention', (event) => {
+                const levelNames = ['Monitoring', 'Ctrl+C', 'SIGTERM', 'SIGKILL', 'Kill Session'];
+                const levelName = levelNames[event.level] || `Level ${event.level}`;
+                const msg = `🔧 Watchdog [${levelName}]: ${event.action}\nStuck: \`${event.stuckCommand.slice(0, 60)}\``;
                 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(() => { });
-                    }
+                    if (topicId)
+                        telegram.sendToTopic(topicId, msg).catch(() => { });
+                }
+                if (_slackAdapter) {
+                    const channelId = _slackAdapter.getChannelForSession(event.sessionName);
+                    if (channelId)
+                        _slackAdapter.sendToChannel(channelId, msg).catch(() => { });
                 }
             });
             watchdog.on('recovery', (sessionName, fromLevel) => {
+                const msg = `✅ Watchdog: session recovered (was at escalation level ${fromLevel})`;
                 if (telegram) {
                     const topicId = telegram.getTopicForSession(sessionName);
-                    if (topicId) {
-                        telegram.sendToTopic(topicId, `✅ Watchdog: session recovered (was at escalation level ${fromLevel})`).catch(() => { });
-                    }
+                    if (topicId)
+                        telegram.sendToTopic(topicId, msg).catch(() => { });
+                }
+                if (_slackAdapter) {
+                    const channelId = _slackAdapter.getChannelForSession(sessionName);
+                    if (channelId)
+                        _slackAdapter.sendToChannel(channelId, msg).catch(() => { });
                 }
             });
             watchdog.start();
             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);
@@ -2801,27 +2927,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;
@@ -2862,33 +3019,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) => {
@@ -2904,6 +3065,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)
@@ -2913,32 +3081,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());
@@ -4336,23 +4558,38 @@ export async function startServer(options) {
             // 1. Resume entries are consumed (removed) on spawn
             // 2. Proactive save may not have run yet
             // 3. beforeSessionKill doesn't fire for bulk process exit
-            if (_topicResumeMap && telegram) {
+            if (_topicResumeMap) {
                 try {
                     const runningSessions = sessionManager.listRunningSessions();
-                    const topicSessions = telegram.getAllTopicSessions?.();
-                    if (topicSessions) {
-                        let saved = 0;
-                        for (const [topicId, sessionName] of topicSessions) {
-                            const session = runningSessions.find(s => s.tmuxSession === sessionName);
-                            const uuid = _topicResumeMap.findUuidForSession(sessionName, session?.claudeSessionId ?? undefined);
+                    let saved = 0;
+                    // Save Telegram topic resume UUIDs
+                    if (telegram) {
+                        const topicSessions = telegram.getAllTopicSessions?.();
+                        if (topicSessions) {
+                            for (const [topicId, sessionName] of topicSessions) {
+                                const session = runningSessions.find(s => s.tmuxSession === sessionName);
+                                const uuid = _topicResumeMap.findUuidForSession(sessionName, session?.claudeSessionId ?? undefined);
+                                if (uuid) {
+                                    _topicResumeMap.save(topicId, uuid, sessionName);
+                                    saved++;
+                                }
+                            }
+                        }
+                    }
+                    // Save Slack channel resume UUIDs
+                    if (_slackAdapter) {
+                        const registry = _slackAdapter.getChannelRegistry();
+                        for (const [channelId, entry] of Object.entries(registry)) {
+                            const session = runningSessions.find(s => s.tmuxSession === entry.sessionName);
+                            const uuid = _topicResumeMap.findUuidForSession(entry.sessionName, session?.claudeSessionId ?? undefined);
                             if (uuid) {
-                                _topicResumeMap.save(topicId, uuid, sessionName);
+                                _slackAdapter.saveChannelResume(channelId, uuid, entry.sessionName);
                                 saved++;
                             }
                         }
-                        if (saved > 0) {
-                            console.log(`[shutdown] Saved ${saved} resume UUID(s) for active sessions`);
-                        }
+                    }
+                    if (saved > 0) {
+                        console.log(`[shutdown] Saved ${saved} resume UUID(s) for active sessions`);
                     }
                 }
                 catch (err) {