@geminixiang/mikan 1.0.0-beta.7 → 1.0.0-beta.71

package/dist/adapters/slack/response-lifecycle.js

@@ -1,11 +1,23 @@
 import * as log from "../../log.js";
-import { createChatResponseErrorReporter, formatToolArgs, splitText, } from "../shared.js";
-import { BufferedResponseStream } from "../streaming.js";
+import { createProgressiveRenderer } from "../progressive-renderer.js";
+import { formatToolArgs, splitText } from "../shared.js";
 import { buildMrkdwnContextBlock } from "./bot.js";
-const MAX_MAIN_LENGTH = 35000; // Best-effort streaming cap; final responses use Slack error-driven fallback.
+import { renderSlackBlocks } from "./blocks.js";
+import { normalizeSlackCurrencyBold } from "./markdown.js";
+import { slackPersonaForProfile } from "./persona.js";
+const MAX_MAIN_LENGTH = 35000;
+/**
+ * Slack's own SDK buffers streamed output at this size before sending, for
+ * exactly the reason we do: appends are rate-limited per call, so forwarding
+ * every token spends the budget on latency nobody can perceive.
+ */
+const STREAM_MIN_DELTA_CHARS = 256;
 const MAX_THREAD_LENGTH = 20000;
 const FALLBACK_MAIN_LENGTH = 3000;
