@cursor/july 0.1.109 → 0.1.112

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

@@ -0,0 +1,560 @@
+/**
+ * Agentic Slack watches communication tools on the turn stream and
+ * renders them through the channel Slack client. The tools do not call
+ * Slack. Writes happen on a successful, non-stubbed `action.result`.
+ *
+ * Ack and the thinking chip are channel-owned: they fire on `turn.started`
+ * / `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";
+import { addReaction, deleteMessage, postMessage, setThreadStatus, updateMessage, } from "./api.js";
+import { paintSlackFooter, turnDurationMs, } from "./footer.js";
+import { createStreamDeliveryStrategy } from "./live-delivery.js";
+import { defaultSlackLog } from "./log.js";
+import { paintTurnStart } from "./paint-start.js";
+import { finishPlaceholder, overlayPlaceholder, startPlaceholder, } from "./placeholder.js";
+import { commitReasoningChip, nextReasoningChip } from "./reasoning-chip.js";
+import { DEFAULT_ACK } from "./reply-options.js";
+import { rememberPendingToolCall, takeToolChipLine } from "./tool-chip.js";
+import { uploadThreadFiles } from "./upload.js";
+function nested(event) {
+    return event.data.parentCallId !== undefined;
+}
+function skip(event, dryRun) {
+    return nested(event) || dryRun === true;
+}
+function thread(state) {
+    if (state.channelId === null || state.channelId === "") {
+        return undefined;
+    }
+    if (state.threadTs === null || state.threadTs === "") {
+        return undefined;
+    }
+    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;
+    });
+}
+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;
+    });
+}
+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,
+            botToken: args.botToken,
+            text: args.text,
+        });
+        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" });
+        }
+    });
+}
+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 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,
+                    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(),
+                });
+            });
+        },
+        "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);
+                }
+            });
+        },
+        "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);
+            });
+        },
+        "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]);
+            });
+        },
+        "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,
+                            },
+                        ],
+                    });
+                    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) {
+                    return;
+                }
+                const staged = (_a = channel.state.agenticFiles) !== null && _a !== void 0 ? _a : [];
+                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,
+                    });
+                }
+                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);
+            });
+        },
+        "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,
+                    });
+                }
+                yield 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),
+            },
+            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({
+            channelId: target.channelId,
+            threadTs: target.threadTs,
+            botToken,
+            log: getLog(),
+        });
+    });
+}
+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);
+        }
+    });
+}
+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);
+            },
+        });
+    });
+}
+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,
+            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;
+                }
+            },
+        });
+    });
+}
+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({
+            botToken: args.botToken,
+            channel: target.channelId,
+            ts,
+            name: reaction.emoji,
+        });
+        if (!result.ok) {
+            args.getLog().warn(`agentic react failed: ${result.error}`, {
+                channel: target.channelId,
+                ts,
+            });
+        }
+    });
+}
+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", {
+            channel: target.channelId,
+            thread_ts: target.threadTs,
+            failures: failures.join("; "),
+        });
+    });
+}

package/dist/channels/slack/agentic-posted.d.ts

@@ -0,0 +1,30 @@
+/**
+ * This-turn Slack posts. `reserve` is the ts `post-update` returns.
+ * `bind` attaches the Slack ts after `chat.postMessage`. `has` is either.
+ * `lastPostAt` is the quiet clock: turn start, then each `post-update`.
+ */
+export declare const SLACK_QUIET_MS = 90000;
+export declare const SLACK_QUIET_HINT = "<slack_quiet>Thread has been quiet. post-update if the picture changed (dead-end, widen, or breakthrough).</slack_quiet>";
+type Hintable = {
+    content: ReadonlyArray<{
+        type: string;
+        text?: string;
+    }>;
+    isError?: boolean;
+};
+export declare function begin(sessionId: string, now?: number): void;
+export declare function end(sessionId: string): void;
+export declare function reserve(sessionId: string, now?: number): string;
+export declare function appendSlackQuietHint<T extends Hintable>(sessionId: string, result: T, now?: number): T;
+export declare function bind(sessionId: string, ts: string, slackTs: string, text: string): void;
+export declare function setPostedText(sessionId: string, slackTs: string, text: string): void;
+export declare function has(sessionId: string, ts: string): boolean;
+export declare function resolve(sessionId: string, ts: string): string | undefined;
+export declare function remove(sessionId: string, ts: string): void;
+export declare function latest(sessionId: string): string | undefined;
+export declare function latestPosted(sessionId: string): {
+    ts: string;
+    text: string;
+} | undefined;
+export {};
+//# sourceMappingURL=agentic-posted.d.ts.map

