@fastagent-sh/fastagent 0.21.0 → 0.22.0

package/dist/channels/slack/preview.js

@@ -1,12 +1,17 @@
+import * as Effect from "effect/Effect";
+import * as Clock from "effect/Clock";
+import * as Stream from "effect/Stream";
+import { previewPump, renderReply, serialWriter } from "../kit/delivery.js";
+import { PortFailure, portJoin } from "../../effect-port.js";
 import { log } from "../../log.js";
 import { RETRY_NOTICE, THINKING_PLACEHOLDER, applyTurnEvent, composeTurnBody, createTurnView, defaultErrorMessage, humanizeToolName, revealedAnswer, summarizeToolArgs, toolLines, } from "../kit/preview-kit.js";
 import { chunkSlackMarkdown, chunkSlackText, isSlackNativeUnavailable, } from "./slack-api.js";
+import { DROPPABLE_FRAME } from "../kit/transport.js";
 export { defaultErrorMessage };
 const CLASSIC_UPDATE_INTERVAL_MS = 3_000;
 const NATIVE_APPEND_INTERVAL_MS = 750;
 const WORKING_STATUS = "is working on your request…";
 const GENERIC_FAILURE = "⚠️ The response stream stopped unexpectedly. Please try again.";
-const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 /** LLM output uses standard Markdown, never Slack's notification control syntax. Keep explicit sends in
  * the slack-send tool, where the Agent has to choose a side-effecting delivery action deliberately.
  * The inner class excludes BOTH `<` and `>` on purpose: bounding each run by the next delimiter keeps
@@ -53,10 +58,16 @@ function withDisclaimer(markdown, disclaimer) {
     const body = markdown.trim() || "(no reply)";
     return disclaimer === false || !disclaimer?.trim() ? body : `${body}\n\n_${disclaimer.trim()}_`;
 }
-async function settleClassic(api, target, previewTs, markdown, update = (ts, value) => api.updateMarkdown(target.channelId, ts, value)) {
+async function settleClassic(api, target, previewTs, markdown, 
+/** The renderer's own edit — it spends the mutation slot the pacing depends on. */
+update) {
+    // Best-effort: the reply lands either way, but a preview left behind sits above it, so say so.
+    const dropPreview = (ts) => api
+        .deleteMessage(target.channelId, ts)
+        .catch((error) => log.warn(`[slack] could not delete the live preview ${ts}: ${String(error)}`));
     if (markdown.trim() === "") {
         if (previewTs)
-            await api.deleteMessage(target.channelId, previewTs).catch(() => { });
+            await dropPreview(previewTs);
         return;
     }
     const [head, ...rest] = chunkSlackMarkdown(markdown);
@@ -64,8 +75,9 @@ async function settleClassic(api, target, previewTs, markdown, update = (ts, val
         try {
             await update(previewTs, head);
         }
-        catch {
-            await api.deleteMessage(target.channelId, previewTs).catch(() => { });
+        catch (error) {
+            log.warn(`[slack] final edit of the live preview failed (${String(error)}); sending the reply as a new message`);
+            await dropPreview(previewTs);
             await api.sendMarkdown(target, markdown);
             return;
         }
@@ -77,6 +89,14 @@ async function settleClassic(api, target, previewTs, markdown, update = (ts, val
     }
     await api.sendMarkdown(target, markdown);
 }
+/**
+ * Deliver a reply this process did not generate: a recovered answer. The stream it was written for is gone with its
+ * process, so there is none to resume — but a compatibility queue message THIS process posted while the record
+ * waited its turn is taken over rather than left above the answer.
+ */
+export async function deliverSlackAnswer(api, target, markdown, previewTs) {
+    await settleClassic(api, target, previewTs, sanitizeSlackMarkdown(markdown), (ts, value) => api.updateMarkdown(target.channelId, ts, value));
+}
 /** Settle a queue/drop/defer notice. These are authored plain strings, so the basic text API is enough. */
 export async function settleSlackPreview(api, target, previewTs, text) {
     if (previewTs) {
@@ -85,248 +105,251 @@ export async function settleSlackPreview(api, target, previewTs, text) {
     }
     await api.postMessage(target, text);
 }
-async function streamClassicSlackReply(events, api, target, formatError, initialPreviewTs, disclaimer, label) {
-    // Event → view-state reduction is the shared machine (preview-kit); this renderer owns mrkdwn
-    // sanitizing and delivery. Reasoning stays a static "Thinking…" here: raw chain-of-thought is not
-    // customer-facing on Slack, so the reducer accumulates it but this view never reads it.
-    const turn = createTurnView();
-    let previewTs = initialPreviewTs;
-    let previewAttempted = previewTs !== undefined;
-    let finalized = false;
-    let lastMutationAt = previewTs ? Date.now() : 0;
-    let lastSent = "";
-    let dirty = false;
-    let pumping = false;
-    let stopped = false;
-    let pumpDone;
-    let previewErrorLogged = false;
-    const view = () => composeTurnBody([
-        THINKING_PLACEHOLDER,
-        toolLines(turn),
-        turn.retrying ? RETRY_NOTICE : "",
-        sanitizeSlackMarkdown(revealedAnswer(turn, CLASSIC_UPDATE_INTERVAL_MS)),
-    ]);
-    const waitForMutationSlot = async () => {
-        const remaining = lastMutationAt + CLASSIC_UPDATE_INTERVAL_MS - Date.now();
-        if (remaining > 0)
-            await wait(remaining);
-    };
-    const updateRateSafe = async (ts, markdown) => {
-        await waitForMutationSlot();
-        await api.updateMarkdown(target.channelId, ts, markdown);
-        lastMutationAt = Date.now();
-    };
-    const flushPreview = async () => {
-        const markdown = chunkSlackText(view())[0] ?? THINKING_PLACEHOLDER;
-        if (markdown === lastSent)
-            return;
-        if (previewTs) {
-            await updateRateSafe(previewTs, markdown);
-        }
-        else {
-            if (previewAttempted)
+function streamClassicSlackReply(events, api, target, formatError, initialPreviewTs, disclaimer, label, onAnswered) {
+    return Effect.gen(function* () {
+        const clock = yield* Clock.Clock;
+        const now = () => clock.currentTimeMillisUnsafe();
+        // Event → view-state reduction is the shared machine (preview-kit); this renderer owns mrkdwn
+        // sanitizing and delivery. Reasoning stays a static "Thinking…" here: raw chain-of-thought is not
+        // customer-facing on Slack, so the reducer accumulates it but this view never reads it.
+        const turn = createTurnView();
+        let previewTs = initialPreviewTs;
+        let previewAttempted = previewTs !== undefined;
+        let lastMutationAt = previewTs ? now() : 0;
+        let lastSent = "";
+        const view = () => composeTurnBody([
+            THINKING_PLACEHOLDER,
+            toolLines(turn),
+            turn.retrying ? RETRY_NOTICE : "",
+            sanitizeSlackMarkdown(revealedAnswer(turn, CLASSIC_UPDATE_INTERVAL_MS, now())),
+        ]);
+        const waitForMutationSlot = Effect.suspend(() => {
+            const remaining = lastMutationAt + CLASSIC_UPDATE_INTERVAL_MS - now();
+            return remaining > 0 ? Effect.sleep(remaining) : Effect.void;
+        });
+        const update = async (ts, markdown, opts) => {
+            try {
+                await api.updateMarkdown(target.channelId, ts, markdown, opts);
+            }
+            finally {
+                // An ATTEMPT spends the slot, not a success. A droppable frame fails instantly on a 429, so a
+                // success-only timestamp would leave `waitForMutationSlot` open and (with throttleMs 0) re-send
+                // the same rejected view once per token — request amplification aimed at a channel that is
+                // already rate-limiting us. The failure itself still propagates to the pump's onError.
+                lastMutationAt = now();
+            }
+        };
+        const flushPreview = async () => {
+            const markdown = chunkSlackText(view())[0] ?? THINKING_PLACEHOLDER;
+            if (markdown === lastSent)
                 return;
-            previewAttempted = true;
-            previewTs = await api.postMarkdown(target, markdown);
-            lastMutationAt = Date.now();
-        }
-        lastSent = markdown;
-    };
-    const runPump = async () => {
-        pumping = true;
-        try {
-            while (dirty && !stopped) {
-                dirty = false;
+            if (previewTs) {
+                await update(previewTs, markdown, DROPPABLE_FRAME);
+            }
+            else {
+                if (previewAttempted)
+                    return;
+                previewAttempted = true;
+                previewTs = await api.postMarkdown(target, markdown);
+                lastMutationAt = now();
+            }
+            lastSent = markdown;
+        };
+        const { touch, finish } = yield* previewPump({
+            flush: flushPreview,
+            throttleMs: 0,
+            beforeFlush: Effect.suspend(() => (previewTs ? waitForMutationSlot : Effect.void)),
+            onError: (error) => log.warn(`${label} live preview failed (final reply still sends): ${String(error)}`),
+        });
+        yield* renderReply(events, {
+            label,
+            finish,
+            formatError,
+            answer: () => withDisclaimer(turn.answer, disclaimer),
+            ...(onAnswered ? { onAnswered } : {}),
+            settle: (markdown) => Effect.gen(function* () {
+                if (previewTs && markdown.trim())
+                    yield* waitForMutationSlot;
+                yield* portJoin(() => settleClassic(api, target, previewTs, sanitizeSlackMarkdown(markdown), update));
+            }),
+            onEvent: (event) => {
+                const changed = applyTurnEvent(turn, event, now());
+                // A hidden answer must not open a placeholder followed by a rate-limited edit on a fast turn.
+                if (changed && (event.type !== "text" || revealedAnswer(turn, CLASSIC_UPDATE_INTERVAL_MS, now()) !== ""))
+                    touch();
+            },
+        });
+    });
+}
+/**
+ * The native renderer owns its own terminal branches instead of `renderReply`'s: each of its three
+ * endings (completed, agent failure, abnormal) weaves the ending INTO the open stream — the notice
+ * becomes more of the answer being typed out — where `renderReply` issues one separate settle write.
+ * Sharing the loop would mean injecting all three, which is more shape than the two lines it saves.
+ */
+function streamNativeSlackReply(events, api, target, formatError, initialPreviewTs, threadTitle, disclaimer, label, onAnswered) {
+    return Effect.gen(function* () {
+        const clock = yield* Clock.Clock;
+        const now = () => clock.currentTimeMillisUnsafe();
+        const scope = yield* Effect.scope;
+        const run = Effect.runSyncWith(yield* Effect.context());
+        let streamTs;
+        let retryStatusShown = false;
+        // Keep status updates ordered through the final clear, independently of content appends.
+        const statuses = yield* serialWriter();
+        const setStatus = (status) => {
+            statuses.enqueue(() => api
+                .setThreadStatus(target, status)
+                .catch((error) => log.warn(`${label} could not set Slack Agent status: ${String(error)}`)));
+        };
+        yield* Effect.addFinalizer(() => Effect.gen(function* () {
+            if (target.channelId.startsWith("D"))
+                setStatus("");
+            yield* statuses.finish.pipe(Effect.orDie);
+        }));
+        let stopAttempted = false;
+        const stop = (ts, markdown) => {
+            // A rejected stop may have landed; scope cleanup must not retry it.
+            stopAttempted = true;
+            return api.stopStream(target.channelId, ts, markdown);
+        };
+        yield* Effect.addFinalizer(() => Effect.suspend(() => {
+            const ts = streamTs;
+            return ts && !stopAttempted
+                ? portJoin(() => stop(ts, `\n\n${GENERIC_FAILURE}`)).pipe(Effect.catchTag("PortFailure", (error) => Effect.sync(() => log.error(`${label} failed to stop an abnormal Slack stream: ${String(error.cause)}`))))
+                : Effect.void;
+        }));
+        const toolTraces = new Map();
+        let pendingText = "";
+        let fullAnswer = "";
+        let textTimer;
+        let lastTextFlushAt = 0;
+        const operations = yield* serialWriter();
+        let renderError;
+        let finalized = false;
+        let streamHasContent = false;
+        let streamEndsWithBlankLine = false;
+        const enqueue = (work) => {
+            operations.enqueue(async () => {
+                if (renderError !== undefined)
+                    return;
                 try {
-                    await flushPreview();
+                    await work();
                 }
                 catch (error) {
-                    if (!previewErrorLogged) {
-                        previewErrorLogged = true;
-                        log.warn(`${label} live preview failed (final reply still sends): ${String(error)}`);
-                    }
+                    renderError = error;
                 }
+            });
+        };
+        const sendContent = async (markdown) => {
+            if (streamTs) {
+                await api.appendStream(target.channelId, streamTs, markdown);
             }
-        }
-        finally {
-            pumping = false;
-        }
-    };
-    const touch = () => {
-        dirty = true;
-        if (!pumping)
-            pumpDone = runPump();
-    };
-    const finishPump = async () => {
-        stopped = true;
-        await pumpDone?.catch(() => { });
-    };
-    const finalize = async (markdown) => {
-        await settleClassic(api, target, previewTs, sanitizeSlackMarkdown(markdown), updateRateSafe);
-    };
-    try {
-        for await (const event of events) {
-            if (event.type === "completed") {
-                await finishPump();
-                finalized = true;
-                await finalize(withDisclaimer(turn.answer, disclaimer));
-                return;
-            }
-            if (event.type === "failed") {
-                await finishPump();
-                finalized = true;
-                const notice = formatError({
-                    details: event.details,
-                    retryable: event.retryable,
-                    ...(event.code !== undefined ? { code: event.code } : {}),
-                }) ?? "";
-                await finalize(notice).catch((error) => log.error(`${label} failed to deliver the agent-failure notice: ${String(error)}`));
-                throw new Error(`agent failed: ${event.details} (retryable=${event.retryable})`);
+            else {
+                streamTs = await api.startStream(target, markdown);
             }
-            const changed = applyTurnEvent(turn, event);
-            // A young (hidden) answer must not trigger the first frame: unlike telegram/feishu, classic
-            // rendering never posts an upfront placeholder, so a text-only fast turn delivers ONE final
-            // post instead of placeholder → 3s-rate-limited edit. Thinking/tool activity still paints.
-            if (changed && (event.type !== "text" || revealedAnswer(turn, CLASSIC_UPDATE_INTERVAL_MS) !== ""))
-                touch();
-        }
-        throw new Error("stream ended without a terminal event");
-    }
-    finally {
-        await finishPump();
-        if (!finalized) {
-            const notice = formatError({ details: "the turn ended without completing", retryable: false }) ?? "";
-            await finalize(notice).catch((error) => log.error(`${label} failed to deliver the abnormal-turn notice: ${String(error)}`));
-        }
-    }
-}
-async function streamNativeSlackReply(events, api, target, formatError, initialPreviewTs, threadTitle, disclaimer, label) {
-    if (initialPreviewTs) {
-        await api
-            .deleteMessage(target.channelId, initialPreviewTs)
-            .catch((error) => log.warn(`${label} could not remove the compatibility queue notice before native streaming: ${String(error)}`));
-    }
-    if (target.channelId.startsWith("D")) {
-        await Promise.all([
-            api
-                .setThreadStatus(target, WORKING_STATUS)
-                .catch((error) => log.warn(`${label} could not set Slack Agent status: ${String(error)}`)),
-            threadTitle
-                ? api
-                    .setThreadTitle(target, threadTitle)
-                    .catch((error) => log.warn(`${label} could not set Slack Agent thread title: ${String(error)}`))
-                : Promise.resolve(),
-        ]);
-    }
-    let streamTs;
-    let retryStatusShown = false;
-    // DM Agent-status writes are fire-and-forget for the render loop, but must reach Slack in order:
-    // an out-of-order pair would leave a stale "retrying" line after progress (or after the final
-    // clear). One promise chain serializes them; each link swallows its own delivery error.
-    let statusChain = Promise.resolve();
-    const setStatus = (status) => {
-        statusChain = statusChain.then(() => api
-            .setThreadStatus(target, status)
-            .catch((error) => log.warn(`${label} could not set Slack Agent status: ${String(error)}`)));
-    };
-    const toolTraces = new Map();
-    let pendingText = "";
-    let fullAnswer = "";
-    let textTimer;
-    let lastTextFlushAt = 0;
-    let operation = Promise.resolve();
-    let renderError;
-    let finalized = false;
-    let streamHasContent = false;
-    let streamEndsWithBlankLine = false;
-    const enqueue = (work) => {
-        operation = operation.then(async () => {
-            if (renderError !== undefined)
+        };
+        const queueMarkdown = (markdown) => {
+            if (!markdown)
                 return;
-            try {
-                await work();
+            streamHasContent = true;
+            streamEndsWithBlankLine = markdown.endsWith("\n\n");
+            enqueue(() => sendContent(markdown));
+        };
+        const flushText = (final = false) => {
+            if (textTimer) {
+                textTimer.interruptUnsafe();
+                textTimer = undefined;
             }
-            catch (error) {
-                renderError = error;
+            let value = pendingText;
+            pendingText = "";
+            if (!final) {
+                // Hold a possible Slack control token split across Agent deltas/flush windows until its closing
+                // `>` arrives. This prevents `<` + `!channel>` from bypassing the sanitizer.
+                const open = value.lastIndexOf("<");
+                if (open >= 0 && !value.slice(open).includes(">") && value.length - open <= 256) {
+                    pendingText = value.slice(open);
+                    value = value.slice(0, open);
+                }
             }
+            if (!value)
+                return;
+            lastTextFlushAt = now();
+            for (const chunk of chunkSlackText(sanitizeSlackMarkdown(value)))
+                queueMarkdown(chunk);
+        };
+        const scheduleText = () => {
+            // A zero-delay clock can finish before its handle is published.
+            if (textTimer && !textTimer.pollUnsafe())
+                return;
+            const delay = Math.max(0, lastTextFlushAt + NATIVE_APPEND_INTERVAL_MS - now());
+            textTimer = run(Effect.forkIn(Effect.sleep(delay).pipe(Effect.andThen(Effect.sync(() => {
+                textTimer = undefined;
+                flushText();
+            }))), scope));
+        };
+        // ponytail: a trace appended while the answer has an unclosed ``` fence lands inside it, and the
+        // trace's own backticks can close it early. Tracking fence parity across chunk boundaries (the job
+        // chunkSlackMarkdown does for the classic renderer) is the fix if a model is ever seen calling a
+        // tool mid-fence; the trace's blank-line framing keeps every other case well-formed.
+        const sendToolTrace = (line) => {
+            flushText();
+            const separator = streamHasContent && !streamEndsWithBlankLine ? "\n\n" : "";
+            queueMarkdown(`${separator}${line}\n\n`);
+        };
+        const settleNative = (terminalMarkdown) => Effect.gen(function* () {
+            flushText(true);
+            yield* operations.finish;
+            yield* portJoin(async () => {
+                const safeTerminal = sanitizeSlackMarkdown(terminalMarkdown);
+                if (renderError !== undefined) {
+                    if (!streamTs && isSlackNativeUnavailable(renderError)) {
+                        log.warn(`${label} native Slack stream was unavailable; delivering one compatibility Markdown reply`);
+                        await api.sendMarkdown(target, safeTerminal);
+                        return;
+                    }
+                    if (streamTs) {
+                        await stop(streamTs, `\n\n${GENERIC_FAILURE}`).catch(() => { });
+                    }
+                    throw renderError;
+                }
+                if (!streamTs)
+                    streamTs = await api.startStream(target, safeTerminal);
+                // What this settle had to say is on screen now — appended, or carried by the startStream above. `stop`
+                // only closes the stream, so failing it must not report the turn as undelivered: that would re-send the
+                // whole answer on the next start. The open stream is the visible cost, and the log is where it is
+                // diagnosed. (Shared by all three endings, so the wording claims a terminal write, not an answer.)
+                await stop(streamTs).catch((error) => log.warn(`${label} could not close the Slack stream after its terminal write: ${String(error)}`));
+            });
         });
-    };
-    const sendContent = async (markdown) => {
-        if (streamTs) {
-            await api.appendStream(target.channelId, streamTs, markdown);
-        }
-        else {
-            streamTs = await api.startStream(target, markdown);
-        }
-    };
-    const queueMarkdown = (markdown) => {
-        if (!markdown)
-            return;
-        streamHasContent = true;
-        streamEndsWithBlankLine = markdown.endsWith("\n\n");
-        enqueue(() => sendContent(markdown));
-    };
-    const flushText = (final = false) => {
-        if (textTimer) {
-            clearTimeout(textTimer);
-            textTimer = undefined;
-        }
-        let value = pendingText;
-        pendingText = "";
-        if (!final) {
-            // Hold a possible Slack control token split across Agent deltas/flush windows until its closing
-            // `>` arrives. This prevents `<` + `!channel>` from bypassing the sanitizer.
-            const open = value.lastIndexOf("<");
-            if (open >= 0 && !value.slice(open).includes(">") && value.length - open <= 256) {
-                pendingText = value.slice(open);
-                value = value.slice(0, open);
+        yield* Effect.addFinalizer(() => Effect.gen(function* () {
+            if (textTimer)
+                textTimer.interruptUnsafe();
+            if (!finalized) {
+                pendingText += `${fullAnswer.trim() ? "\n\n" : ""}${GENERIC_FAILURE}`;
+                yield* settleNative(fullAnswer.trim() || GENERIC_FAILURE).pipe(Effect.catchTag("PortFailure", (error) => Effect.sync(() => log.error(`${label} failed to stop an abnormal Slack stream: ${String(error.cause)}`))));
             }
-        }
-        if (!value)
-            return;
-        lastTextFlushAt = Date.now();
-        for (const chunk of chunkSlackText(sanitizeSlackMarkdown(value)))
-            queueMarkdown(chunk);
-    };
-    const scheduleText = () => {
-        if (textTimer)
-            return;
-        const delay = Math.max(0, lastTextFlushAt + NATIVE_APPEND_INTERVAL_MS - Date.now());
-        textTimer = setTimeout(() => {
-            textTimer = undefined;
-            flushText();
-        }, delay);
-    };
-    // ponytail: a trace appended while the answer has an unclosed ``` fence lands inside it, and the
-    // trace's own backticks can close it early. Tracking fence parity across chunk boundaries (the job
-    // chunkSlackMarkdown does for the classic renderer) is the fix if a model is ever seen calling a
-    // tool mid-fence; the trace's blank-line framing keeps every other case well-formed.
-    const sendToolTrace = (line) => {
-        flushText();
-        const separator = streamHasContent && !streamEndsWithBlankLine ? "\n\n" : "";
-        queueMarkdown(`${separator}${line}\n\n`);
-    };
-    const settleNative = async (terminalMarkdown) => {
-        flushText(true);
-        await operation;
-        const safeTerminal = sanitizeSlackMarkdown(terminalMarkdown);
-        if (renderError !== undefined) {
-            if (!streamTs && isSlackNativeUnavailable(renderError)) {
-                log.warn(`${label} native Slack stream was unavailable; delivering one compatibility Markdown reply`);
-                await api.sendMarkdown(target, safeTerminal);
-                return;
+        }));
+        yield* portJoin(async () => {
+            if (initialPreviewTs) {
+                await api
+                    .deleteMessage(target.channelId, initialPreviewTs)
+                    .catch((error) => log.warn(`${label} could not remove the compatibility queue notice before native streaming: ${String(error)}`));
             }
-            if (streamTs) {
-                await api.stopStream(target.channelId, streamTs, `\n\n${GENERIC_FAILURE}`).catch(() => { });
+            if (target.channelId.startsWith("D")) {
+                await Promise.all([
+                    api
+                        .setThreadStatus(target, WORKING_STATUS)
+                        .catch((error) => log.warn(`${label} could not set Slack Agent status: ${String(error)}`)),
+                    threadTitle
+                        ? api
+                            .setThreadTitle(target, threadTitle)
+                            .catch((error) => log.warn(`${label} could not set Slack Agent thread title: ${String(error)}`))
+                        : Promise.resolve(),
+                ]);
             }
-            throw renderError;
-        }
-        if (!streamTs)
-            streamTs = await api.startStream(target, safeTerminal);
-        await api.stopStream(target.channelId, streamTs);
-    };
-    try {
-        for await (const event of events) {
+        });
+        yield* Stream.runForEachWhile(events, (event) => Effect.gen(function* () {
             if (event.type !== "retrying" && retryStatusShown) {
                 // Progress after a retry notice: restore the normal working status so the stale line doesn't
                 // contradict a visibly streaming answer.
@@ -366,46 +389,46 @@ async function streamNativeSlackReply(events, api, target, formatError, initialP
                 const footer = finalAnswer.slice(fullAnswer.trim().length);
                 if (footer)
                     pendingText += footer;
-                await settleNative(finalAnswer);
-                return;
+                // Before the terminal write, as in `renderReply`: what the stream has already appended is not delivery —
+                // a stream left open by a dead process shows an unfinished answer.
+                yield* Effect.try({ try: () => onAnswered?.(finalAnswer), catch: (cause) => new PortFailure(cause) });
+                yield* settleNative(finalAnswer);
+                return false;
             }
             else if (event.type === "failed") {
                 finalized = true;
-                const notice = formatError({
-                    details: event.details,
-                    retryable: event.retryable,
-                    ...(event.code !== undefined ? { code: event.code } : {}),
-                }) ?? "";
-                if (notice) {
-                    pendingText += `${fullAnswer.trim() ? "\n\n" : ""}${notice}`;
-                    fullAnswer += `${fullAnswer.trim() ? "\n\n" : ""}${notice}`;
-                }
-                await settleNative(fullAnswer.trim() || GENERIC_FAILURE).catch((error) => log.error(`${label} failed to deliver the agent-failure stream: ${String(error)}`));
-                throw new Error(`agent failed: ${event.details} (retryable=${event.retryable})`);
+                yield* Effect.gen(function* () {
+                    const notice = yield* Effect.try({
+                        try: () => formatError({
+                            details: event.details,
+                            retryable: event.retryable,
+                            ...(event.code !== undefined ? { code: event.code } : {}),
+                        }) ?? "",
+                        catch: (cause) => new PortFailure(cause),
+                    });
+                    if (notice) {
+                        pendingText += `${fullAnswer.trim() ? "\n\n" : ""}${notice}`;
+                        fullAnswer += `${fullAnswer.trim() ? "\n\n" : ""}${notice}`;
+                    }
+                    yield* settleNative(fullAnswer.trim() || GENERIC_FAILURE);
+                }).pipe(Effect.catchTag("PortFailure", (error) => Effect.sync(() => log.error(`${label} failed to deliver the agent-failure stream: ${String(error.cause)}`))));
+                return yield* Effect.fail(new PortFailure(new Error(`agent failed: ${event.details} (retryable=${event.retryable})`)));
             }
+            return true;
+        }).pipe(Effect.uninterruptible));
+        if (!finalized)
+            yield* Effect.fail(new PortFailure(new Error("stream ended without a terminal event")));
+    });
+}
+export function slackReply(events, api, target, formatError, options = {}) {
+    return Effect.suspend(() => {
+        const { rendering = "native", initialPreviewTs, threadTitle, disclaimer, label = "[slack]", onAnswered } = options;
+        if (rendering === "native" && target.threadTs) {
+            return streamNativeSlackReply(events, api, target, formatError, initialPreviewTs, threadTitle, disclaimer, label, onAnswered);
         }
-        throw new Error("stream ended without a terminal event");
-    }
-    finally {
-        if (textTimer)
-            clearTimeout(textTimer);
-        if (!finalized) {
-            pendingText += `${fullAnswer.trim() ? "\n\n" : ""}${GENERIC_FAILURE}`;
-            await settleNative(fullAnswer.trim() || GENERIC_FAILURE).catch((error) => log.error(`${label} failed to stop an abnormal Slack stream: ${String(error)}`));
-        }
-        if (target.channelId.startsWith("D")) {
-            setStatus("");
-            await statusChain;
+        if (rendering === "native") {
+            log.info(`${label} native streaming needs a thread target — using the classic renderer for this turn`);
         }
-    }
-}
-export async function streamSlackReply(events, api, target, formatError, options = {}) {
-    const { rendering = "native", initialPreviewTs, threadTitle, disclaimer, label = "[slack]" } = options;
-    if (rendering === "native" && target.threadTs) {
-        return streamNativeSlackReply(events, api, target, formatError, initialPreviewTs, threadTitle, disclaimer, label);
-    }
-    if (rendering === "native") {
-        log.info(`${label} native streaming needs a thread target — using the classic renderer for this turn`);
-    }
-    return streamClassicSlackReply(events, api, target, formatError, initialPreviewTs, disclaimer, label);
+        return streamClassicSlackReply(events, api, target, formatError, initialPreviewTs, disclaimer, label, onAnswered);
+    });
 }

package/dist/channels/slack/reaction.d.ts

@@ -14,11 +14,19 @@ export interface SlackReactionSession {
     complete(): Promise<void>;
     remove(): Promise<void>;
 }
-/** Add the processing emoji now; return a session to swap it for the completed emoji or remove it. */
-export declare function startSlackReaction(args: {
+/** What identifies the acked message: the asker's own message, and how to reach it. */
+export interface SlackReactionTarget {
     api: Pick<SlackApi, "addReaction" | "removeReaction">;
     channelId: string;
     ts: string;
     emojis: SlackReactionEmojis;
     label: string;
-}): Promise<SlackReactionSession>;
+}
+/**
+ * Finish an ack this process did not start: 👀 on the asker's message was added by the run that produced the answer,
+ * and a re-delivery is the only thing left that can turn it into ✅. Without it the ack says "still working" under a
+ * delivered answer, forever.
+ */
+export declare function completeSlackReaction(target: SlackReactionTarget): Promise<void>;
+/** Add the processing emoji now; return a session to swap it for the completed emoji or remove it. */
+export declare function startSlackReaction(args: SlackReactionTarget): Promise<SlackReactionSession>;