@cursor/bdk 0.2.8 → 0.2.10

package/dist/channels/slack/agentic-delivery.js

@@ -7,15 +7,6 @@
  * / `reasoning.appended` / `actions.requested`, not from model `react` /
  * `set-status`. Prefer the last assistant line before a `tool_call`.
  */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { markHostedFirstVisibleReply, noteHostedVisibleReplyError, } from "../../internal/hosted-execution-latency.js";
 import { begin, bind, end, has, latest, latestPosted, remove, resolve, setPostedText, } from "./agentic-posted.js";
 import { DELETE_MESSAGE, EDIT_MESSAGE, isOwnedSignal, isSignal, POST_CARD, POST_FILE, POST_UPDATE, parseCard, parseDelete, parseEdit, parseReaction, parseStagedFile, parseUpdate, REACT, } from "./agentic-signals.js";
@@ -44,523 +35,480 @@ function thread(state) {
     }
     return { channelId: state.channelId, threadTs: state.threadTs };
 }
-function postStaticPlaceholder(args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (args.channel.state.placeholderPosted === true) {
-            return;
-        }
-        if (args.placeholder === undefined) {
-            return;
-        }
-        const target = thread(args.channel.state);
-        if (target === undefined) {
-            return;
-        }
-        const started = startPlaceholder({
-            line: args.placeholder,
-            botToken: args.botToken,
-            channelId: target.channelId,
-            threadTs: target.threadTs,
-            log: args.log,
-            recipientUserId: args.channel.state.triggeringUserId,
-            recipientTeamId: args.channel.state.teamId,
-        });
-        yield started === null || started === void 0 ? void 0 : started.done;
+async function postStaticPlaceholder(args) {
+    if (args.channel.state.placeholderPosted === true) {
+        return;
+    }
+    if (args.placeholder === undefined) {
+        return;
+    }
+    const target = thread(args.channel.state);
+    if (target === undefined) {
+        return;
+    }
+    const started = startPlaceholder({
+        line: args.placeholder,
+        botToken: args.botToken,
+        channelId: target.channelId,
+        threadTs: target.threadTs,
+        log: args.log,
+        recipientUserId: args.channel.state.triggeringUserId,
+        recipientTeamId: args.channel.state.teamId,
     });
+    await started?.done;
 }
-function setChip(channel, status, botToken, getLog, loadingMessages) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const target = thread(channel.state);
-        if (target === undefined) {
-            return false;
-        }
-        const result = yield setThreadStatus({
-            botToken,
-            channelId: target.channelId,
-            threadTs: target.threadTs,
-            status,
-            loadingMessages: loadingMessages === undefined ? undefined : [...loadingMessages],
-        });
-        if (!result.ok) {
-            getLog().warn(`agentic status failed: ${result.error}`, {
-                channel: target.channelId,
-                thread_ts: target.threadTs,
-            });
-            return false;
-        }
-        return true;
+async function setChip(channel, status, botToken, getLog, loadingMessages) {
+    const target = thread(channel.state);
+    if (target === undefined) {
+        return false;
+    }
+    const result = await setThreadStatus({
+        botToken,
+        channelId: target.channelId,
+        threadTs: target.threadTs,
+        status,
+        loadingMessages: loadingMessages === undefined ? undefined : [...loadingMessages],
     });
+    if (!result.ok) {
+        getLog().warn(`agentic status failed: ${result.error}`, {
+            channel: target.channelId,
+            thread_ts: target.threadTs,
+        });
+        return false;
+    }
+    return true;
 }
-function postNew(args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
-        const state = args.channel.state;
-        const target = thread(state);
-        if (target === undefined) {
-            return;
-        }
-        const log = args.getLog();
-        const overlaid = yield overlayPlaceholder({
-            channelId: target.channelId,
-            threadTs: target.threadTs,
+async function postNew(args) {
+    const state = args.channel.state;
+    const target = thread(state);
+    if (target === undefined) {
+        return;
+    }
+    const log = args.getLog();
+    const overlaid = await overlayPlaceholder({
+        channelId: target.channelId,
+        threadTs: target.threadTs,
+        botToken: args.botToken,
+        text: args.text,
+    });
+    if (overlaid !== undefined) {
+        state.lastPostedText = args.text;
+        state.lastBotMessageTs = overlaid;
+        bind(args.sessionId, args.ts ?? overlaid, overlaid, args.text);
+        log.info("placeholder replaced", {
+            channel: target.channelId,
+            thread_ts: target.threadTs,
+            message_ts: overlaid,
+            session: args.sessionId,
+            chars: args.text.length,
+        });
+        markHostedFirstVisibleReply({
+            outcome: "progress_update",
+            deliverySurface: "slack",
+        });
+        await setChip(args.channel, "", args.botToken, args.getLog);
+        return;
+    }
+    try {
+        const posted = await postMessage({
             botToken: args.botToken,
+            channel: target.channelId,
             text: args.text,
+            threadTs: target.threadTs,
         });
-        if (overlaid !== undefined) {
-            state.lastPostedText = args.text;
-            state.lastBotMessageTs = overlaid;
-            bind(args.sessionId, (_a = args.ts) !== null && _a !== void 0 ? _a : overlaid, overlaid, args.text);
-            log.info("placeholder replaced", {
-                channel: target.channelId,
-                thread_ts: target.threadTs,
-                message_ts: overlaid,
-                session: args.sessionId,
-                chars: args.text.length,
-            });
-            markHostedFirstVisibleReply({
-                outcome: "progress_update",
-                deliverySurface: "slack",
-            });
-            yield setChip(args.channel, "", args.botToken, args.getLog);
-            return;
-        }
-        try {
-            const posted = yield postMessage({
-                botToken: args.botToken,
-                channel: target.channelId,
-                text: args.text,
-                threadTs: target.threadTs,
-            });
-            state.lastPostedText = args.text;
-            state.lastBotMessageTs = posted.ts;
-            bind(args.sessionId, (_b = args.ts) !== null && _b !== void 0 ? _b : posted.ts, posted.ts, args.text);
-            log.info("agentic reply posted", {
-                channel: target.channelId,
-                thread_ts: target.threadTs,
-                message_ts: posted.ts,
-                session: args.sessionId,
-                chars: args.text.length,
-            });
-            markHostedFirstVisibleReply({
-                outcome: "final_post",
-                deliverySurface: "slack",
-            });
-            yield setChip(args.channel, "", args.botToken, args.getLog);
-        }
-        catch (error) {
-            log.warn(`agentic reply failed: ${error instanceof Error ? error.message : String(error)}`, {
-                channel: target.channelId,
-                thread_ts: target.threadTs,
-            });
-            noteHostedVisibleReplyError({ deliverySurface: "slack" });
-        }
-    });
+        state.lastPostedText = args.text;
+        state.lastBotMessageTs = posted.ts;
+        bind(args.sessionId, args.ts ?? posted.ts, posted.ts, args.text);
+        log.info("agentic reply posted", {
+            channel: target.channelId,
+            thread_ts: target.threadTs,
+            message_ts: posted.ts,
+            session: args.sessionId,
+            chars: args.text.length,
+        });
+        markHostedFirstVisibleReply({
+            outcome: "final_post",
+            deliverySurface: "slack",
+        });
+        await setChip(args.channel, "", args.botToken, args.getLog);
+    }
+    catch (error) {
+        log.warn(`agentic reply failed: ${error instanceof Error ? error.message : String(error)}`, {
+            channel: target.channelId,
+            thread_ts: target.threadTs,
+        });
+        noteHostedVisibleReplyError({ deliverySurface: "slack" });
+    }
 }
 export function buildAgenticEvents(options) {
-    var _a;
-    var _b, _c;
-    const botToken = (_a = options.credentials) === null || _a === void 0 ? void 0 : _a.botToken;
-    const getLog = (_b = options.getLog) !== null && _b !== void 0 ? _b : (() => defaultSlackLog);
-    const ack = (_c = options.ack) !== null && _c !== void 0 ? _c : DEFAULT_ACK;
+    const botToken = options.credentials?.botToken;
+    const getLog = options.getLog ?? (() => defaultSlackLog);
+    const ack = options.ack ?? DEFAULT_ACK;
     const placeholder = options.placeholder;
     const status = options.status;
     const stream = createStreamDeliveryStrategy({ botToken, getLog });
     return {
-        "turn.started"(event, channel, ctx) {
-            return __awaiter(this, void 0, void 0, function* () {
-                yield stream.cleanupOrphan({ channel });
-                channel.state.agenticFiles = [];
-                channel.state.streamTs = null;
-                channel.state.streamChannelId = null;
-                channel.state.streamFull = false;
-                channel.state.streamingUnavailable = false;
-                channel.state.streamAppendedChunks = 0;
-                channel.state.lastReasoningTypingAtMs = null;
-                channel.state.lastReasoningTypingStatus = null;
-                channel.state.pendingToolCallMessage = null;
-                channel.state.turnStartedAtMs = Date.now();
-                begin(event.sessionId);
-                if (ctx.session.dryRun === true) {
-                    return;
-                }
-                const target = thread(channel.state);
-                if (target === undefined) {
-                    return;
-                }
-                if (channel.state.startPainted !== true) {
-                    yield paintTurnStart({
-                        botToken,
-                        channelId: target.channelId,
-                        threadTs: target.threadTs,
-                        ack,
-                        log: getLog(),
-                    });
-                }
-                yield postStaticPlaceholder({
-                    channel,
-                    placeholder,
+        async "turn.started"(event, channel, ctx) {
+            await stream.cleanupOrphan({ channel });
+            channel.state.agenticFiles = [];
+            channel.state.streamTs = null;
+            channel.state.streamChannelId = null;
+            channel.state.streamFull = false;
+            channel.state.streamingUnavailable = false;
+            channel.state.streamAppendedChunks = 0;
+            channel.state.lastReasoningTypingAtMs = null;
+            channel.state.lastReasoningTypingStatus = null;
+            channel.state.pendingToolCallMessage = null;
+            channel.state.turnStartedAtMs = Date.now();
+            begin(event.sessionId);
+            if (ctx.session.dryRun === true) {
+                return;
+            }
+            const target = thread(channel.state);
+            if (target === undefined) {
+                return;
+            }
+            if (channel.state.startPainted !== true) {
+                await paintTurnStart({
                     botToken,
+                    channelId: target.channelId,
+                    threadTs: target.threadTs,
+                    ack,
                     log: getLog(),
                 });
+            }
+            await postStaticPlaceholder({
+                channel,
+                placeholder,
+                botToken,
+                log: getLog(),
             });
         },
-        "message.received"(_event, channel, ctx) {
-            return __awaiter(this, void 0, void 0, function* () {
-                if (ctx.session.dryRun === true) {
-                    return;
-                }
-                yield postStaticPlaceholder({
-                    channel,
-                    placeholder,
-                    botToken,
-                    log: getLog(),
-                });
+        async "message.received"(_event, channel, ctx) {
+            if (ctx.session.dryRun === true) {
+                return;
+            }
+            await postStaticPlaceholder({
+                channel,
+                placeholder,
+                botToken,
+                log: getLog(),
             });
         },
-        "reasoning.appended"(event, channel, ctx) {
-            return __awaiter(this, void 0, void 0, function* () {
-                if (nested(event) || ctx.session.dryRun === true) {
-                    return;
-                }
-                if (status.reasoning === false) {
-                    return;
-                }
-                const now = Date.now();
-                const line = nextReasoningChip(channel.state, event.data.text, now);
-                if (line === undefined) {
-                    return;
-                }
-                if (yield setChip(channel, line, botToken, getLog, [line])) {
-                    commitReasoningChip(channel.state, line, now);
-                }
-            });
+        async "reasoning.appended"(event, channel, ctx) {
+            if (nested(event) || ctx.session.dryRun === true) {
+                return;
+            }
+            if (status.reasoning === false) {
+                return;
+            }
+            const now = Date.now();
+            const line = nextReasoningChip(channel.state, event.data.text, now);
+            if (line === undefined) {
+                return;
+            }
+            if (await setChip(channel, line, botToken, getLog, [line])) {
+                commitReasoningChip(channel.state, line, now);
+            }
         },
-        "message.completed"(event, channel, ctx) {
-            return __awaiter(this, void 0, void 0, function* () {
-                if (nested(event) || ctx.session.dryRun === true) {
-                    return;
-                }
-                rememberPendingToolCall(channel.state, event.data.finishReason, event.data.text);
-            });
+        async "message.completed"(event, channel, ctx) {
+            if (nested(event) || ctx.session.dryRun === true) {
+                return;
+            }
+            rememberPendingToolCall(channel.state, event.data.finishReason, event.data.text);
         },
-        "actions.requested"(event, channel, ctx) {
-            return __awaiter(this, void 0, void 0, function* () {
-                if (skip(event, ctx.session.dryRun)) {
-                    return;
-                }
-                const calls = event.data.calls.filter(call => !isOwnedSignal(call.toolName));
-                const line = takeToolChipLine(channel.state, status.tools, calls);
-                if (line === undefined) {
-                    return;
-                }
-                yield setChip(channel, line, botToken, getLog, [line]);
-            });
+        async "actions.requested"(event, channel, ctx) {
+            if (skip(event, ctx.session.dryRun)) {
+                return;
+            }
+            const calls = event.data.calls.filter(call => !isOwnedSignal(call.toolName));
+            const line = takeToolChipLine(channel.state, status.tools, calls);
+            if (line === undefined) {
+                return;
+            }
+            await setChip(channel, line, botToken, getLog, [line]);
         },
-        "action.result"(event, channel, ctx) {
-            return __awaiter(this, void 0, void 0, function* () {
-                var _a;
-                if (skip(event, ctx.session.dryRun)) {
-                    return;
-                }
-                if (event.data.isError || event.data.stubbed === true) {
-                    return;
-                }
-                if (isSignal(event.data.toolName, POST_UPDATE)) {
-                    const update = parseUpdate(event.data.output);
-                    if (update === undefined) {
-                        return;
-                    }
-                    yield postNew({
-                        channel,
-                        text: update.message,
-                        ts: update.ts,
-                        sessionId: ctx.session.id,
-                        botToken,
-                        getLog,
-                    });
-                    return;
-                }
-                if (isSignal(event.data.toolName, EDIT_MESSAGE)) {
-                    yield applyEdit({
-                        channel,
-                        output: event.data.output,
-                        sessionId: ctx.session.id,
-                        botToken,
-                        getLog,
-                    });
-                    return;
-                }
-                if (isSignal(event.data.toolName, DELETE_MESSAGE)) {
-                    yield applyDelete({
-                        channel,
-                        output: event.data.output,
-                        sessionId: ctx.session.id,
-                        botToken,
-                        getLog,
-                    });
-                    return;
-                }
-                if (isSignal(event.data.toolName, POST_CARD)) {
-                    const card = parseCard(event.data.output);
-                    const channelId = channel.state.channelId;
-                    if (card === undefined || channelId === null || channelId === "") {
-                        return;
-                    }
-                    yield stream.appendChunks({
-                        channel,
-                        channelId,
-                        sessionId: ctx.session.id,
-                        chunks: [
-                            {
-                                type: "task_update",
-                                id: card.id,
-                                title: card.title,
-                                status: card.status,
-                                details: card.details,
-                            },
-                        ],
-                    });
+        async "action.result"(event, channel, ctx) {
+            if (skip(event, ctx.session.dryRun)) {
+                return;
+            }
+            if (event.data.isError || event.data.stubbed === true) {
+                return;
+            }
+            if (isSignal(event.data.toolName, POST_UPDATE)) {
+                const update = parseUpdate(event.data.output);
+                if (update === undefined) {
                     return;
                 }
-                if (isSignal(event.data.toolName, REACT)) {
-                    yield applyReaction({
-                        channel,
-                        output: event.data.output,
-                        sessionId: ctx.session.id,
-                        botToken,
-                        getLog,
-                    });
-                    return;
-                }
-                if (!isSignal(event.data.toolName, POST_FILE)) {
-                    return;
-                }
-                const file = parseStagedFile(event.data.output);
-                if (file === undefined) {
+                await postNew({
+                    channel,
+                    text: update.message,
+                    ts: update.ts,
+                    sessionId: ctx.session.id,
+                    botToken,
+                    getLog,
+                });
+                return;
+            }
+            if (isSignal(event.data.toolName, EDIT_MESSAGE)) {
+                await applyEdit({
+                    channel,
+                    output: event.data.output,
+                    sessionId: ctx.session.id,
+                    botToken,
+                    getLog,
+                });
+                return;
+            }
+            if (isSignal(event.data.toolName, DELETE_MESSAGE)) {
+                await applyDelete({
+                    channel,
+                    output: event.data.output,
+                    sessionId: ctx.session.id,
+                    botToken,
+                    getLog,
+                });
+                return;
+            }
+            if (isSignal(event.data.toolName, POST_CARD)) {
+                const card = parseCard(event.data.output);
+                const channelId = channel.state.channelId;
+                if (card === undefined || channelId === null || channelId === "") {
                     return;
                 }
-                const staged = (_a = channel.state.agenticFiles) !== null && _a !== void 0 ? _a : [];
-                staged.push(file);
-                channel.state.agenticFiles = staged;
-            });
+                await stream.appendChunks({
+                    channel,
+                    channelId,
+                    sessionId: ctx.session.id,
+                    chunks: [
+                        {
+                            type: "task_update",
+                            id: card.id,
+                            title: card.title,
+                            status: card.status,
+                            details: card.details,
+                        },
+                    ],
+                });
+                return;
+            }
+            if (isSignal(event.data.toolName, REACT)) {
+                await applyReaction({
+                    channel,
+                    output: event.data.output,
+                    sessionId: ctx.session.id,
+                    botToken,
+                    getLog,
+                });
+                return;
+            }
+            if (!isSignal(event.data.toolName, POST_FILE)) {
+                return;
+            }
+            const file = parseStagedFile(event.data.output);
+            if (file === undefined) {
+                return;
+            }
+            const staged = channel.state.agenticFiles ?? [];
+            staged.push(file);
+            channel.state.agenticFiles = staged;
         },
-        "turn.completed"(_event, channel, ctx) {
-            return __awaiter(this, void 0, void 0, function* () {
-                var _a;
-                yield stream.cleanupOrphan({ channel });
-                if (ctx.session.dryRun !== true) {
-                    yield setChip(channel, "", botToken, getLog);
-                    yield paintFooter({
-                        channel,
-                        sessionId: ctx.session.id,
-                        status: "completed",
-                        footer: options.footer,
-                        botToken,
-                        getLog,
-                        host: ctx.host,
-                    });
-                }
-                yield retractUnclaimed(channel, botToken, getLog);
-                end(ctx.session.id);
-                const files = (_a = channel.state.agenticFiles) !== null && _a !== void 0 ? _a : [];
-                channel.state.agenticFiles = [];
-                yield uploadStaged(files, channel, botToken, getLog);
-            });
+        async "turn.completed"(_event, channel, ctx) {
+            await stream.cleanupOrphan({ channel });
+            if (ctx.session.dryRun !== true) {
+                await setChip(channel, "", botToken, getLog);
+                await paintFooter({
+                    channel,
+                    sessionId: ctx.session.id,
+                    status: "completed",
+                    footer: options.footer,
+                    botToken,
+                    getLog,
+                    host: ctx.host,
+                });
+            }
+            await retractUnclaimed(channel, botToken, getLog);
+            end(ctx.session.id);
+            const files = channel.state.agenticFiles ?? [];
+            channel.state.agenticFiles = [];
+            await uploadStaged(files, channel, botToken, getLog);
         },
-        "turn.failed"(_event, channel, ctx) {
-            return __awaiter(this, void 0, void 0, function* () {
-                yield stream.cleanupOrphan({ channel });
-                channel.state.agenticFiles = [];
-                if (ctx.session.dryRun !== true) {
-                    yield setChip(channel, "", botToken, getLog);
-                    yield paintFooter({
-                        channel,
-                        sessionId: ctx.session.id,
-                        status: "failed",
-                        footer: options.footer,
-                        botToken,
-                        getLog,
-                        host: ctx.host,
-                    });
-                }
-                yield retractUnclaimed(channel, botToken, getLog);
-                end(ctx.session.id);
-            });
+        async "turn.failed"(_event, channel, ctx) {
+            await stream.cleanupOrphan({ channel });
+            channel.state.agenticFiles = [];
+            if (ctx.session.dryRun !== true) {
+                await setChip(channel, "", botToken, getLog);
+                await paintFooter({
+                    channel,
+                    sessionId: ctx.session.id,
+                    status: "failed",
+                    footer: options.footer,
+                    botToken,
+                    getLog,
+                    host: ctx.host,
+                });
+            }
+            await retractUnclaimed(channel, botToken, getLog);
+            end(ctx.session.id);
         },
     };
 }
-function paintFooter(args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const posted = latestPosted(args.sessionId);
-        const target = thread(args.channel.state);
-        if (posted === undefined || target === undefined) {
-            return;
-        }
-        const result = yield paintSlackFooter({
-            footer: args.footer,
-            ctx: {
-                sessionId: args.sessionId,
-                channelId: target.channelId,
-                threadTs: target.threadTs,
-                text: posted.text,
-                status: args.status,
-                durationMs: turnDurationMs(args.channel.state.turnStartedAtMs),
-                host: args.host,
-            },
-            ts: posted.ts,
-            botToken: args.botToken,
-        });
-        if (result !== undefined && !result.ok) {
-            args.getLog().warn(`agentic footer failed: ${result.error}`, {
-                channel: target.channelId,
-                ts: posted.ts,
-            });
-        }
-    });
-}
-function retractUnclaimed(channel, botToken, getLog) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const target = thread(channel.state);
-        if (target === undefined) {
-            return;
-        }
-        yield finishPlaceholder({
+async function paintFooter(args) {
+    const posted = latestPosted(args.sessionId);
+    const target = thread(args.channel.state);
+    if (posted === undefined || target === undefined) {
+        return;
+    }
+    const result = await paintSlackFooter({
+        footer: args.footer,
+        ctx: {
+            sessionId: args.sessionId,
             channelId: target.channelId,
             threadTs: target.threadTs,
-            botToken,
-            log: getLog(),
-        });
+            text: posted.text,
+            status: args.status,
+            durationMs: turnDurationMs(args.channel.state.turnStartedAtMs),
+            host: args.host,
+        },
+        ts: posted.ts,
+        botToken: args.botToken,
     });
+    if (result !== undefined && !result.ok) {
+        args.getLog().warn(`agentic footer failed: ${result.error}`, {
+            channel: target.channelId,
+            ts: posted.ts,
+        });
+    }
 }
-function applyOwned(args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const target = thread(args.channel.state);
-        if (target === undefined) {
-            return;
-        }
-        const log = args.getLog();
-        if (!has(args.sessionId, args.ts)) {
-            log.warn(`agentic ${args.verb} rejected: ts is not a message this turn posted`, {
-                channel: target.channelId,
-                ts: args.ts,
-            });
-            return;
-        }
-        const slackTs = resolve(args.sessionId, args.ts);
-        if (slackTs === undefined) {
-            return;
-        }
-        const result = yield args.write(target.channelId, slackTs);
-        if (!result.ok) {
-            log.warn(`agentic ${args.verb} failed: ${result.error}`, {
-                channel: target.channelId,
-                ts: args.ts,
-            });
-            return;
-        }
-        if (args.ok !== undefined) {
-            args.ok(slackTs);
-        }
+async function retractUnclaimed(channel, botToken, getLog) {
+    const target = thread(channel.state);
+    if (target === undefined) {
+        return;
+    }
+    await finishPlaceholder({
+        channelId: target.channelId,
+        threadTs: target.threadTs,
+        botToken,
+        log: getLog(),
     });
 }
-function applyEdit(args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const edit = parseEdit(args.output);
-        if (edit === undefined) {
-            return;
-        }
-        yield applyOwned({
-            channel: args.channel,
-            sessionId: args.sessionId,
-            ts: edit.ts,
-            botToken: args.botToken,
-            getLog: args.getLog,
-            verb: "edit",
-            write: (channelId, ts) => updateMessage({
-                botToken: args.botToken,
-                channel: channelId,
-                ts,
-                text: edit.message,
-            }),
-            ok: slackTs => {
-                setPostedText(args.sessionId, slackTs, edit.message);
-            },
+async function applyOwned(args) {
+    const target = thread(args.channel.state);
+    if (target === undefined) {
+        return;
+    }
+    const log = args.getLog();
+    if (!has(args.sessionId, args.ts)) {
+        log.warn(`agentic ${args.verb} rejected: ts is not a message this turn posted`, {
+            channel: target.channelId,
+            ts: args.ts,
         });
-    });
+        return;
+    }
+    const slackTs = resolve(args.sessionId, args.ts);
+    if (slackTs === undefined) {
+        return;
+    }
+    const result = await args.write(target.channelId, slackTs);
+    if (!result.ok) {
+        log.warn(`agentic ${args.verb} failed: ${result.error}`, {
+            channel: target.channelId,
+            ts: args.ts,
+        });
+        return;
+    }
+    if (args.ok !== undefined) {
+        args.ok(slackTs);
+    }
 }
-function applyDelete(args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const removed = parseDelete(args.output);
-        if (removed === undefined) {
-            return;
-        }
-        yield applyOwned({
-            channel: args.channel,
-            sessionId: args.sessionId,
-            ts: removed.ts,
+async function applyEdit(args) {
+    const edit = parseEdit(args.output);
+    if (edit === undefined) {
+        return;
+    }
+    await applyOwned({
+        channel: args.channel,
+        sessionId: args.sessionId,
+        ts: edit.ts,
+        botToken: args.botToken,
+        getLog: args.getLog,
+        verb: "edit",
+        write: (channelId, ts) => updateMessage({
             botToken: args.botToken,
-            getLog: args.getLog,
-            verb: "delete",
-            write: (channelId, ts) => deleteMessage({
-                botToken: args.botToken,
-                channel: channelId,
-                ts,
-            }),
-            ok: slackTs => {
-                var _a;
-                remove(args.sessionId, removed.ts);
-                if (args.channel.state.lastBotMessageTs === slackTs) {
-                    args.channel.state.lastBotMessageTs = (_a = latest(args.sessionId)) !== null && _a !== void 0 ? _a : null;
-                }
-            },
-        });
+            channel: channelId,
+            ts,
+            text: edit.message,
+        }),
+        ok: slackTs => {
+            setPostedText(args.sessionId, slackTs, edit.message);
+        },
     });
 }
-function applyReaction(args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        const reaction = parseReaction(args.output);
-        const target = thread(args.channel.state);
-        if (reaction === undefined || target === undefined) {
-            return;
-        }
-        const ts = (_a = reaction.ts) !== null && _a !== void 0 ? _a : target.threadTs;
-        const result = yield addReaction({
+async function applyDelete(args) {
+    const removed = parseDelete(args.output);
+    if (removed === undefined) {
+        return;
+    }
+    await applyOwned({
+        channel: args.channel,
+        sessionId: args.sessionId,
+        ts: removed.ts,
+        botToken: args.botToken,
+        getLog: args.getLog,
+        verb: "delete",
+        write: (channelId, ts) => deleteMessage({
             botToken: args.botToken,
-            channel: target.channelId,
+            channel: channelId,
             ts,
-            name: reaction.emoji,
-        });
-        if (!result.ok) {
-            args.getLog().warn(`agentic react failed: ${result.error}`, {
-                channel: target.channelId,
-                ts,
-            });
-        }
+        }),
+        ok: slackTs => {
+            remove(args.sessionId, removed.ts);
+            if (args.channel.state.lastBotMessageTs === slackTs) {
+                args.channel.state.lastBotMessageTs = latest(args.sessionId) ?? null;
+            }
+        },
     });
 }
-function uploadStaged(files, channel, botToken, getLog) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (files.length === 0) {
-            return;
-        }
-        const target = thread(channel.state);
-        if (target === undefined) {
-            return;
-        }
-        const failures = yield uploadThreadFiles({
-            botToken,
-            channelId: target.channelId,
-            threadTs: target.threadTs,
-            files,
-        });
-        if (failures.length === 0) {
-            return;
-        }
-        getLog().warn("agentic file upload failed", {
+async function applyReaction(args) {
+    const reaction = parseReaction(args.output);
+    const target = thread(args.channel.state);
+    if (reaction === undefined || target === undefined) {
+        return;
+    }
+    const ts = reaction.ts ?? target.threadTs;
+    const result = await addReaction({
+        botToken: args.botToken,
+        channel: target.channelId,
+        ts,
+        name: reaction.emoji,
+    });
+    if (!result.ok) {
+        args.getLog().warn(`agentic react failed: ${result.error}`, {
             channel: target.channelId,
-            thread_ts: target.threadTs,
-            failures: failures.join("; "),
+            ts,
         });
+    }
+}
+async function uploadStaged(files, channel, botToken, getLog) {
+    if (files.length === 0) {
+        return;
+    }
+    const target = thread(channel.state);
+    if (target === undefined) {
+        return;
+    }
+    const failures = await uploadThreadFiles({
+        botToken,
+        channelId: target.channelId,
+        threadTs: target.threadTs,
+        files,
+    });
+    if (failures.length === 0) {
+        return;
+    }
+    getLog().warn("agentic file upload failed", {
+        channel: target.channelId,
+        thread_ts: target.threadTs,
+        failures: failures.join("; "),
     });
 }