instar 0.26.11 → 0.27.2

package/dist/commands/server.js

@@ -93,6 +93,7 @@ import { createMessagingProbes } from '../monitoring/probes/MessagingProbe.js';
 import { createLifelineProbes } from '../monitoring/probes/LifelineProbe.js';
 import { createPlatformProbes } from '../monitoring/probes/PlatformProbe.js';
 import { bootstrapThreadline } from '../threadline/ThreadlineBootstrap.js';
+import { createUnifiedTrustSystem } from '../threadline/UnifiedTrustWiring.js';
 import { toInjection } from '../types/pipeline.js';
 import { UserManager } from '../users/UserManager.js';
 import { formatUserContextForSession, hasUserContext } from '../users/UserContextBuilder.js';
@@ -2884,7 +2885,8 @@ export async function startServer(options) {
             sessionManager.on('beforeSessionKill', (session) => {
                 try {
                     // Save Telegram topic resume UUID (if Telegram is configured)
-                    if (telegram) {
+                    // Skip for context exhaustion kills — re-saving would cause a death loop
+                    if (telegram && !contextExhaustionKills.has(session.tmuxSession)) {
                         const topicId = telegram.getTopicForSession(session.tmuxSession);
                         if (topicId) {
                             const uuid = _topicResumeMap.findUuidForSession(session.tmuxSession, session.claudeSessionId ?? undefined);
@@ -2895,7 +2897,9 @@ export async function startServer(options) {
                         }
                     }
                     // Save Slack channel resume UUID (if Slack is configured)
-                    if (_slackAdapter) {
+                    // Skip if the session is being killed for context exhaustion — saving the UUID
+                    // would cause a death loop where the next respawn loads the same bloated conversation.
+                    if (_slackAdapter && !contextExhaustionKills.has(session.tmuxSession)) {
                         const channelId = _slackAdapter.getChannelForSession(session.tmuxSession);
                         if (channelId) {
                             const uuid = _topicResumeMap.findUuidForSession(session.tmuxSession, session.claudeSessionId ?? undefined);
@@ -2905,6 +2909,9 @@ export async function startServer(options) {
                             }
                         }
                     }
+                    else if (contextExhaustionKills.has(session.tmuxSession)) {
+                        console.log(`[beforeSessionKill] Skipping Slack resume UUID save for ${session.name} — context exhaustion recovery`);
+                    }
                 }
                 catch (err) {
                     console.error(`[beforeSessionKill] Failed to save resume UUID:`, err);
@@ -3076,6 +3083,9 @@ export async function startServer(options) {
                 sendToTopic: async (topicId, text) => {
                     const slackChId = slackProxyChannelMap.get(topicId);
                     if (slackChId && _slackAdapter) {
+                        // Never send monitoring messages to system channels (dashboard, lifeline)
+                        if (_slackAdapter.isSystemChannel(slackChId))
+                            return;
                         await _slackAdapter.sendToChannel(slackChId, text);
                         return;
                     }
@@ -3152,6 +3162,8 @@ export async function startServer(options) {
                 sendToTopic: async (topicId, text) => {
                     const slackChId = slackProxyChannelMap.get(topicId);
                     if (slackChId && _slackAdapter) {
+                        if (_slackAdapter.isSystemChannel(slackChId))
+                            return;
                         await _slackAdapter.sendToChannel(slackChId, text);
                         return;
                     }
@@ -3245,6 +3257,9 @@ export async function startServer(options) {
         // SessionRecovery — fast mechanical recovery (JSONL analysis, no LLM)
         // Platform-aware: works with Telegram topics AND Slack channels
         let sessionRecovery;
+        // Track sessions being killed for context exhaustion — prevents beforeSessionKill
+        // from re-saving resume UUIDs (which would cause an infinite death loop)
+        const contextExhaustionKills = new Set();
         if (telegram || _slackAdapter) {
             sessionRecovery = new SessionRecovery({ enabled: true, projectDir: config.projectDir }, {
                 isSessionAlive: (name) => sessionManager.isSessionAlive(name),
@@ -3307,18 +3322,95 @@ export async function startServer(options) {
                 },
                 respawnSessionFresh: async (topicId, _sessionName, recoveryPrompt) => {
                     // Fresh respawn for context exhaustion — explicitly clear resume UUID
-                    // so the new session starts clean with telegram history, not --resume.
+                    // so the new session starts clean with history, not --resume.
                     if (_topicResumeMap) {
                         _topicResumeMap.remove(topicId);
                     }
+                    // Check if this is a Slack channel (synthetic negative topic IDs)
+                    let slackChId = slackProxyChannelMap.get(topicId);
+                    // Fallback: reverse-lookup from adapter channel registry if map doesn't have it
+                    if (!slackChId && _slackAdapter && topicId < 0) {
+                        const registry = _slackAdapter.getChannelRegistry();
+                        for (const channelId of Object.keys(registry)) {
+                            if (slackChannelToSyntheticId(channelId) === topicId) {
+                                slackChId = channelId;
+                                break;
+                            }
+                        }
+                        if (slackChId) {
+                            console.log(`[respawnSessionFresh] Resolved slackChId=${slackChId} via reverse lookup (map miss for topicId=${topicId})`);
+                        }
+                    }
+                    console.log(`[respawnSessionFresh] topicId=${topicId} slackChId=${slackChId || 'none'} slackAdapter=${!!_slackAdapter} session=${_sessionName} mapSize=${slackProxyChannelMap.size}`);
+                    if (slackChId && _slackAdapter) {
+                        // Kill existing session (already flagged in contextExhaustionKills via event listener)
+                        const session = sessionManager.listRunningSessions().find(s => s.tmuxSession === _sessionName);
+                        if (session)
+                            sessionManager.killSession(session.id);
+                        // Clear the channel resume so the new session starts fresh
+                        _slackAdapter.removeChannelResume(slackChId);
+                        // Spawn a fresh session with recovery context
+                        await new Promise(resolve => setTimeout(resolve, 2000));
+                        // Build a recovery bootstrap message with thread history
+                        const history = _slackAdapter.getChannelMessages(slackChId, 30);
+                        const botUserId = _slackAdapter.getBotUserId?.() ?? null;
+                        const lines = [];
+                        lines.push(`[RECOVERY] Previous session hit the context window limit. This is a FRESH restart with thread history.`);
+                        if (recoveryPrompt)
+                            lines.push(recoveryPrompt);
+                        lines.push('');
+                        lines.push(`--- Thread History (last ${history.length} messages) ---`);
+                        for (const m of history) {
+                            const date = new Date(parseFloat(m.ts) * 1000);
+                            const time = date.toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit', second: '2-digit', hour12: false });
+                            const isBot = botUserId && m.user === botUserId;
+                            const label = isBot ? 'Agent' : m.user;
+                            lines.push(`[${time}] ${label}: ${m.text}`);
+                        }
+                        lines.push('--- End Thread History ---');
+                        lines.push('');
+                        lines.push('CRITICAL: You MUST relay your response back to Slack.');
+                        lines.push(`cat <<'EOF' | .claude/scripts/slack-reply.sh ${slackChId}`);
+                        lines.push('Your response text here');
+                        lines.push('EOF');
+                        const tmpDir = '/tmp/instar-slack';
+                        fs.mkdirSync(tmpDir, { recursive: true });
+                        const ctxPath = path.join(tmpDir, `recovery-${slackChId}-${Date.now()}.txt`);
+                        const contextData = lines.join('\n');
+                        fs.writeFileSync(ctxPath, contextData);
+                        const bootstrapMessage = `[slack:${slackChId}] [RECOVERY] Context exhaustion — session restarted fresh. (IMPORTANT: Read ${ctxPath} for thread history and Slack relay instructions — you MUST relay your response back.)`;
+                        try {
+                            const newSessionName = await sessionManager.spawnInteractiveSession(bootstrapMessage);
+                            if (newSessionName) {
+                                _slackAdapter.registerChannelSession(slackChId, newSessionName);
+                                console.log(`[slack→recovery] Fresh session "${newSessionName}" spawned for channel ${slackChId} (context exhaustion recovery)`);
+                            }
+                        }
+                        catch (err) {
+                            console.error(`[slack→recovery] Fresh session spawn failed for ${slackChId}: ${err instanceof Error ? err.message : err}`);
+                        }
+                        return;
+                    }
                     if (telegram) {
                         const targetSession = telegram.getSessionForTopic(topicId);
-                        if (!targetSession)
+                        if (!targetSession) {
+                            console.warn(`[respawnSessionFresh] No Telegram or Slack session found for topicId=${topicId} — recovery has no target`);
                             return;
+                        }
                         await respawnSessionForTopic(sessionManager, telegram, targetSession, topicId, undefined, topicMemory, undefined, recoveryPrompt, { silent: true });
                     }
+                    else if (!slackChId) {
+                        console.warn(`[respawnSessionFresh] No platform handler for topicId=${topicId} — recovery is a no-op`);
+                    }
                 },
             });
+            // Track context exhaustion kills to prevent beforeSessionKill from re-saving
+            // resume UUIDs (which would cause an infinite death loop)
+            sessionRecovery.on('recovery:context_exhaustion', ({ sessionName }) => {
+                contextExhaustionKills.add(sessionName);
+                // Clean up after 60 seconds — by then the kill and respawn are done
+                setTimeout(() => contextExhaustionKills.delete(sessionName), 60_000);
+            });
             console.log(pc.green('  Session Recovery enabled (mechanical fast-path)'));
         }
         // SessionMonitor — proactive session health monitoring
@@ -3336,9 +3428,12 @@ export async function startServer(options) {
                         }
                     }
                     // Slack channel sessions (using synthetic IDs)
+                    // Exclude system channels (dashboard, lifeline) — they don't have interactive sessions
                     if (_slackAdapter) {
                         const registry = _slackAdapter.getChannelRegistry();
                         for (const [channelId, entry] of Object.entries(registry)) {
+                            if (_slackAdapter.isSystemChannel(channelId))
+                                continue;
                             const syntheticId = slackChannelToSyntheticId(channelId);
                             sessions.set(syntheticId, entry.sessionName);
                         }
@@ -3367,6 +3462,8 @@ export async function startServer(options) {
                 sendToTopic: async (topicId, text) => {
                     const slackChId = slackProxyChannelMap.get(topicId);
                     if (slackChId && _slackAdapter) {
+                        if (_slackAdapter.isSystemChannel(slackChId))
+                            return;
                         await _slackAdapter.sendToChannel(slackChId, text);
                         return;
                     }
@@ -3582,6 +3679,32 @@ export async function startServer(options) {
         const { HookEventReceiver } = await import('../monitoring/HookEventReceiver.js');
         const hookEventReceiver = new HookEventReceiver({ stateDir: config.stateDir });
         console.log(pc.green('  Hook event receiver enabled'));
+        // Wire PreCompact events to trigger proactive triage after compaction.
+        // When a session compacts, it goes idle at a prompt. If there are unanswered
+        // user messages (common with Telegram/Slack), Pattern 2b will reinject them.
+        if (triageOrchestrator && telegram) {
+            const _triageOrch = triageOrchestrator;
+            const _telegram = telegram;
+            hookEventReceiver.on('PreCompact', () => {
+                // Delay to let compaction + recovery hooks finish
+                setTimeout(() => {
+                    const topicSessions = _telegram.getAllTopicSessions();
+                    for (const [topicId, sessionName] of topicSessions) {
+                        if (!sessionManager.isSessionAlive(sessionName))
+                            continue;
+                        const history = _telegram.getTopicHistory(topicId, 5);
+                        const lastMsg = history[history.length - 1];
+                        if (lastMsg?.fromUser) {
+                            console.log(`[CompactionResume] PreCompact detected, topic ${topicId} has unanswered message — activating triage`);
+                            _triageOrch.activate(topicId, sessionName, 'watchdog', lastMsg.text, Date.now()).catch(err => {
+                                console.warn(`[CompactionResume] Triage activation failed for topic ${topicId}:`, err);
+                            });
+                        }
+                    }
+                }, 10_000);
+            });
+            console.log(pc.green('  Compaction auto-resume wired to triage orchestrator'));
+        }
         // Subagent Tracker — monitors subagent lifecycle via hook events
         const { SubagentTracker } = await import('../monitoring/SubagentTracker.js');
         const subagentTracker = new SubagentTracker({ stateDir: config.stateDir });
@@ -3705,38 +3828,50 @@ export async function startServer(options) {
                 const { PresenceProxy } = await import('../monitoring/PresenceProxy.js');
                 const { execSync: shellExecSync } = await import('child_process');
                 const messagesLogPath = path.join(config.stateDir, 'telegram-messages.jsonl');
+                const slackMessagesLogPath = path.join(config.stateDir, 'slack-messages.jsonl');
+                // Shared helper: check a messages log file for agent responses after a timestamp
+                const checkLogForAgentResponse = (logPath, topicId, sinceIso) => {
+                    try {
+                        const content = fs.readFileSync(logPath, 'utf-8');
+                        const lines = content.trim().split('\n').slice(-50);
+                        for (const line of lines) {
+                            try {
+                                const msg = JSON.parse(line);
+                                // Slack logs use channelId (string); Telegram logs use topicId (number).
+                                // For Slack synthetic IDs (negative), match against channelId via the map.
+                                const matchesTopic = msg.topicId === topicId
+                                    || (topicId < 0 && msg.channelId && slackChannelToSyntheticId(String(msg.channelId)) === topicId);
+                                if (matchesTopic && !msg.fromUser && msg.timestamp > sinceIso) {
+                                    const t = (msg.text || '').trim();
+                                    const isSystem = t === '✓ Delivered' || t.startsWith('✓ Delivered')
+                                        || t.startsWith('🔄 Session restarting') || t === 'Session respawned.'
+                                        || t === 'Session terminated.' || t.startsWith('Send a new message to start')
+                                        || t.startsWith('🔭');
+                                    if (!isSystem)
+                                        return true;
+                                }
+                            }
+                            catch { /* skip malformed lines */ }
+                        }
+                        return false;
+                    }
+                    catch {
+                        return false;
+                    }
+                };
                 presenceProxy = new PresenceProxy({
                     stateDir: config.stateDir,
                     intelligence: sharedIntelligence,
                     agentName: config.projectName ?? 'the agent',
                     hasAgentRespondedSince: (topicId, sinceMs) => {
-                        // Read last ~50 lines of the messages log and check for agent responses
-                        try {
-                            const content = fs.readFileSync(messagesLogPath, 'utf-8');
-                            const lines = content.trim().split('\n').slice(-50);
-                            const sinceIso = new Date(sinceMs).toISOString();
-                            for (const line of lines) {
-                                try {
-                                    const msg = JSON.parse(line);
-                                    if (msg.topicId === topicId && !msg.fromUser && msg.timestamp > sinceIso) {
-                                        // Skip proxy messages and system messages (delivery confirmations, session lifecycle)
-                                        const t = (msg.text || '').trim();
-                                        const isSystem = t === '✓ Delivered' || t.startsWith('✓ Delivered')
-                                            || t.startsWith('🔄 Session restarting') || t === 'Session respawned.'
-                                            || t === 'Session terminated.' || t.startsWith('Send a new message to start')
-                                            || t.startsWith('🔭');
-                                        if (!isSystem) {
-                                            return true;
-                                        }
-                                    }
-                                }
-                                catch { /* skip malformed lines */ }
-                            }
-                            return false;
-                        }
-                        catch {
-                            return false;
-                        }
+                        const sinceIso = new Date(sinceMs).toISOString();
+                        // Check Telegram log
+                        if (checkLogForAgentResponse(messagesLogPath, topicId, sinceIso))
+                            return true;
+                        // Also check Slack log (for Slack synthetic IDs or cross-platform responses)
+                        if (checkLogForAgentResponse(slackMessagesLogPath, topicId, sinceIso))
+                            return true;
+                        return false;
                     },
                     captureSessionOutput: (name, lines) => sessionManager.captureOutput(name, lines),
                     getSessionForTopic: (topicId) => {
@@ -3752,6 +3887,9 @@ export async function startServer(options) {
                         // Check if this is a Slack synthetic ID (negative = Slack channel)
                         const slackChannelId = slackProxyChannelMap.get(topicId);
                         if (slackChannelId && _slackAdapter) {
+                            // Never send proxy messages to system channels (dashboard, lifeline)
+                            if (_slackAdapter.isSystemChannel(slackChannelId))
+                                return;
                             // Route directly to Slack channel
                             await _slackAdapter.sendToChannel(slackChannelId, text);
                             return;
@@ -3825,6 +3963,12 @@ export async function startServer(options) {
                             await triageNurse.triage(topicId, sessionName, '', Date.now(), 'manual');
                         }
                         : undefined,
+                    recoverContextExhaustion: sessionRecovery
+                        ? async (topicId, sessionName) => {
+                            const result = await sessionRecovery.checkAndRecover(topicId, sessionName);
+                            return { recovered: result.recovered };
+                        }
+                        : undefined,
                 });
                 // Hook into Telegram's onMessageLogged callback (always active, unlike EventBus which requires a feature flag)
                 const existingCallback = telegram.onMessageLogged;
@@ -3873,8 +4017,11 @@ export async function startServer(options) {
                             _slackAdapter.clearStallTracking(String(entry.channelId));
                         }
                         // Convert Slack channelId to synthetic numeric ID for PresenceProxy
+                        // Skip system channels (dashboard, lifeline) — they don't have interactive sessions
                         if (!entry.channelId)
                             return;
+                        if (_slackAdapter.isSystemChannel(String(entry.channelId)))
+                            return;
                         const syntheticId = slackChannelToSyntheticId(String(entry.channelId));
                         presenceProxy.onMessageLogged({
                             messageId: typeof entry.messageId === 'number' ? entry.messageId : parseInt(String(entry.messageId), 10) || 0,
@@ -3958,9 +4105,14 @@ export async function startServer(options) {
                             const tunnelUrl = await tunnel.start();
                             console.log(`[SleepWake] Tunnel restarted: ${tunnelUrl}`);
                             // Re-broadcast dashboard URL after tunnel restart (quick tunnels get new URL)
-                            if (telegram && tunnelUrl) {
+                            if (tunnelUrl) {
                                 const tunnelType = config.tunnel?.type || 'quick';
-                                await telegram.broadcastDashboardUrl(tunnelUrl, tunnelType).catch(() => { });
+                                if (telegram) {
+                                    await telegram.broadcastDashboardUrl(tunnelUrl, tunnelType).catch(() => { });
+                                }
+                                if (_slackAdapter) {
+                                    await _slackAdapter.broadcastDashboardUrl(tunnelUrl).catch(() => { });
+                                }
                             }
                         })(),
                         new Promise((_, reject) => setTimeout(() => reject(new Error('Tunnel restart timed out after 15s')), 15_000)),
@@ -3972,6 +4124,21 @@ export async function startServer(options) {
                     tunnel.enableAutoReconnect();
                 }
             }
+            // Reconnect Slack after sleep — WebSocket connections die during sleep
+            // and the close-handler reconnect can silently fail if the network isn't
+            // fully up yet. Proactive reconnect after a short delay is more reliable.
+            if (slackAdapter) {
+                // Wait 2s for network to stabilize after wake before reconnecting
+                setTimeout(async () => {
+                    try {
+                        await slackAdapter.reconnect();
+                        console.log('[SleepWake] Slack reconnected');
+                    }
+                    catch (err) {
+                        console.error('[SleepWake] Slack reconnect failed:', err.message);
+                    }
+                }, 2000);
+            }
             // Notify via batcher — wake events are informational, not urgent
             // Only notify for long sleeps (>5 min) — short sleeps are routine and not worth mentioning
             if (event.sleepDurationSeconds > 300) {
@@ -4399,6 +4566,7 @@ export async function startServer(options) {
         let threadlineHandshake;
         let threadlineShutdown;
         let threadlineRelayClient;
+        let unifiedTrust;
         try {
             const threadline = await bootstrapThreadline({
                 agentName: config.projectName,
@@ -4413,6 +4581,19 @@ export async function startServer(options) {
             threadlineHandshake = threadline.handshakeManager;
             threadlineShutdown = threadline.shutdown;
             threadlineRelayClient = threadline.relayClient;
+            // Initialize unified trust system (three-layer model + MoltBridge)
+            if (threadline.trustManager) {
+                try {
+                    unifiedTrust = createUnifiedTrustSystem(threadline.trustManager, {
+                        stateDir: config.stateDir,
+                        moltbridge: config.moltbridge,
+                    });
+                    console.log(`Unified trust system initialized (identity: ${unifiedTrust.identity.get()?.displayFingerprint ?? 'none'})`);
+                }
+                catch (err) {
+                    console.error(`Unified trust system init failed (non-fatal): ${err instanceof Error ? err.message : err}`);
+                }
+            }
             if (threadlineRelayClient) {
                 // Wire relay message delivery through ThreadlineRouter (Phase 1).
                 // Replaces the ad-hoc handler with proper thread persistence, auto-ack,
@@ -4604,7 +4785,7 @@ export async function startServer(options) {
                 return { content: lines.join('\n'), truncated: false, elapsedMs: Date.now() - start };
             }, { description: 'Feature discovery state and behavioral contract summary' });
         }
-        const server = new AgentServer({ config, sessionManager, state, scheduler, telegram, relationships, feedback, feedbackAnomalyDetector, dispatches, updateChecker, autoUpdater, autoDispatcher, quotaTracker, quotaManager, publisher, viewer, tunnel, evolution, watchdog, topicMemory, triageNurse, projectMapper, coherenceGate: scopeVerifier, contextHierarchy, canonicalState, operationGate, sentinel, adaptiveTrust, memoryMonitor, orphanReaper, coherenceMonitor, commitmentTracker, semanticMemory, activitySentinel, messageRouter, summarySentinel, spawnManager, systemReviewer, capabilityMapper, selfKnowledgeTree, coverageAuditor, topicResumeMap: _topicResumeMap ?? undefined, autonomyManager, trustElevationTracker, autonomousEvolution, coordinator: coordinator.enabled ? coordinator : undefined, localSigningKeyPem, whatsapp: whatsappAdapter, slack: slackAdapter, imessage: imessageAdapter, whatsappBusinessBackend, messageBridge, hookEventReceiver, worktreeMonitor, subagentTracker, instructionsVerifier, handshakeManager: threadlineHandshake, threadlineRouter, threadlineRelayClient, listenerManager: listenerManager ?? undefined, responseReviewGate, telemetryHeartbeat, pasteManager, featureRegistry, discoveryEvaluator, liveConfig });
+        const server = new AgentServer({ config, sessionManager, state, scheduler, telegram, relationships, feedback, feedbackAnomalyDetector, dispatches, updateChecker, autoUpdater, autoDispatcher, quotaTracker, quotaManager, publisher, viewer, tunnel, evolution, watchdog, topicMemory, triageNurse, projectMapper, coherenceGate: scopeVerifier, contextHierarchy, canonicalState, operationGate, sentinel, adaptiveTrust, memoryMonitor, orphanReaper, coherenceMonitor, commitmentTracker, semanticMemory, activitySentinel, messageRouter, summarySentinel, spawnManager, systemReviewer, capabilityMapper, selfKnowledgeTree, coverageAuditor, topicResumeMap: _topicResumeMap ?? undefined, autonomyManager, trustElevationTracker, autonomousEvolution, coordinator: coordinator.enabled ? coordinator : undefined, localSigningKeyPem, whatsapp: whatsappAdapter, slack: slackAdapter, imessage: imessageAdapter, whatsappBusinessBackend, messageBridge, hookEventReceiver, worktreeMonitor, subagentTracker, instructionsVerifier, handshakeManager: threadlineHandshake, threadlineRouter, threadlineRelayClient, listenerManager: listenerManager ?? undefined, responseReviewGate, telemetryHeartbeat, pasteManager, featureRegistry, discoveryEvaluator, unifiedTrust, liveConfig });
         await server.start();
         // Connect DegradationReporter downstream systems now that everything is initialized.
         // Any degradation events queued during startup will drain to feedback + telegram.
@@ -4674,9 +4855,14 @@ export async function startServer(options) {
                         try {
                             const tunnelUrl = await tunnel.start();
                             console.log(pc.green(`[tunnel] Connected: ${tunnelUrl}`));
-                            if (telegram && tunnelUrl) {
+                            if (tunnelUrl) {
                                 const tunnelType = (config.tunnel?.type || 'quick');
-                                await telegram.broadcastDashboardUrl(tunnelUrl, tunnelType).catch(() => { });
+                                if (telegram) {
+                                    await telegram.broadcastDashboardUrl(tunnelUrl, tunnelType).catch(() => { });
+                                }
+                                if (_slackAdapter) {
+                                    await _slackAdapter.broadcastDashboardUrl(tunnelUrl).catch(() => { });
+                                }
                             }
                         }
                         catch (retryErr) {
@@ -4725,6 +4911,12 @@ export async function startServer(options) {
                             telegram.config.dashboardPin = config.dashboardPin || '';
                         }
                         await telegram.broadcastDashboardUrl(dashUrl, tunnelType);
+                        // Also broadcast to Slack dashboard channel if configured
+                        if (_slackAdapter) {
+                            await _slackAdapter.broadcastDashboardUrl(dashUrl).catch((err) => {
+                                console.warn(`[server] Slack dashboard broadcast failed: ${err.message}`);
+                            });
+                        }
                     }
                     else {
                         console.log(pc.yellow(`  Dashboard available locally at http://localhost:${config.port}/dashboard (no tunnel configured — not broadcasting to Telegram)`));