instar 0.25.1 → 0.25.2

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,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"}

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,21 +2825,31 @@ 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();
@@ -4336,23 +4431,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) {