package/dist/channels/slack/agentic-posted.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agentic-posted.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/agentic-posted.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,eAAO,MAAM,cAAc,QAAS,CAAC;AAErC,eAAO,MAAM,gBAAgB,6HAC+F,CAAC;AAU7H,KAAK,QAAQ,GAAG;IACd,OAAO,EAAE,aAAa,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACxD,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAuBF,wBAAgB,KAAK,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,GAAE,MAAmB,GAAG,IAAI,CAEvE;AAED,wBAAgB,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAE3C;AAED,wBAAgB,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,GAAE,MAAmB,GAAG,MAAM,CAO3E;AAED,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,QAAQ,EACrD,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,CAAC,EACT,GAAG,GAAE,MAAmB,GACvB,CAAC,CAYH;AAED,wBAAgB,IAAI,CAClB,SAAS,EAAE,MAAM,EACjB,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,GACX,IAAI,CAMN;AAED,wBAAgB,aAAa,CAC3B,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,GACX,IAAI,CAEN;AAED,wBAAgB,GAAG,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAK1D;AAED,wBAAgB,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAEzE;AAED,wBAAgB,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,CAa1D;AAED,wBAAgB,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAM5D;AAED,wBAAgB,YAAY,CAC1B,SAAS,EAAE,MAAM,GAChB;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAU1C"}

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

@@ -0,0 +1,102 @@
+/**
+ * This-turn Slack posts. `reserve` is the ts `post-update` returns.
+ * `bind` attaches the Slack ts after `chat.postMessage`. `has` is either.
+ * `lastPostAt` is the quiet clock: turn start, then each `post-update`.
+ */
+export const SLACK_QUIET_MS = 90000;
+export const SLACK_QUIET_HINT = "<slack_quiet>Thread has been quiet. post-update if the picture changed (dead-end, widen, or breakthrough).</slack_quiet>";
+const posted = new Map();
+function empty(now = Date.now()) {
+    return {
+        n: 0,
+        reserved: new Set(),
+        slack: new Map(),
+        text: new Map(),
+        lastPostAt: now,
+    };
+}
+function turn(sessionId) {
+    let current = posted.get(sessionId);
+    if (current === undefined) {
+        current = empty();
+        posted.set(sessionId, current);
+    }
+    return current;
+}
+export function begin(sessionId, now = Date.now()) {
+    posted.set(sessionId, empty(now));
+}
+export function end(sessionId) {
+    posted.delete(sessionId);
+}
+export function reserve(sessionId, now = Date.now()) {
+    const current = turn(sessionId);
+    current.n += 1;
+    current.lastPostAt = now;
+    const ts = String(current.n);
+    current.reserved.add(ts);
+    return ts;
+}
+export function appendSlackQuietHint(sessionId, result, now = Date.now()) {
+    if (result.isError === true) {
+        return result;
+    }
+    const current = posted.get(sessionId);
+    if (current === undefined || now - current.lastPostAt < SLACK_QUIET_MS) {
+        return result;
+    }
+    return Object.assign(Object.assign({}, result), { content: [...result.content, { type: "text", text: SLACK_QUIET_HINT }] });
+}
+export function bind(sessionId, ts, slackTs, text) {
+    const current = turn(sessionId);
+    current.reserved.delete(ts);
+    current.slack.set(ts, slackTs);
+    current.slack.set(slackTs, slackTs);
+    current.text.set(slackTs, text);
+}
+export function setPostedText(sessionId, slackTs, text) {
+    var _a;
+    (_a = posted.get(sessionId)) === null || _a === void 0 ? void 0 : _a.text.set(slackTs, text);
+}
+export function has(sessionId, ts) {
+    const current = posted.get(sessionId);
+    return (current !== undefined && (current.reserved.has(ts) || current.slack.has(ts)));
+}
+export function resolve(sessionId, ts) {
+    var _a;
+    return (_a = posted.get(sessionId)) === null || _a === void 0 ? void 0 : _a.slack.get(ts);
+}
+export function remove(sessionId, ts) {
+    var _a;
+    const current = posted.get(sessionId);
+    if (current === undefined) {
+        return;
+    }
+    current.reserved.delete(ts);
+    const slackTs = (_a = current.slack.get(ts)) !== null && _a !== void 0 ? _a : ts;
+    current.text.delete(slackTs);
+    for (const [key, value] of current.slack) {
+        if (key === ts || key === slackTs || value === slackTs) {
+            current.slack.delete(key);
+        }
+    }
+}
+export function latest(sessionId) {
+    const current = posted.get(sessionId);
+    if (current === undefined || current.slack.size === 0) {
+        return undefined;
+    }
+    return [...current.slack.values()].at(-1);
+}
+export function latestPosted(sessionId) {
+    var _a;
+    const ts = latest(sessionId);
+    if (ts === undefined) {
+        return undefined;
+    }
+    const text = (_a = posted.get(sessionId)) === null || _a === void 0 ? void 0 : _a.text.get(ts);
+    if (text === undefined || text === "") {
+        return undefined;
+    }
+    return { ts, text };
+}