-const WORKING_INDICATOR = " ...";
+// A separate paragraph preserves a rich_text block while headings/tables grow.
+// Inline suffixes become part of header/table, and Slack can reject replacing
+// an existing rich_text-only message with that non-rich-text-only shape.
+const WORKING_INDICATOR = "\n\n...";
 const TRUNCATION_NOTE_INCREMENTAL = "\n\n_(message truncated, ask me to elaborate on specific parts)_";
 const formatSlackContinuation = (partNum) => `_(continued ${partNum})_`;
 function isSlackMsgTooLong(err) {
@@ -13,28 +25,43 @@ function isSlackMsgTooLong(err) {
     const message = err instanceof Error ? err.message : String(err);
     return data?.error === "msg_too_long" || message.includes("msg_too_long");
 }
+/**
+ * Where to cut a response that has to be truncated.
+ *
+ * Back off to the last line break rather than slicing at the exact budget: a
+ * hard cut lands mid-word, and since the notice is inserted between the two
+ * halves, the line cannot be read whole in either place. Only back off within
+ * reach of the limit — a response with no line break in its final quarter has
+ * nothing better to offer, and losing a quarter of it would be worse.
+ */
+function truncationCut(text, limit) {
+    if (text.length <= limit)
+        return text.length;
+    const lastBreak = text.lastIndexOf("\n", limit);
+    return lastBreak > limit * 0.75 ? lastBreak : limit;
+}
 function fallbackLongSlackText(text, overflowLink, prefixLength = FALLBACK_MAIN_LENGTH) {
     const suffix = overflowLink
         ? `\n\n_(message too long for Slack; continued in thread; session view: <${overflowLink}|open>)_`
         : "\n\n_(message too long for Slack; continued in thread)_";
-    return `${text.slice(0, prefixLength)}${suffix}`;
+    const cut = truncationCut(text, prefixLength);
+    return { text: `${text.slice(0, cut)}${suffix}`, cut };
 }
 async function postSlackTextWithFallback(post, text, overflowLink) {
     let prefixLength = FALLBACK_MAIN_LENGTH;
-    let lastErr;
     for (;;) {
-        const fallbackText = fallbackLongSlackText(text, overflowLink, prefixLength);
+        const fallback = fallbackLongSlackText(text, overflowLink, prefixLength);
         try {
-            const result = await post(fallbackText);
-            return { result, text: fallbackText, prefixLength };
+            await post(fallback.text);
+            // The continuation resumes from where the text was actually cut, which
+            // is not the nominal budget once it backs off to a line break.
+            return { text: fallback.text, prefixLength: fallback.cut };
         }
         catch (err) {
             if (!isSlackMsgTooLong(err))
                 throw err;
-            lastErr = err;
-            if (prefixLength === 0) {
-                throw lastErr instanceof Error ? lastErr : new Error(String(lastErr));
-            }
+            if (prefixLength === 0)
+                throw err;
             prefixLength = Math.max(0, Math.floor(prefixLength / 2));
         }
     }
@@ -51,357 +78,246 @@ function formatSlackToolResult(result) {
     text += `*Result:*\n\`\`\`\n${result.result}\n\`\`\``;
     return text;
 }
-export function createSlackResponseContext({ event, slack, sessionPlan, replyMode, message, }) {
-    let messageTs = sessionPlan.initialMessageTs ?? null;
-    let assistantStatusFailureWarned = false;
-    const onAssistantStatusError = (label, err) => {
-        if (assistantStatusFailureWarned)
+function closeOpenFences(text) {
+    let openMarker = null;
+    for (const line of text.split("\n")) {
+        const marker = line.match(/^\s*(`{3,}|~{3,})/)?.[1];
+        if (marker === undefined)
+            continue;
+        if (openMarker === null)
+            openMarker = marker;
+        else if (marker[0] === openMarker[0] && marker.length >= openMarker.length)
+            openMarker = null;
+    }
+    return openMarker ? `${text}\n${openMarker}` : text;
+}
+function needsCanonicalRender(text) {
+    if (normalizeSlackCurrencyBold(text) !== text)
+        return true;
+    return renderSlackBlocks(text).blocks.some((block) => block.type === "table");
+}
+class SlackResponseLifecycle {
+    constructor(context) {
+        this.context = context;
+        this.assistantStatusFailureWarned = false;
+        this.statusEnded = false;
+        this.statusRequested = false;
+        /** The tail of an over-long response, awaiting delivery to a thread. */
+        this.pendingContinuation = "";
+        this.continuationAnchor = null;
+        /** How much of that tail the thread already holds. */
+        this.continuationSent = "";
+    }
+    onAssistantStatusError(label, err) {
+        if (this.assistantStatusFailureWarned)
             return;
-        assistantStatusFailureWarned = true;
+        this.assistantStatusFailureWarned = true;
         log.logWarning(`Slack setAssistantStatus failed (${label}; further occurrences suppressed for this session)`, err instanceof Error ? err.message : String(err));
-    };
-    const threadMessageTs = [];
-    let accumulatedText = "";
-    let isWorking = true;
-    let mainResponseLogged = false;
-    let streamActive = false;
-    let streamUnavailable = false;
-    let streamedText = "";
-    let updatePromise = Promise.resolve();
-    const channelId = event.channel;
-    const conversationId = event.conversationId;
-    // Slack message timestamps are numeric; event-file triggers use `event:<filename>`.
-    const eventFilename = event.ts.match(/^event:([^:]+(?:\.json)?)/)?.[1];
-    const { rootTs, isThreaded } = sessionPlan;
-    const replyInThread = Boolean(rootTs && (isThreaded || replyMode === "thread"));
-    /**
-     * Post the first visible reply.
-     * Default Slack behavior is now top-level channel replies.
-     * If the triggering message is already inside a thread, stay in that thread.
-     */
-    const postFirstMessage = async (text) => {
-        if (replyInThread && rootTs) {
-            return slack.postInThread(channelId, rootTs, text);
-        }
-        return slack.postMessage(channelId, text);
-    };
-    const postDiagnosticDirect = async (text, options) => {
-        const threadAnchor = messageTs ?? rootTs;
+    }
+    async postThreadDiagnostic(text, options = {}, responseId) {
+        const { event, sessionPlan, slack } = this.context;
+        const threadAnchor = responseId ?? sessionPlan.rootTs;
         if (!threadAnchor)
-            return;
+            return [];
+        const ids = [];
         for (const part of splitText(text, MAX_THREAD_LENGTH, formatSlackContinuation)) {
-            if (options?.style === "muted") {
-                const ts = await slack.postInThreadBlocks(channelId, threadAnchor, part, [
+            if (options.style === "muted") {
+                ids.push(await slack.postInThreadBlocks(event.channel, threadAnchor, part, [
                     buildMrkdwnContextBlock(part),
-                ]);
-                threadMessageTs.push(ts);
+                ]));
             }
             else {
-                const diagnosticText = options?.style === "error" ? `_${part}_` : part;
-                const ts = await slack.postInThread(channelId, threadAnchor, diagnosticText);
-                threadMessageTs.push(ts);
+                ids.push(await slack.postInThread(event.channel, threadAnchor, options.style === "error" ? `_${part}_` : part));
             }
         }
-    };
-    const reportResponseError = createChatResponseErrorReporter(() => ({
-        platform: "slack",
-        conversationId,
-        channelId,
-        messageId: message.id,
-        sessionKey: message.sessionKey,
-        responseMessageId: messageTs,
-        threadTs: rootTs,
-        conversationKind: message.conversationKind,
-        isThreaded,
-    }));
-    const postOrUpdateMain = async (body, handleMsgTooLong = true) => {
-        const writeMain = async (text) => {
-            if (messageTs) {
-                await slack.updateMessage(channelId, messageTs, text);
-                return;
-            }
-            if (replyInThread && rootTs) {
-                messageTs = await slack.postInThread(channelId, rootTs, text);
-                return messageTs;
-            }
-            messageTs = await postFirstMessage(text);
-            return messageTs;
-        };
-        try {
-            await writeMain(body);
-        }
-        catch (err) {
-            if (!handleMsgTooLong || !isSlackMsgTooLong(err))
-                throw err;
-            const fallback = await postSlackTextWithFallback(writeMain, body);
-            accumulatedText = fallback.text;
-            stream.setText(accumulatedText);
-        }
-    };
-    const abandonActiveStream = async () => {
-        if (!streamActive || !messageTs)
+        return ids;
+    }
+    /**
+     * Deliver the tail of an over-long response to its thread.
+     *
+     * Called only at points where the response is final, and idempotent, so the
+     * replace path and the end of the run can both call it without the thread
+     * seeing anything twice. Sending the whole remainder in one message is also
+     * what keeps it faithful: Slack trims message text, so every extra split is
+     * a chance to drop the whitespace it lands on.
+     */
+    async flushContinuation() {
+        if (!this.pendingContinuation || this.pendingContinuation === this.continuationSent)
             return;
-        const failedStreamTs = messageTs;
-        streamActive = false;
-        streamedText = "";
-        await slack.stopMessageStream(channelId, failedStreamTs).catch(() => undefined);
-        if (messageTs === failedStreamTs)
-            messageTs = null;
-    };
-    const startOrAppendStream = async (text, displayText) => {
-        if (streamUnavailable) {
-            await postOrUpdateMain(displayText);
+        const extendsSentPrefix = this.pendingContinuation.startsWith(this.continuationSent);
+        const unsent = extendsSentPrefix
+            ? this.pendingContinuation.slice(this.continuationSent.length)
+            : this.pendingContinuation;
+        if (!unsent.trim())
             return;
+        await this.postThreadDiagnostic(extendsSentPrefix && this.continuationSent
+            ? unsent
+            : `_(continued from truncated message)_\n\n${unsent}`, {}, this.continuationAnchor);
+        this.continuationSent = this.pendingContinuation;
+    }
+    requestStatus(status) {
+        const { event, sessionPlan, slack } = this.context;
+        if (!sessionPlan.rootTs)
+            return;
+        void slack
+            .setAssistantStatus(event.channel, sessionPlan.rootTs, status)
+            .catch((err) => this.onAssistantStatusError(status ? "typing" : "clear-on-idle", err));
+    }
+    endStatus() {
+        if (this.statusEnded)
+            return;
+        this.statusEnded = true;
+        this.requestStatus("");
+    }
+    async deleteMessage(id) {
+        this.endStatus();
+        const { event, slack } = this.context;
+        await slack.deleteMessage(event.channel, id);
+    }
+    async setTyping(isTyping, responseId) {
+        const { eventFilename, sessionPlan } = this.context;
+        if (!isTyping || responseId || !sessionPlan.rootTs || this.statusEnded || this.statusRequested)
+            return;
+        this.statusRequested = true;
+        this.requestStatus(eventFilename ? `Starting event: ${eventFilename}` : "Thinking");
+    }
+    async onWorkingChanged(working) {
+        if (!working)
+            this.endStatus();
+    }
+    async onFinish(text, responseId) {
+        const { event, replyInThread, sessionPlan, slack } = this.context;
+        if (responseId && text.trim()) {
+            slack.logBotResponse(event.channel, text, responseId, replyInThread ? sessionPlan.rootTs : undefined);
         }
-        try {
-            if (messageTs && streamActive) {
-                if (!text.startsWith(streamedText)) {
-                    await abandonActiveStream();
-                    await postOrUpdateMain(displayText);
-                    return;
-                }
-                const delta = text.slice(streamedText.length);
-                if (delta) {
-                    await slack.appendMessageStream(channelId, messageTs, delta);
-                    streamedText = text;
-                }
-                return;
-            }
-            if (!replyInThread || !rootTs) {
-                streamUnavailable = true;
-                await postOrUpdateMain(displayText);
-                return;
-            }
-            messageTs = await slack.startMessageStream(channelId, text, rootTs, event.user);
-            streamActive = true;
-            streamedText = text;
-        }
-        catch (err) {
-            streamUnavailable = true;
-            log.logWarning("Slack streaming unavailable; falling back to chat.update", err instanceof Error ? err.message : String(err));
-            await abandonActiveStream();
-            await postOrUpdateMain(displayText);
-        }
-    };
-    const stream = new BufferedResponseStream({
-        flush: async (text) => {
-            accumulatedText = text;
-            const mainLimit = isWorking ? MAX_MAIN_LENGTH - WORKING_INDICATOR.length : MAX_MAIN_LENGTH;
-            if (accumulatedText.length > mainLimit) {
-                accumulatedText =
-                    accumulatedText.substring(0, mainLimit - TRUNCATION_NOTE_INCREMENTAL.length) +
-                        TRUNCATION_NOTE_INCREMENTAL;
-                stream.setText(accumulatedText);
-            }
-            const displayText = isWorking ? accumulatedText + WORKING_INDICATOR : accumulatedText;
-            await startOrAppendStream(text, displayText);
-        },
-        finish: async (text) => {
-            accumulatedText = text;
-            isWorking = false;
-            if (streamActive && messageTs) {
-                try {
-                    if (!accumulatedText.startsWith(streamedText)) {
-                        await abandonActiveStream();
-                        await postOrUpdateMain(accumulatedText);
-                        return;
-                    }
-                    const delta = accumulatedText.slice(streamedText.length);
-                    if (delta) {
-                        await slack.appendMessageStream(channelId, messageTs, delta);
-                        streamedText = accumulatedText;
-                    }
-                    await slack.stopMessageStream(channelId, messageTs);
-                    streamActive = false;
-                    streamedText = "";
-                    return;
-                }
-                catch (err) {
-                    streamUnavailable = true;
-                    log.logWarning("Slack streaming unavailable; falling back to chat.update", err instanceof Error ? err.message : String(err));
-                    await abandonActiveStream();
-                }
-            }
-            if (messageTs || accumulatedText) {
-                await postOrUpdateMain(accumulatedText);
+        this.endStatus();
+        await this.flushContinuation();
+    }
+    async handleTooLong({ text, operation, options, responseId, write, getResponseId, }) {
+        const { replyInThread, sessionPlan } = this.context;
+        let overflowLink;
+        const resolveOverflowLink = () => {
+            if (overflowLink === undefined && options?.createOverflowLink) {
+                overflowLink = options.createOverflowLink();
             }
-        },
+            return overflowLink;
+        };
+        const fallback = await postSlackTextWithFallback(write, text, resolveOverflowLink());
+        // The truncation notice promises a thread continuation unconditionally,
+        // so every path that prints it has to deliver one. Incremental renders
+        // reach this repeatedly as the text grows, so the tail is only recorded
+        // here and delivered once the response is final. Posting each increment
+        // would also lose whitespace that Slack trims at fragment boundaries.
+        this.pendingContinuation = text.slice(fallback.prefixLength).trimStart();
+        this.continuationAnchor = replyInThread
+            ? (sessionPlan.rootTs ?? getResponseId() ?? responseId)
+            : (getResponseId() ?? responseId);
+        if (operation === "replace")
+            await this.flushContinuation();
+        return fallback;
+    }
+}
+function formatProvisionalSlackText(text, working) {
+    const closed = closeOpenFences(text);
+    return working ? `${closed}${WORKING_INDICATOR}` : closed;
+}
+function prepareSlackSource(text, working) {
+    text = normalizeSlackCurrencyBold(text);
+    const limit = working ? MAX_MAIN_LENGTH - WORKING_INDICATOR.length : MAX_MAIN_LENGTH;
+    if (text.length <= limit)
+        return text;
+    return `${text.slice(0, Math.max(0, limit - TRUNCATION_NOTE_INCREMENTAL.length))}${TRUNCATION_NOTE_INCREMENTAL}`;
+}
+export function createSlackResponseContext({ event, slack, sessionPlan, replyMode, message, }) {
+    const { rootTs, isThreaded } = sessionPlan;
+    const replyInThread = Boolean(rootTs && (isThreaded || replyMode === "thread"));
+    const eventFilename = event.ts.match(/^event:([^:]+(?:\.json)?)/)?.[1];
+    const lifecycle = new SlackResponseLifecycle({
+        event,
+        slack,
+        sessionPlan,
+        replyInThread,
+        eventFilename,
     });
-    const queueResponseOperation = async (label, operation, work, context) => {
-        updatePromise = updatePromise.then(async () => {
-            try {
-                await work();
-            }
-            catch (err) {
-                log.logWarning(`Slack ${label} error`, err instanceof Error ? err.message : String(err));
-                reportResponseError(err, operation, context(err));
-            }
-        });
-        await updatePromise;
-    };
-    const responder = {
-        respond: async (text) => {
-            await queueResponseOperation("respond", "respond", async () => {
-                accumulatedText = accumulatedText ? `${accumulatedText}\n${text}` : text;
-                const mainLimit = isWorking
-                    ? MAX_MAIN_LENGTH - WORKING_INDICATOR.length
-                    : MAX_MAIN_LENGTH;
-                if (accumulatedText.length > mainLimit) {
-                    accumulatedText =
-                        accumulatedText.substring(0, mainLimit - TRUNCATION_NOTE_INCREMENTAL.length) +
-                            TRUNCATION_NOTE_INCREMENTAL;
-                }
-                stream.setText(accumulatedText);
-                const displayText = isWorking ? accumulatedText + WORKING_INDICATOR : accumulatedText;
-                await startOrAppendStream(text, displayText);
-            }, () => ({
-                phase: messageTs ? "update" : "initial_post",
-                textLength: text.length,
-                accumulatedLength: accumulatedText.length,
-            }));
-        },
-        appendResponseDelta: async (delta) => {
-            await queueResponseOperation("appendResponseDelta", "respond", async () => {
-                await stream.append(delta);
-            }, () => ({ textLength: delta.length, accumulatedLength: stream.getText().length }));
-        },
-        finishResponse: async (finalText) => {
-            await queueResponseOperation("finishResponse", "set_working", async () => {
-                await stream.finish(finalText);
-                accumulatedText = stream.getText();
-                if (messageTs && accumulatedText.trim() && !mainResponseLogged) {
-                    slack.logBotResponse(channelId, accumulatedText, messageTs, replyInThread ? rootTs : undefined);
-                    mainResponseLogged = true;
-                }
-                if (!rootTs)
-                    return;
-                await slack
-                    .setAssistantStatus(channelId, rootTs, "")
-                    .catch((err) => onAssistantStatusError("clear-on-idle", err));
-            }, () => ({ finalTextLength: finalText?.length }));
-        },
-        replaceResponse: async (text, options) => {
-            await queueResponseOperation("replaceResponse", "replace_response", async () => {
-                // Lazy: only mint a token if Slack actually rejects the message.
-                let overflowLink;
-                const resolveOverflowLink = () => {
-                    if (overflowLink === undefined && options?.createOverflowLink) {
-                        overflowLink = options.createOverflowLink();
-                    }
-                    return overflowLink;
-                };
-                accumulatedText = text;
-                stream.setText(accumulatedText);
-                const displayText = isWorking ? accumulatedText + WORKING_INDICATOR : accumulatedText;
-                try {
-                    if (streamActive && messageTs) {
-                        await slack.stopMessageStream(channelId, messageTs);
-                        streamActive = false;
-                        streamedText = "";
-                    }
-                    await postOrUpdateMain(displayText, false);
-                }
-                catch (err) {
-                    if (!isSlackMsgTooLong(err))
-                        throw err;
-                    const link = resolveOverflowLink();
-                    const fallback = await postSlackTextWithFallback(async (body) => {
-                        await postOrUpdateMain(body);
-                    }, text, link);
-                    accumulatedText = fallback.text;
-                    const continuation = text.slice(fallback.prefixLength).trimStart();
-                    if (continuation) {
-                        await postDiagnosticDirect(`_(continued from truncated message)_\n\n${continuation}`);
-                    }
-                }
-            }, () => ({
-                textLength: text.length,
-                hadExistingResponse: Boolean(messageTs),
-            }));
-        },
-        respondDiagnostic: async (text, options) => {
-            await queueResponseOperation("respondDiagnostic", "respond_diagnostic", async () => {
-                await postDiagnosticDirect(text, options);
-            }, () => ({
-                textLength: text.length,
-                style: options?.style,
-            }));
-        },
-        respondToolResult: async (result) => {
-            await responder.respondDiagnostic(formatSlackToolResult(result));
-        },
-        setTyping: async (isTyping) => {
-            if (isTyping && !messageTs && rootTs) {
-                try {
-                    const statusText = eventFilename ? `Starting event: ${eventFilename}` : "Thinking";
-                    await slack.setAssistantStatus(channelId, rootTs, statusText);
-                }
-                catch (err) {
-                    // Assistant API not available — first respond() call will create the message.
-                    onAssistantStatusError("typing", err);
-                }
+    // Reserve before choosing, not after failing: the buffered path is a
+    // working answer rather than a degraded retry after a wasted request.
+    const streamKind = replyInThread && rootTs && slack.tryReserveStreamStart() ? "native" : "buffered";
+    const { responder } = createProgressiveRenderer({
+        label: "Slack",
+        maxLength: MAX_MAIN_LENGTH,
+        initialResponseId: sessionPlan.initialMessageTs ?? null,
+        formatContinuation: formatSlackContinuation,
+        errorPrefix: "",
+        workingIndicator: streamKind === "buffered" ? WORKING_INDICATOR : undefined,
+        formatProvisional: formatProvisionalSlackText,
+        prepareSource: prepareSlackSource,
+        supportsDeltas: true,
+        stream: streamKind === "native"
+            ? {
+                start: (text) => slack.startMessageStream(event.channel, text, rootTs, event.user),
+                append: (id, delta) => slack.appendMessageStream(event.channel, id, delta),
+                stop: (id) => slack.stopMessageStream(event.channel, id),
+                minDeltaChars: STREAM_MIN_DELTA_CHARS,
             }
-        },
-        uploadFile: async (filePath, title) => {
-            await slack.uploadFile(channelId, filePath, title, rootTs);
-        },
+            : undefined,
+        needsCanonicalRender,
+        formatToolResult: formatSlackToolResult,
+        responseErrorContext: (responseId) => ({
+            platform: "slack",
+            conversationId: event.conversationId,
+            channelId: event.channel,
+            messageId: message.id,
+            sessionKey: message.sessionKey,
+            responseMessageId: responseId,
+            threadTs: rootTs,
+            conversationKind: message.conversationKind,
+            isThreaded,
+        }),
+        post: (text) => replyInThread && rootTs
+            ? slack.postInThread(event.channel, rootTs, text)
+            : slack.postMessage(event.channel, text),
+        update: (id, text) => slack.updateMessage(event.channel, id, text),
+        postExtra: (text, responseId) => slack.postInThread(event.channel, responseId ?? rootTs ?? "", text),
+        postDiagnostic: lifecycle.postThreadDiagnostic.bind(lifecycle),
+        delete: lifecycle.deleteMessage.bind(lifecycle),
+        deleteExtra: (id) => slack.deleteMessage(event.channel, String(id)),
+        setTyping: lifecycle.setTyping.bind(lifecycle),
+        onWorkingChanged: lifecycle.onWorkingChanged.bind(lifecycle),
+        onFinish: lifecycle.onFinish.bind(lifecycle),
+        isTooLongError: isSlackMsgTooLong,
+        handleTooLong: lifecycle.handleTooLong.bind(lifecycle),
+        uploadFile: (filePath, title) => slack.uploadFile(event.channel, filePath, title, replyInThread ? rootTs : undefined),
         react: async (emoji) => {
-            // React to the triggering message. Event runs have no real message ts.
-            if (eventFilename)
-                return;
-            await slack.addReaction(channelId, event.ts, emoji);
-        },
-        setWorking: async (working) => {
-            await queueResponseOperation("setWorking", "set_working", async () => {
-                isWorking = working;
-                if (messageTs) {
-                    const displayText = isWorking ? accumulatedText + WORKING_INDICATOR : accumulatedText;
-                    const updates = streamActive && !isWorking
-                        ? [
-                            slack.stopMessageStream(channelId, messageTs).then(() => {
-                                streamActive = false;
-                            }),
-                        ]
-                        : [slack.updateMessage(channelId, messageTs, displayText)];
-                    if (!working && rootTs) {
-                        updates.push(slack
-                            .setAssistantStatus(channelId, rootTs, "")
-                            .catch((err) => onAssistantStatusError("clear-on-idle", err)));
-                    }
-                    await Promise.all(updates);
-                }
-            }, () => ({ working }));
+            if (!eventFilename)
+                await slack.addReaction(event.channel, event.ts, emoji);
         },
+    });
+    return {
+        ...responder,
         deleteResponse: async () => {
-            updatePromise = updatePromise.then(async () => {
-                // Clear assistant status first
-                if (rootTs) {
-                    try {
-                        await slack.setAssistantStatus(channelId, rootTs, "");
-                    }
-                    catch {
-                        // Ignore errors clearing status
-                    }
-                }
-                // Delete thread messages first (in reverse order)
-                for (let i = threadMessageTs.length - 1; i >= 0; i--) {
-                    try {
-                        await slack.deleteMessage(channelId, threadMessageTs[i]);
-                    }
-                    catch {
-                        // Ignore errors deleting thread messages
-                    }
-                }
-                threadMessageTs.length = 0;
-                // Then delete main message
-                if (messageTs) {
-                    await slack.deleteMessage(channelId, messageTs);
-                    messageTs = null;
-                }
-            });
-            await updatePromise;
+            lifecycle.endStatus();
+            await responder.deleteResponse();
+        },
+        /**
+         * Spike: post the specialist's answer as a fresh Slack message under that
+         * profile's own username/icon. `chat.update`/`chat.appendStream` cannot
+         * carry an identity, so the in-progress message (already posted under
+         * mikan's own identity) is left as-is and this always sends a new message
+         * rather than editing it.
+         */
+        respondAsRole: async (profile, text) => {
+            const identity = slackPersonaForProfile(profile);
+            if (!identity) {
+                await (replyInThread && rootTs
+                    ? slack.postInThread(event.channel, rootTs, text)
+                    : slack.postMessage(event.channel, text));
+                return;
+            }
+            const ts = await (replyInThread && rootTs
+                ? slack.postInThread(event.channel, rootTs, text, identity)
+                : slack.postMessage(event.channel, text, undefined, identity));
+            slack.logBotResponse(event.channel, text, ts, replyInThread ? rootTs : undefined);
         },
     };
-    return responder;
 }
 //# sourceMappingURL=response-lifecycle.js.map