@ashx-j/lunr-dev 0.2.16-dev.9.1 → 0.2.21-dev.12.1

package/dist/builtin-extensions/pi-intercom/index.js

@@ -3,7 +3,7 @@ import { randomUUID } from "crypto";
 import { Type } from "typebox";
 import { Text } from "@ashx-j/lunr-tui";
 import { IntercomClient } from "./broker/client.js";
-import { spawnBrokerIfNeeded } from "./broker/spawn.js";
+import { isNativeSupervisorChannelActive, spawnBrokerIfNeeded } from "./broker/spawn.js";
 import { SessionListOverlay } from "./ui/session-list.js";
 import { ComposeOverlay } from "./ui/compose.js";
 import { InlineMessageComponent } from "./ui/inline-message.js";
@@ -310,7 +310,8 @@ function parseSubagentIntercomPayload(payload) {
         return null;
     }
     const requestId = typeof record.requestId === "string" ? record.requestId : undefined;
-    return { to: record.to, message: record.message, ...(requestId ? { requestId } : {}) };
+    const ownerNotificationSessionId = typeof record.ownerNotificationSessionId === "string" ? record.ownerNotificationSessionId : undefined;
+    return { to: record.to, message: record.message, ...(requestId ? { requestId } : {}), ...(ownerNotificationSessionId ? { ownerNotificationSessionId } : {}) };
 }
 function resolveIntercomPresenceName(sessionName, sessionId) {
     const trimmedName = sessionName?.trim();
@@ -875,6 +876,9 @@ export default function piIntercomExtension(pi) {
         agentRunning = false;
         activeTools.clear();
         startNamePoll();
+        if (isNativeSupervisorChannelActive()) {
+            return;
+        }
         const startupGeneration = runtimeGeneration;
         startupConnectTimer = setTimeout(() => {
             startupConnectTimer = null;
@@ -899,67 +903,70 @@ export default function piIntercomExtension(pi) {
             ...(error ? { error: getErrorMessage(error) } : {}),
         });
     }
+    const resultDeliveries = new Map();
+    const acknowledgedResults = [];
     function relaySubagentIntercomPayload(payload, options) {
         const parsed = parseSubagentIntercomPayload(payload);
         if (!parsed)
             return;
         const relayGeneration = runtimeGeneration;
-        void (async () => {
-            const relayStillLive = () => !runtimeStarted || Boolean(getLiveContext(runtimeContext, relayGeneration));
-            if (!relayStillLive()) {
-                return;
-            }
-            if (currentSessionTargetMatches(parsed.to)) {
-                deliverLocalSubagentRelayMessage(options.sender, options.status, parsed.message);
-                if (options.acknowledge)
-                    emitResultDelivery(parsed.requestId, true);
-                return;
-            }
-            let activeClient;
-            let target;
-            try {
-                activeClient = await ensureConnected("background");
-                target = await resolveSessionTarget(activeClient, parsed.to) ?? parsed.to;
-            }
-            catch (error) {
-                if (!relayStillLive())
-                    return;
-                recordSubagentDeliveryError(options.errorEntryType, parsed.to, parsed.message, error);
-                if (options.acknowledge)
-                    emitResultDelivery(parsed.requestId, false, error);
-                return;
-            }
-            if (!relayStillLive()) {
-                return;
-            }
-            if (currentSessionTargetMatches(parsed.to, target, activeClient)) {
-                deliverLocalSubagentRelayMessage(options.sender, options.status, parsed.message);
-                if (options.acknowledge)
-                    emitResultDelivery(parsed.requestId, true);
+        const deliverLocal = () => {
+            const ctx = getLiveContext(runtimeContext, relayGeneration);
+            const ownerSessionId = ctx?.sessionManager.getSessionFile?.() ?? ctx?.sessionManager.getSessionId();
+            // The owner already receives subagent-notify; keep the relay ACK without another model message.
+            if (options.sender === "subagent-result" && ownerSessionId && parsed.ownerNotificationSessionId === ownerSessionId)
                 return;
-            }
-            try {
-                const result = await activeClient.send(target, { text: parsed.message });
-                if (!relayStillLive())
-                    return;
-                if (!result.delivered) {
-                    const error = new Error(result.reason ?? "Session may not exist or has disconnected.");
-                    recordSubagentDeliveryError(options.errorEntryType, parsed.to, parsed.message, error);
-                    if (options.acknowledge)
-                        emitResultDelivery(parsed.requestId, false, error);
-                    return;
+            deliverLocalSubagentRelayMessage(options.sender, options.status, parsed.message);
+        };
+        const key = options.acknowledge && parsed.requestId ? `${relayGeneration}:${parsed.requestId}` : undefined;
+        let delivery = key ? resultDeliveries.get(key) : undefined;
+        if (!delivery) {
+            delivery = (async () => {
+                const relayStillLive = () => !runtimeStarted || Boolean(getLiveContext(runtimeContext, relayGeneration));
+                try {
+                    if (!relayStillLive())
+                        return false;
+                    if (currentSessionTargetMatches(parsed.to)) {
+                        deliverLocal();
+                        return true;
+                    }
+                    const activeClient = await ensureConnected("background");
+                    const target = await resolveSessionTarget(activeClient, parsed.to) ?? parsed.to;
+                    if (!relayStillLive())
+                        return false;
+                    if (currentSessionTargetMatches(parsed.to, target, activeClient)) {
+                        deliverLocal();
+                        return true;
+                    }
+                    const result = await activeClient.send(target, { text: parsed.message });
+                    if (!result.delivered)
+                        throw new Error(result.reason ?? "Session may not exist or has disconnected.");
+                    return true;
                 }
-                if (options.acknowledge)
-                    emitResultDelivery(parsed.requestId, true);
-            }
-            catch (error) {
-                if (!relayStillLive())
-                    return;
-                recordSubagentDeliveryError(options.errorEntryType, parsed.to, parsed.message, error);
-                if (options.acknowledge)
-                    emitResultDelivery(parsed.requestId, false, error);
+                catch (error) {
+                    if (relayStillLive())
+                        recordSubagentDeliveryError(options.errorEntryType, parsed.to, parsed.message, error);
+                    return false;
+                }
+            })();
+            if (key) {
+                resultDeliveries.set(key, delivery);
+                void delivery.then((delivered) => {
+                    if (!delivered) {
+                        if (resultDeliveries.get(key) === delivery)
+                            resultDeliveries.delete(key);
+                        return;
+                    }
+                    acknowledgedResults.push(key);
+                    while (acknowledgedResults.length > 1024)
+                        resultDeliveries.delete(acknowledgedResults.shift());
+                });
             }
-        })();
+        }
+        void delivery.then((delivered) => {
+            if (options.acknowledge)
+                emitResultDelivery(parsed.requestId, delivered);
+        });
     }
     const unsubscribeSubagentControlIntercom = pi.events.on(SUBAGENT_CONTROL_INTERCOM_EVENT, (payload) => {
         relaySubagentIntercomPayload(payload, {
@@ -1100,7 +1107,8 @@ export default function piIntercomExtension(pi) {
         }
     });
     const childOrchestratorMetadata = readChildOrchestratorMetadata();
-    if (childOrchestratorMetadata) {
+    const nativeSupervisorChannel = isNativeSupervisorChannelActive();
+    if (childOrchestratorMetadata && !nativeSupervisorChannel) {
         pi.registerTool({
             name: "contact_supervisor",
             label: "Contact Supervisor",
@@ -1361,10 +1369,11 @@ export default function piIntercomExtension(pi) {
             },
         });
     }
-    pi.registerTool({
-        name: "intercom",
-        label: "Intercom",
-        description: `Send a message to another pi session running on this machine.
+    if (!nativeSupervisorChannel)
+        pi.registerTool({
+            name: "intercom",
+            label: "Intercom",
+            description: `Send a message to another pi session running on this machine.
 Use this to communicate findings, request help, or coordinate work with other sessions.
 
 Usage:
@@ -1374,158 +1383,131 @@ Usage:
   intercom({ action: "reply", message: "..." })                      → Reply to the active/single pending ask
   intercom({ action: "pending" })                                      → List unresolved inbound asks
   intercom({ action: "status" })                  → Show connection status`,
-        promptSnippet: "Use to coordinate with other local pi sessions: list peers, send updates, ask for help, or check intercom connectivity.",
-        parameters: Type.Object({
-            action: StringEnum(["list", "send", "ask", "reply", "pending", "status"], {
-                description: "Action: 'list', 'send', 'ask', 'reply', 'pending', or 'status'",
+            promptSnippet: "Use to coordinate with other local pi sessions: list peers, send updates, ask for help, or check intercom connectivity.",
+            parameters: Type.Object({
+                action: StringEnum(["list", "send", "ask", "reply", "pending", "status"], {
+                    description: "Action: 'list', 'send', 'ask', 'reply', 'pending', or 'status'",
+                }),
+                to: Type.Optional(Type.String({
+                    description: "Target session name or ID (for 'send', 'ask', or disambiguating 'reply')",
+                })),
+                message: Type.Optional(Type.String({
+                    description: "Message to send (for 'send', 'ask', or 'reply' action)",
+                })),
+                attachments: Type.Optional(Type.Array(Type.Object({
+                    type: StringEnum(["file", "snippet", "context"]),
+                    name: Type.String(),
+                    content: Type.String(),
+                    language: Type.Optional(Type.String()),
+                }))),
+                replyTo: Type.Optional(Type.String({
+                    description: "Message ID to reply to (for threading or responding to an 'ask')",
+                })),
             }),
-            to: Type.Optional(Type.String({
-                description: "Target session name or ID (for 'send', 'ask', or disambiguating 'reply')",
-            })),
-            message: Type.Optional(Type.String({
-                description: "Message to send (for 'send', 'ask', or 'reply' action)",
-            })),
-            attachments: Type.Optional(Type.Array(Type.Object({
-                type: StringEnum(["file", "snippet", "context"]),
-                name: Type.String(),
-                content: Type.String(),
-                language: Type.Optional(Type.String()),
-            }))),
-            replyTo: Type.Optional(Type.String({
-                description: "Message ID to reply to (for threading or responding to an 'ask')",
-            })),
-        }),
-        async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-            let connectedClient;
-            try {
-                connectedClient = await ensureConnected("tool");
-            }
-            catch (error) {
-                return {
-                    content: [{ type: "text", text: `Intercom not connected: ${getErrorMessage(error)}` }],
-                    details: { error: true },
-                };
-            }
-            syncPresenceIdentity(ctx.sessionManager.getSessionId());
-            const { action, to, message, attachments, replyTo } = params;
-            switch (action) {
-                case "list": {
-                    try {
-                        const mySessionId = connectedClient.sessionId;
-                        const sessions = await connectedClient.listSessions();
-                        const currentSession = sessions.find(s => s.id === mySessionId);
-                        const otherSessions = sessions.filter(s => s.id !== mySessionId);
-                        if (!currentSession) {
+            async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+                let connectedClient;
+                try {
+                    connectedClient = await ensureConnected("tool");
+                }
+                catch (error) {
+                    return {
+                        content: [{ type: "text", text: `Intercom not connected: ${getErrorMessage(error)}` }],
+                        details: { error: true },
+                    };
+                }
+                syncPresenceIdentity(ctx.sessionManager.getSessionId());
+                const { action, to, message, attachments, replyTo } = params;
+                switch (action) {
+                    case "list": {
+                        try {
+                            const mySessionId = connectedClient.sessionId;
+                            const sessions = await connectedClient.listSessions();
+                            const currentSession = sessions.find(s => s.id === mySessionId);
+                            const otherSessions = sessions.filter(s => s.id !== mySessionId);
+                            if (!currentSession) {
+                                return {
+                                    content: [{ type: "text", text: "Current session is missing from intercom session list." }],
+                                    details: { error: true },
+                                };
+                            }
+                            const currentSection = `**Current session:**\n${formatSessionListRow(currentSession, currentSession.cwd, true)}`;
+                            const otherSection = otherSessions.length === 0
+                                ? "**Other sessions:**\nNo other sessions connected."
+                                : `**Other sessions:**\n${otherSessions.map(s => formatSessionListRow(s, currentSession.cwd, false)).join("\n")}`;
+                            return {
+                                content: [{ type: "text", text: `${currentSection}\n\n${otherSection}` }],
+                                details: {},
+                            };
+                        }
+                        catch (error) {
                             return {
-                                content: [{ type: "text", text: "Current session is missing from intercom session list." }],
+                                content: [{ type: "text", text: `Failed to list sessions: ${getErrorMessage(error)}` }],
                                 details: { error: true },
                             };
                         }
-                        const currentSection = `**Current session:**\n${formatSessionListRow(currentSession, currentSession.cwd, true)}`;
-                        const otherSection = otherSessions.length === 0
-                            ? "**Other sessions:**\nNo other sessions connected."
-                            : `**Other sessions:**\n${otherSessions.map(s => formatSessionListRow(s, currentSession.cwd, false)).join("\n")}`;
-                        return {
-                            content: [{ type: "text", text: `${currentSection}\n\n${otherSection}` }],
-                            details: {},
-                        };
-                    }
-                    catch (error) {
-                        return {
-                            content: [{ type: "text", text: `Failed to list sessions: ${getErrorMessage(error)}` }],
-                            details: { error: true },
-                        };
-                    }
-                }
-                case "send": {
-                    if (!to || !message) {
-                        return {
-                            content: [{ type: "text", text: "Missing 'to' or 'message' parameter" }],
-                            details: { error: true },
-                        };
                     }
-                    try {
-                        const sendTo = await resolveSessionTarget(connectedClient, to) ?? to;
-                        if (sendTo === connectedClient.sessionId) {
+                    case "send": {
+                        if (!to || !message) {
                             return {
-                                content: [{ type: "text", text: "Cannot message the current session" }],
+                                content: [{ type: "text", text: "Missing 'to' or 'message' parameter" }],
                                 details: { error: true },
                             };
                         }
-                        if (!replyTo && config.confirmSend && ctx.hasUI) {
-                            const attachmentText = attachments?.length ? formatAttachments(attachments) : "";
-                            const confirmed = await ctx.ui.confirm("Send Message", `Send to "${to}":\n\n${message}${attachmentText}`);
-                            if (!confirmed) {
+                        try {
+                            const sendTo = await resolveSessionTarget(connectedClient, to) ?? to;
+                            if (sendTo === connectedClient.sessionId) {
                                 return {
-                                    content: [{ type: "text", text: "Message cancelled by user" }],
-                                    details: {},
+                                    content: [{ type: "text", text: "Cannot message the current session" }],
+                                    details: { error: true },
                                 };
                             }
-                        }
-                        const result = await connectedClient.send(sendTo, {
-                            text: message,
-                            attachments,
-                            replyTo,
-                        });
-                        if (!result.delivered) {
-                            const errorText = result.reason ?? "Session may not exist or has disconnected.";
+                            if (!replyTo && config.confirmSend && ctx.hasUI) {
+                                const attachmentText = attachments?.length ? formatAttachments(attachments) : "";
+                                const confirmed = await ctx.ui.confirm("Send Message", `Send to "${to}":\n\n${message}${attachmentText}`);
+                                if (!confirmed) {
+                                    return {
+                                        content: [{ type: "text", text: "Message cancelled by user" }],
+                                        details: {},
+                                    };
+                                }
+                            }
+                            const result = await connectedClient.send(sendTo, {
+                                text: message,
+                                attachments,
+                                replyTo,
+                            });
+                            if (!result.delivered) {
+                                const errorText = result.reason ?? "Session may not exist or has disconnected.";
+                                return {
+                                    content: [{ type: "text", text: `Message to "${to}" was not delivered: ${errorText}` }],
+                                    details: { messageId: result.id, delivered: false, reason: result.reason },
+                                };
+                            }
+                            pi.appendEntry("intercom_sent", {
+                                to,
+                                message: { text: message, attachments, replyTo },
+                                messageId: result.id,
+                                timestamp: Date.now(),
+                            });
+                            if (replyTo) {
+                                replyTracker.markReplied(replyTo);
+                            }
                             return {
-                                content: [{ type: "text", text: `Message to "${to}" was not delivered: ${errorText}` }],
-                                details: { messageId: result.id, delivered: false, reason: result.reason },
+                                content: [{ type: "text", text: `Message sent to ${to}` }],
+                                details: { messageId: result.id, delivered: true },
                             };
                         }
-                        pi.appendEntry("intercom_sent", {
-                            to,
-                            message: { text: message, attachments, replyTo },
-                            messageId: result.id,
-                            timestamp: Date.now(),
-                        });
-                        if (replyTo) {
-                            replyTracker.markReplied(replyTo);
-                        }
-                        return {
-                            content: [{ type: "text", text: `Message sent to ${to}` }],
-                            details: { messageId: result.id, delivered: true },
-                        };
-                    }
-                    catch (error) {
-                        return {
-                            content: [{ type: "text", text: `Failed to send: ${getErrorMessage(error)}` }],
-                            details: { error: true },
-                        };
-                    }
-                }
-                case "ask": {
-                    if (!to || !message) {
-                        return {
-                            content: [{ type: "text", text: "Missing 'to' or 'message' parameter" }],
-                            details: { error: true },
-                        };
-                    }
-                    if (replyWaiter) {
-                        return {
-                            content: [{ type: "text", text: "Already waiting for a reply" }],
-                            details: { error: true },
-                        };
-                    }
-                    if (_signal?.aborted) {
-                        return {
-                            content: [{ type: "text", text: "Cancelled" }],
-                            details: { error: true },
-                        };
-                    }
-                    let replyPromise = null;
-                    try {
-                        const sendTo = await resolveSessionTarget(connectedClient, to) ?? to;
-                        if (_signal?.aborted) {
+                        catch (error) {
                             return {
-                                content: [{ type: "text", text: "Cancelled" }],
+                                content: [{ type: "text", text: `Failed to send: ${getErrorMessage(error)}` }],
                                 details: { error: true },
                             };
                         }
-                        if (sendTo === connectedClient.sessionId) {
+                    }
+                    case "ask": {
+                        if (!to || !message) {
                             return {
-                                content: [{ type: "text", text: "Cannot message the current session" }],
+                                content: [{ type: "text", text: "Missing 'to' or 'message' parameter" }],
                                 details: { error: true },
                             };
                         }
@@ -1535,198 +1517,225 @@ Usage:
                                 details: { error: true },
                             };
                         }
-                        const questionId = randomUUID();
-                        replyPromise = waitForReply(sendTo, questionId, _signal, () => connectedClient.cancelAsk(questionId));
-                        replyPromise.catch(() => undefined);
-                        const sendResult = await connectedClient.send(sendTo, {
-                            messageId: questionId,
-                            text: message,
-                            attachments,
-                            replyTo,
-                            expectsReply: true,
-                        });
-                        if (!sendResult.delivered) {
-                            const errorText = sendResult.reason ?? "Session may not exist or has disconnected.";
-                            rejectReplyWaiter(new Error(`Message to "${to}" was not delivered: ${errorText}`));
+                        if (_signal?.aborted) {
+                            return {
+                                content: [{ type: "text", text: "Cancelled" }],
+                                details: { error: true },
+                            };
+                        }
+                        let replyPromise = null;
+                        try {
+                            const sendTo = await resolveSessionTarget(connectedClient, to) ?? to;
+                            if (_signal?.aborted) {
+                                return {
+                                    content: [{ type: "text", text: "Cancelled" }],
+                                    details: { error: true },
+                                };
+                            }
+                            if (sendTo === connectedClient.sessionId) {
+                                return {
+                                    content: [{ type: "text", text: "Cannot message the current session" }],
+                                    details: { error: true },
+                                };
+                            }
+                            if (replyWaiter) {
+                                return {
+                                    content: [{ type: "text", text: "Already waiting for a reply" }],
+                                    details: { error: true },
+                                };
+                            }
+                            const questionId = randomUUID();
+                            replyPromise = waitForReply(sendTo, questionId, _signal, () => connectedClient.cancelAsk(questionId));
+                            replyPromise.catch(() => undefined);
+                            const sendResult = await connectedClient.send(sendTo, {
+                                messageId: questionId,
+                                text: message,
+                                attachments,
+                                replyTo,
+                                expectsReply: true,
+                            });
+                            if (!sendResult.delivered) {
+                                const errorText = sendResult.reason ?? "Session may not exist or has disconnected.";
+                                rejectReplyWaiter(new Error(`Message to "${to}" was not delivered: ${errorText}`));
+                                if (replyPromise) {
+                                    try {
+                                        await replyPromise;
+                                    }
+                                    catch {
+                                        // The waiter was already rejected above. Keep the delivery failure as the only error here.
+                                    }
+                                }
+                                return {
+                                    content: [{ type: "text", text: `Message to "${to}" was not delivered: ${errorText}` }],
+                                    details: { error: true },
+                                };
+                            }
+                            pi.appendEntry("intercom_sent", {
+                                to,
+                                message: { text: message, attachments, replyTo },
+                                messageId: sendResult.id,
+                                timestamp: Date.now(),
+                            });
+                            const replyMessage = await replyPromise;
+                            const replyText = replyMessage.content.text;
+                            const replyAttachments = replyMessage.content.attachments?.length
+                                ? formatAttachments(replyMessage.content.attachments)
+                                : "";
+                            pi.appendEntry("intercom_received", {
+                                from: to,
+                                message: { text: replyText, attachments: replyMessage.content.attachments },
+                                messageId: replyMessage.id,
+                                timestamp: replyMessage.timestamp,
+                            });
+                            return {
+                                content: [{ type: "text", text: `**Reply from ${to}:**\n${replyText}${replyAttachments}` }],
+                                details: {},
+                            };
+                        }
+                        catch (error) {
+                            rejectReplyWaiter(toError(error));
                             if (replyPromise) {
                                 try {
                                     await replyPromise;
                                 }
                                 catch {
-                                    // The waiter was already rejected above. Keep the delivery failure as the only error here.
+                                    // The waiter is cleanup-only on this path. The real failure is the one from the outer catch.
                                 }
                             }
                             return {
-                                content: [{ type: "text", text: `Message to "${to}" was not delivered: ${errorText}` }],
+                                content: [{ type: "text", text: `Failed: ${getErrorMessage(error)}` }],
                                 details: { error: true },
                             };
                         }
-                        pi.appendEntry("intercom_sent", {
-                            to,
-                            message: { text: message, attachments, replyTo },
-                            messageId: sendResult.id,
-                            timestamp: Date.now(),
-                        });
-                        const replyMessage = await replyPromise;
-                        const replyText = replyMessage.content.text;
-                        const replyAttachments = replyMessage.content.attachments?.length
-                            ? formatAttachments(replyMessage.content.attachments)
-                            : "";
-                        pi.appendEntry("intercom_received", {
-                            from: to,
-                            message: { text: replyText, attachments: replyMessage.content.attachments },
-                            messageId: replyMessage.id,
-                            timestamp: replyMessage.timestamp,
-                        });
-                        return {
-                            content: [{ type: "text", text: `**Reply from ${to}:**\n${replyText}${replyAttachments}` }],
-                            details: {},
-                        };
                     }
-                    catch (error) {
-                        rejectReplyWaiter(toError(error));
-                        if (replyPromise) {
-                            try {
-                                await replyPromise;
+                    case "reply": {
+                        if (!message) {
+                            return {
+                                content: [{ type: "text", text: "Missing 'message' parameter" }],
+                                details: { error: true },
+                            };
+                        }
+                        try {
+                            const target = replyTracker.resolveReplyTarget({ to, replyTo });
+                            if (target.from.id === connectedClient.sessionId) {
+                                return {
+                                    content: [{ type: "text", text: "Cannot message the current session" }],
+                                    details: { error: true },
+                                };
                             }
-                            catch {
-                                // The waiter is cleanup-only on this path. The real failure is the one from the outer catch.
+                            const result = await connectedClient.send(target.from.id, {
+                                text: message,
+                                replyTo: target.message.id,
+                            });
+                            if (!result.delivered) {
+                                const errorText = result.reason ?? "Session may not exist or has disconnected.";
+                                if (result.reason === "Session not found") {
+                                    replyTracker.dismissPendingAsk(target.message.id);
+                                }
+                                return {
+                                    content: [{ type: "text", text: `Reply to "${target.from.name || target.from.id}" was not delivered: ${errorText}` }],
+                                    details: { messageId: result.id, delivered: false, reason: result.reason },
+                                };
                             }
+                            replyTracker.markReplied(target.message.id);
+                            pi.appendEntry("intercom_sent", {
+                                to: target.from.name || target.from.id,
+                                message: { text: message, replyTo: target.message.id },
+                                messageId: result.id,
+                                timestamp: Date.now(),
+                            });
+                            return {
+                                content: [{ type: "text", text: `Reply sent to ${target.from.name || target.from.id}` }],
+                                details: { messageId: result.id, delivered: true, replyTo: target.message.id },
+                            };
                         }
-                        return {
-                            content: [{ type: "text", text: `Failed: ${getErrorMessage(error)}` }],
-                            details: { error: true },
-                        };
-                    }
-                }
-                case "reply": {
-                    if (!message) {
-                        return {
-                            content: [{ type: "text", text: "Missing 'message' parameter" }],
-                            details: { error: true },
-                        };
-                    }
-                    try {
-                        const target = replyTracker.resolveReplyTarget({ to, replyTo });
-                        if (target.from.id === connectedClient.sessionId) {
+                        catch (error) {
                             return {
-                                content: [{ type: "text", text: "Cannot message the current session" }],
+                                content: [{ type: "text", text: `Failed to reply: ${getErrorMessage(error)}` }],
                                 details: { error: true },
                             };
                         }
-                        const result = await connectedClient.send(target.from.id, {
-                            text: message,
-                            replyTo: target.message.id,
-                        });
-                        if (!result.delivered) {
-                            const errorText = result.reason ?? "Session may not exist or has disconnected.";
-                            if (result.reason === "Session not found") {
-                                replyTracker.dismissPendingAsk(target.message.id);
-                            }
+                    }
+                    case "pending": {
+                        const pendingAsks = replyTracker.listPending();
+                        if (pendingAsks.length === 0) {
                             return {
-                                content: [{ type: "text", text: `Reply to "${target.from.name || target.from.id}" was not delivered: ${errorText}` }],
-                                details: { messageId: result.id, delivered: false, reason: result.reason },
+                                content: [{ type: "text", text: "No unresolved inbound asks." }],
+                                details: {},
                             };
                         }
-                        replyTracker.markReplied(target.message.id);
-                        pi.appendEntry("intercom_sent", {
-                            to: target.from.name || target.from.id,
-                            message: { text: message, replyTo: target.message.id },
-                            messageId: result.id,
-                            timestamp: Date.now(),
+                        const now = Date.now();
+                        const lines = pendingAsks.map(({ from, message, receivedAt }) => {
+                            const preview = message.content.text.replace(/\s+/g, " ").slice(0, 80);
+                            const elapsedSeconds = Math.max(0, Math.floor((now - receivedAt) / 1000));
+                            return `- ${from.name || from.id} · ${message.id} · ${elapsedSeconds}s ago · ${preview}`;
                         });
                         return {
-                            content: [{ type: "text", text: `Reply sent to ${target.from.name || target.from.id}` }],
-                            details: { messageId: result.id, delivered: true, replyTo: target.message.id },
-                        };
-                    }
-                    catch (error) {
-                        return {
-                            content: [{ type: "text", text: `Failed to reply: ${getErrorMessage(error)}` }],
-                            details: { error: true },
-                        };
-                    }
-                }
-                case "pending": {
-                    const pendingAsks = replyTracker.listPending();
-                    if (pendingAsks.length === 0) {
-                        return {
-                            content: [{ type: "text", text: "No unresolved inbound asks." }],
+                            content: [{ type: "text", text: `**Pending asks:**\n${lines.join("\n")}` }],
                             details: {},
                         };
                     }
-                    const now = Date.now();
-                    const lines = pendingAsks.map(({ from, message, receivedAt }) => {
-                        const preview = message.content.text.replace(/\s+/g, " ").slice(0, 80);
-                        const elapsedSeconds = Math.max(0, Math.floor((now - receivedAt) / 1000));
-                        return `- ${from.name || from.id} · ${message.id} · ${elapsedSeconds}s ago · ${preview}`;
-                    });
-                    return {
-                        content: [{ type: "text", text: `**Pending asks:**\n${lines.join("\n")}` }],
-                        details: {},
-                    };
-                }
-                case "status": {
-                    try {
-                        const mySessionId = connectedClient.sessionId;
-                        const sessions = await connectedClient.listSessions();
-                        return {
-                            content: [{
-                                    type: "text",
-                                    text: `**Intercom Status:**\nConnected: Yes\nSession ID: ${mySessionId}\nActive sessions: ${sessions.length}`,
-                                }],
-                            details: {},
-                        };
+                    case "status": {
+                        try {
+                            const mySessionId = connectedClient.sessionId;
+                            const sessions = await connectedClient.listSessions();
+                            return {
+                                content: [{
+                                        type: "text",
+                                        text: `**Intercom Status:**\nConnected: Yes\nSession ID: ${mySessionId}\nActive sessions: ${sessions.length}`,
+                                    }],
+                                details: {},
+                            };
+                        }
+                        catch (error) {
+                            return {
+                                content: [{ type: "text", text: `Failed to get status: ${getErrorMessage(error)}` }],
+                                details: { error: true },
+                            };
+                        }
                     }
-                    catch (error) {
+                    default:
                         return {
-                            content: [{ type: "text", text: `Failed to get status: ${getErrorMessage(error)}` }],
+                            content: [{ type: "text", text: `Unknown action: ${action}` }],
                             details: { error: true },
                         };
-                    }
                 }
-                default:
-                    return {
-                        content: [{ type: "text", text: `Unknown action: ${action}` }],
-                        details: { error: true },
-                    };
-            }
-        },
-        renderCall(args, theme) {
-            const action = typeof args.action === "string" ? args.action : "intercom";
-            const target = typeof args.to === "string" && args.to.trim() ? args.to.trim() : undefined;
-            const messagePreview = previewText(args.message, 96);
-            const attachmentCount = Array.isArray(args.attachments) ? args.attachments.length : 0;
-            let text = theme.fg("toolTitle", theme.bold("intercom "));
-            text += theme.fg(action === "ask" ? "warning" : action === "reply" ? "success" : "accent", action);
-            if (target) {
-                text += " " + theme.fg("muted", "→") + " " + theme.fg("accent", target);
-            }
-            if (attachmentCount > 0) {
-                text += " " + theme.fg("dim", `(${attachmentCount} attachment${attachmentCount === 1 ? "" : "s"})`);
-            }
-            if (messagePreview) {
-                text += "\n  " + theme.fg("dim", messagePreview);
-            }
-            return new Text(text, 0, 0);
-        },
-        renderResult(result, { isPartial }, theme, context) {
-            if (isPartial) {
-                return new Text(theme.fg("warning", "Intercom working..."), 0, 0);
-            }
-            const details = result.details;
-            const failed = Boolean(context.isError || details?.error === true || details?.delivered === false);
-            let text = failed ? theme.fg("error", "✗ ") : theme.fg("success", "✓ ");
-            text += theme.fg(failed ? "error" : "text", firstTextContent(result));
-            if (details?.messageId && !context.expanded) {
-                text += theme.fg("dim", ` (${details.messageId.slice(0, 8)})`);
-            }
-            if (details?.reason && context.expanded) {
-                text += "\n" + theme.fg("dim", `Reason: ${details.reason}`);
-            }
-            return new Text(text, 0, 0);
-        },
-    });
+            },
+            renderCall(args, theme) {
+                const action = typeof args.action === "string" ? args.action : "intercom";
+                const target = typeof args.to === "string" && args.to.trim() ? args.to.trim() : undefined;
+                const messagePreview = previewText(args.message, 96);
+                const attachmentCount = Array.isArray(args.attachments) ? args.attachments.length : 0;
+                let text = theme.fg("toolTitle", theme.bold("intercom "));
+                text += theme.fg(action === "ask" ? "warning" : action === "reply" ? "success" : "accent", action);
+                if (target) {
+                    text += " " + theme.fg("muted", "→") + " " + theme.fg("accent", target);
+                }
+                if (attachmentCount > 0) {
+                    text += " " + theme.fg("dim", `(${attachmentCount} attachment${attachmentCount === 1 ? "" : "s"})`);
+                }
+                if (messagePreview) {
+                    text += "\n  " + theme.fg("dim", messagePreview);
+                }
+                return new Text(text, 0, 0);
+            },
+            renderResult(result, { isPartial }, theme, context) {
+                if (isPartial) {
+                    return new Text(theme.fg("warning", "Intercom working..."), 0, 0);
+                }
+                const details = result.details;
+                const failed = Boolean(context.isError || details?.error === true || details?.delivered === false);
+                let text = failed ? theme.fg("error", "✗ ") : theme.fg("success", "✓ ");
+                text += theme.fg(failed ? "error" : "text", firstTextContent(result));
+                if (details?.messageId && !context.expanded) {
+                    text += theme.fg("dim", ` (${details.messageId.slice(0, 8)})`);
+                }
+                if (details?.reason && context.expanded) {
+                    text += "\n" + theme.fg("dim", `Reason: ${details.reason}`);
+                }
+                return new Text(text, 0, 0);
+            },
+        });
     async function openIntercomOverlay(ctx) {
         const overlayGeneration = runtimeGeneration;
         const liveContext = getLiveContext(ctx, overlayGeneration);