@amykit/plugin-slack 0.5.0 → 0.7.0

package/dist/SlackConversation.js

@@ -1,4 +1,4 @@
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 import { TooLarge } from "./SlackApi.js";
@@ -18,12 +18,32 @@ export const DEFAULT_RETENTION_DAYS = 30;
 /** Pruning walks the state directory, so it happens at most this often. */
 const PRUNE_EVERY_MS = 60 * 60 * 1000;
 const DAY_MS = 24 * 60 * 60 * 1000;
+/** A reaction whose list of users is too short to say who is on it. */
+const UNKNOWN = Symbol("unknown");
+/** ✅ settles it, 💬 asks something first. */
+export const DEFAULT_MARKS = { decision: "white_check_mark", discussion: "speech_balloon" };
 /** What marks a root as amy's, and whose work it opened. */
 const ROOT_EVENT = "amy_work_thread";
+const ASK_EVENT = "amy_ask";
+const ASK_FALLBACK_EVENT = "amy_ask_fallback";
+const ASK_AMBIGUOUS_EVENT = "amy_ask_ambiguous";
+const ASK_TAKEN_EVENT = "amy_ask_taken";
+const KEYCAPS = ["one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "keycap_ten"];
+const APPROVAL_REACTIONS = ["white_check_mark", "x"];
+const SUBMIT_REACTION = "white_check_mark";
+/** A conversation's thread is read at most this often: Slack may allow conversations.replies once a minute. */
+const CHAT_THREAD_EVERY_MS = 60 * 1000;
 export class SlackConversation {
     api;
     options;
-    threads;
+    asks = true;
+    threads = true;
+    edit = true;
+    /** The channel: its conversations and claims are its own. */
+    get source() {
+        return `slack:${this.options.channel}`;
+    }
+    threadMap;
     filesDirectory;
     opening = new Map();
     botUser;
@@ -31,21 +51,23 @@ export class SlackConversation {
     constructor(api, options) {
         this.api = api;
         this.options = options;
-        this.threads = new ThreadMap(options.directory, {
+        this.threadMap = new ThreadMap(options.directory, {
             maxWaitMs: options.lockWaitMs,
             leaseMs: options.leaseMs,
+            readOnly: options.readOnly,
             // A root replaced in another channel takes its downloads with it.
             onDisplaced: (ts) => this.dropFiles(ts),
         });
         this.filesDirectory = path.join(options.directory, "files");
         // The operator's screenshots, fetched with the bot's token: private.
-        privateDirectory(this.filesDirectory);
+        if (!options.readOnly)
+            privateDirectory(this.filesDirectory);
     }
     open(workId, title) {
         let known;
         try {
             // Known first, which marks it used, so the prune after it keeps it.
-            known = this.threads.known(workId, this.options.channel);
+            known = this.threadMap.known(workId, this.options.channel);
         }
         catch (error) {
             // A promise-returning method rejects; it does not throw at the caller.
@@ -64,42 +86,78 @@ export class SlackConversation {
     }
     async post(thread, message) {
         if (message.files?.length) {
-            // Uploading needs `files:write`, which this plugin does not ask for:
-            // amy asks in words, and the operator's pictures come the other way.
             throw new Error("@amykit/plugin-slack does not upload files; post their paths as text");
         }
-        // Writing to a thread is using it, as reading its replies is.
-        this.threads.used(thread.id);
+        this.threadMap.used(thread.id);
         this.pruneNowAndThen();
+        if (!message.ask)
+            return this.postText(thread.id, message.text);
+        const ask = message.ask;
+        if (!validAsk(ask))
+            return this.postAskFallback(thread.id, message.text, ask);
+        if (ask.form !== "approval" && ask.answers.length > KEYCAPS.length) {
+            return this.postAskFallback(thread.id, message.text, ask);
+        }
         const { body } = await this.api.call("chat.postMessage", {
             channel: this.options.channel,
             thread_ts: thread.id,
-            text: message.text,
+            text: renderAsk(message.text, ask, false),
+            metadata: askMetadata(ASK_EVENT, ask),
         });
-        return String(body.ts);
+        const ts = String(body.ts);
+        this.rememberAskedFrom(thread.id, ts);
+        try {
+            for (const name of reactionsFor(ask)) {
+                await this.api.call("reactions.add", { channel: this.options.channel, timestamp: ts, name });
+            }
+        }
+        catch {
+            // The ask stands as posted, its answers listed on it: the operator
+            // reacts by hand, which is read as any reaction is, or types.
+        }
+        return ts;
     }
     async replies(thread, since) {
         const after = instantToMicros(since);
         if (Number.isNaN(after))
             throw new Error(`replies since ${since}: not an instant`);
-        // Reading a thread is using it, whether or not the caller opened it
-        // first — marked before the prune, so the prune never takes it.
-        this.threads.used(thread.id);
+        this.threadMap.used(thread.id);
         this.pruneNowAndThen();
         const bot = await this.botUserId();
-        const answers = [];
-        for (const message of await this.threadMessages(thread.id, after)) {
+        // A later copy of the same ask must see the earlier decision. Slack has
+        // no reaction timestamp, so recover the thread's ask messages instead
+        // of retaining an accepted answer in process memory. Where amy recorded
+        // the first ask it posted here, one read from there holds both the asks
+        // and what is recent: conversations.replies may be limited to one call
+        // a minute, so a look makes one.
+        const askedFrom = this.askedFrom(thread.id);
+        const read = askedFrom === undefined
+            ? await this.threadMessages(thread.id, after)
+            : await this.threadMessages(thread.id, Math.min(after, askedFrom), true);
+        const recent = askedFrom === undefined ? read : read.filter((message) => message.ts !== undefined && tsToMicros(message.ts) > after);
+        // Metadata is anybody's to attach: an ask, or the notice amy took one,
+        // is read only from a message this bot wrote, so another app cannot
+        // turn the operator's reaction into an answer to amy's question.
+        const amys = (messages) => messages.filter((message) => message.metadata === undefined || message.user === bot);
+        // With no record (an ask from before amy kept one), a recent ask still
+        // sends the look back for the whole thread, as it always did.
+        const unrecorded = askedFrom === undefined && recent.some((message) => message.user === bot && readAsk(message) !== undefined);
+        const messages = amys(unrecorded ? await this.threadMessages(thread.id, 0) : read);
+        const answers = await this.askedReplies(thread.id, after, messages);
+        for (const message of recent) {
             if (!this.isOperatorAnswer(message, thread.id, bot))
                 continue;
             const at = tsToMicros(message.ts);
             if (at <= after)
                 continue;
             const { paths, skipped } = await this.downloadAll(thread.id, message.files ?? []);
+            const kind = await this.kindOf(message);
             answers.push({
                 at: microsToInstant(at),
                 author: message.user,
                 text: [message.text ?? "", ...skipped].filter(Boolean).join("\n"),
                 files: paths,
+                ...(kind ? { kind } : {}),
             });
         }
         return answers.sort((a, b) => a.at.localeCompare(b.at));
@@ -128,7 +186,7 @@ export class SlackConversation {
      * from it. The thread stays in Slack; the next `open` starts a new one.
      */
     forget(workId) {
-        const ts = this.threads.forget(workId);
+        const ts = this.threadMap.forget(workId);
         if (ts)
             this.dropFiles(ts);
     }
@@ -145,11 +203,183 @@ export class SlackConversation {
         if (days <= 0)
             return { threads: 0, files: 0 };
         const cutoff = now.getTime() - days * DAY_MS;
-        const threads = this.threads.prune(cutoff);
+        const threads = this.threadMap.prune(cutoff);
         for (const ts of threads)
             this.dropFiles(ts);
         return { threads: threads.length, files: pruneFiles(this.filesDirectory, cutoff) };
     }
+    /**
+     * The messages in the channel that reached no work, oldest first, until
+     * they are settled: a root message the operator posts, and the operator's
+     * replies in that root's thread, which is one conversation (S14). The
+     * channel is read for them first, so it is read all the time (S20).
+     */
+    async chat() {
+        if (!this.options.readOnly)
+            await this.fileChat();
+        const directory = path.join(this.chatDirectory(), "inbox");
+        return jsonIn(directory)
+            .flatMap((name) => {
+            const filed = readJson(path.join(directory, name));
+            // Filed while somebody else was the operator: theirs to have said, not this operator's to act on.
+            return filed && filed.author === this.options.operator ? [filed] : [];
+        })
+            .sort((a, b) => a.at.localeCompare(b.at));
+    }
+    async settle(id) {
+        const message = /^slack:([^:]+):(\d+\.\d+)$/.exec(id);
+        if (!message || message[1] !== this.options.channel)
+            throw new Error(`${id} is not a message this channel filed`);
+        fs.rmSync(path.join(this.chatDirectory(), "inbox", `${safeName(message[2])}.json`), { force: true });
+    }
+    /** Says something in a conversation's thread. */
+    async say(place, text) {
+        const { body } = await this.api.call("chat.postMessage", { channel: this.options.channel, thread_ts: place, text });
+        return String(body.ts);
+    }
+    async revise(_place, id, text) {
+        await this.api.call("chat.update", { channel: this.options.channel, ts: id, text });
+    }
+    /**
+     * Files the operator's new root messages, and their replies in the
+     * threads of conversations still going, each once. The first read starts
+     * from now: what was said in the channel before amy listened is not asked
+     * of it. A thread goes quiet a day after the operator last wrote in it.
+     */
+    async fileChat() {
+        const bot = await this.botUserId();
+        const chat = this.chatDirectory();
+        privateDirectory(chat);
+        const cursorFile = path.join(chat, "cursor.json");
+        const cursor = readJson(cursorFile)?.oldest;
+        if (cursor === undefined) {
+            writeJsonFile(cursorFile, { oldest: msToTs(this.clock().getTime()) });
+            return;
+        }
+        // Slack may allow conversations.history once a minute too: the channel is
+        // read when that is due, and what was filed is handed out meanwhile.
+        const historyQuota = path.join(chat, "history.json");
+        if (this.clock().getTime() - (readJson(historyQuota)?.at ?? 0) >= CHAT_THREAD_EVERY_MS) {
+            writeJsonFile(historyQuota, { at: this.clock().getTime() });
+            writeJsonFile(cursorFile, { oldest: await this.fileRoots(cursor, bot) });
+        }
+        await this.fileDueReplies(chat, bot);
+    }
+    /** The chat's own state, by channel: a channel changed in the config starts afresh and never answers the old one's messages. */
+    chatDirectory() {
+        return path.join(this.options.directory, "chat", safeName(this.options.channel));
+    }
+    /**
+     * One conversation's replies per minute, whichever has waited longest:
+     * Slack may allow conversations.replies once a minute for the whole app, not
+     * once per thread, so the chat shares that one call rather than queueing.
+     */
+    async fileDueReplies(chat, bot) {
+        const now = this.clock().getTime();
+        // Work threads read whenever their work asks, and each read takes the
+        // shared allowance. The chat waits for it, but never past its own second
+        // slot: work reads under a minute apart would otherwise hold the chat's
+        // follow-ups unread for as long as the work goes on. A read Slack refuses
+        // for that is a 429, which the API waits out.
+        const free = now - (readJson(this.repliesQuota())?.at ?? 0) >= CHAT_THREAD_EVERY_MS;
+        const chatReads = path.join(chat, "chat-replies.json");
+        const owed = now - (readJson(chatReads)?.at ?? 0) >= 2 * CHAT_THREAD_EVERY_MS;
+        if (!free && !owed)
+            return;
+        const threads = jsonIn(path.join(chat, "threads")).map((name) => {
+            const file = path.join(chat, "threads", name);
+            return { file, kept: readJson(file) };
+        });
+        const due = threads
+            .filter((one) => one.kept)
+            .sort((a, b) => (a.kept.checked ?? 0) - (b.kept.checked ?? 0))[0];
+        if (!due)
+            return;
+        writeJsonFile(chatReads, { at: now });
+        await this.fileReplies(due.file, bot);
+    }
+    /** The operator's root messages since the cursor, each a conversation from now on; answers the new cursor. */
+    async fileRoots(cursor, bot) {
+        let oldest = cursor;
+        for (const message of await this.pages("conversations.history", { channel: this.options.channel, oldest: cursor })) {
+            if (!message.ts)
+                continue;
+            if (tsToMicros(message.ts) > tsToMicros(oldest))
+                oldest = message.ts;
+            const root = !message.thread_ts || message.thread_ts === message.ts;
+            if (!root || !this.isOperatorMessage(message, bot))
+                continue;
+            this.fileChatMessage(message, message.ts);
+            // A newly discovered root waits behind conversations already awaiting a
+            // reply; otherwise a steady stream of roots can starve their follow-ups.
+            const now = this.clock().getTime();
+            writeJsonFile(path.join(this.chatDirectory(), "threads", `${safeName(message.ts)}.json`), { read: message.ts, last: now, checked: now });
+        }
+        return oldest;
+    }
+    /** The operator's replies in one conversation's thread, at most once a minute, until it goes quiet. */
+    async fileReplies(file, bot) {
+        const now = this.clock().getTime();
+        const kept = readJson(file);
+        if (!kept)
+            return;
+        const root = path.basename(file, ".json");
+        let { read, last } = kept;
+        let messages;
+        try {
+            messages = await this.threadMessages(root, tsToMicros(kept.read));
+        }
+        catch (error) {
+            // The root is gone: that conversation is over, and the others are still read.
+            if (/thread_not_found|message_not_found/.test(messageOf(error))) {
+                fs.rmSync(file, { force: true });
+                // What was asked there is gone with it: nothing is left to answer in.
+                const inbox = path.join(this.chatDirectory(), "inbox");
+                for (const name of jsonIn(inbox)) {
+                    if (readJson(path.join(inbox, name))?.place === root)
+                        fs.rmSync(path.join(inbox, name), { force: true });
+                }
+                return;
+            }
+            throw error;
+        }
+        for (const message of messages) {
+            if (!message.ts || message.ts === root || !this.isOperatorMessage(message, bot))
+                continue;
+            this.fileChatMessage(message, root);
+            if (tsToMicros(message.ts) > tsToMicros(read))
+                read = message.ts;
+            last = now;
+        }
+        writeJsonFile(file, { read, last, checked: now });
+    }
+    /** One channel-wide conversations.replies allowance, shared by chat and work threads. */
+    repliesQuota() {
+        return path.join(this.chatDirectory(), "replies.json");
+    }
+    fileChatMessage(message, root) {
+        const text = (message.text ?? "").trim();
+        if (!text)
+            return;
+        const target = path.join(this.chatDirectory(), "inbox", `${safeName(message.ts)}.json`);
+        const filed = {
+            id: `slack:${this.options.channel}:${message.ts}`,
+            at: microsToInstant(tsToMicros(message.ts)),
+            author: message.user,
+            text,
+            place: root,
+            threaded: true,
+        };
+        writeJsonFile(target, filed);
+    }
+    /** The operator, writing as themselves: no bot, no other person, no channel event. */
+    isOperatorMessage(message, bot) {
+        if (message.bot_id || message.user === bot)
+            return false;
+        if (message.subtype && message.subtype !== "file_share" && message.subtype !== "thread_broadcast")
+            return false;
+        return message.user === this.options.operator;
+    }
     clock() {
         return this.options.now?.() ?? new Date();
     }
@@ -170,6 +400,7 @@ export class SlackConversation {
         privateDirectory(this.filesDirectory);
         fs.writeFileSync(this.forgottenMarker(ts), "", { mode: 0o600 });
         fs.rmSync(this.threadFiles(ts), { recursive: true, force: true });
+        fs.rmSync(this.answerDirectory(ts), { recursive: true, force: true });
     }
     /** Throttled, and never the reason a call fails: pruning is housekeeping. */
     pruneNowAndThen() {
@@ -184,6 +415,182 @@ export class SlackConversation {
             // A file another process removed first, or one still being written.
         }
     }
+    async postText(threadTs, text) {
+        const { body } = await this.api.call("chat.postMessage", { channel: this.options.channel, thread_ts: threadTs, text });
+        return String(body.ts);
+    }
+    async postAskFallback(threadTs, text, ask) {
+        const { body } = await this.api.call("chat.postMessage", {
+            channel: this.options.channel,
+            thread_ts: threadTs,
+            text: renderAsk(text, ask, true),
+            metadata: askMetadata(ASK_FALLBACK_EVENT, ask),
+        });
+        return String(body.ts);
+    }
+    /** Reconstruct answers from Slack every time; no accepted-answer cache survives a process. */
+    async askedReplies(threadTs, after, messages) {
+        const asks = messages.map(readAsk).filter((ask) => ask !== undefined);
+        const taken = new Set();
+        const replies = [];
+        for (const entry of asks.sort((a, b) => tsToMicros(a.message.ts) - tsToMicros(b.message.ts))) {
+            const remembered = this.rememberedAnswer(threadTs, entry.ask.id);
+            // Re-read an accepted ask too: its decision is immutable, but a later
+            // complete, different mark still deserves the once-only acknowledgement.
+            // Marks Slack cannot fully list block a first answer, never a saved
+            // one: the remembered answer is replayed and nothing new is read.
+            const verdict = await this.answerOf(entry.message, entry.ask).catch((error) => {
+                if (remembered)
+                    return { ambiguous: false, observed: [] };
+                throw error;
+            });
+            const accepted = await this.acceptedAnswer(threadTs, messages, entry, remembered, verdict);
+            if (!accepted)
+                continue;
+            const chosen = accepted.chosen;
+            // Another copy of the ask carries the answer: this one is replayed by
+            // nothing, and a complete mark on it is a later answer, told once.
+            if (accepted.messageTs !== entry.message.ts) {
+                if (verdict.chosen || verdict.ambiguous)
+                    await this.acknowledgeTaken(threadTs, messages, entry.ask, chosen);
+                continue;
+            }
+            if (this.hasChangedAnswer(remembered, verdict))
+                await this.acknowledgeTaken(threadTs, messages, entry.ask, chosen);
+            if (taken.has(entry.ask.id)) {
+                await this.acknowledgeTaken(threadTs, messages, entry.ask, chosen);
+                continue;
+            }
+            taken.add(entry.ask.id);
+            // An answer saved before amy dated it carries its ask's time instead.
+            const acceptedAt = accepted.acceptedAt === undefined ? tsToMicros(accepted.messageTs) : instantToMicros(accepted.acceptedAt);
+            if (acceptedAt > after) {
+                replies.push({ at: microsToInstant(acceptedAt), author: this.options.operator, text: entry.ask.prompt, files: [], kind: "decision", answer: { ask: entry.ask.id, chosen } });
+            }
+        }
+        return replies;
+    }
+    /** The answer this ask holds after this look, if any: the remembered one, or the first complete one seen now. */
+    async acceptedAnswer(threadTs, messages, entry, remembered, verdict) {
+        if (verdict.ambiguous) {
+            await this.explainAmbiguity(threadTs, messages, entry.ask, verdict.observed);
+            // A later conflict cannot revoke the durable first answer: replay it
+            // so a look that previously parked still has the decision to apply.
+            if (remembered)
+                await this.acknowledgeTaken(threadTs, messages, entry.ask, remembered.chosen);
+            return remembered;
+        }
+        if (!verdict.chosen)
+            return remembered;
+        return remembered ?? this.rememberAnswer(threadTs, entry.ask.id, verdict.chosen, entry.message.ts);
+    }
+    /** The first complete answer is immutable once seen, even if its reaction changes later. */
+    rememberedAnswer(threadTs, askId) {
+        try {
+            const state = JSON.parse(fs.readFileSync(this.answerFile(threadTs, askId), "utf-8"));
+            if (!Array.isArray(state.chosen) || !state.chosen.every((chosen) => typeof chosen === "string") || typeof state.messageTs !== "string")
+                return undefined;
+            return { chosen: state.chosen, messageTs: state.messageTs, ...(typeof state.acceptedAt === "string" ? { acceptedAt: state.acceptedAt } : {}) };
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return undefined;
+            throw error;
+        }
+    }
+    /** Creates the decision once; a competing reader adopts the value written first. */
+    rememberAnswer(threadTs, askId, chosen, messageTs) {
+        const file = this.answerFile(threadTs, askId);
+        fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+        const staged = path.join(path.dirname(file), `.${randomUUID()}.partial`);
+        const handle = fs.openSync(staged, "wx", 0o600);
+        try {
+            // When amy first saw it, not when it asked: an ask posted before a
+            // look's since can still be answered after it.
+            fs.writeFileSync(handle, JSON.stringify({ chosen, messageTs, acceptedAt: this.clock().toISOString() }));
+            fs.fsyncSync(handle);
+        }
+        finally {
+            fs.closeSync(handle);
+        }
+        try {
+            fs.linkSync(staged, file);
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+        }
+        finally {
+            fs.rmSync(staged, { force: true });
+        }
+        return this.rememberedAnswer(threadTs, askId) ?? { chosen, messageTs, acceptedAt: this.clock().toISOString() };
+    }
+    /** The first ask amy posted in this thread, as microseconds, if it kept one. */
+    askedFrom(threadTs) {
+        try {
+            const ts = fs.readFileSync(path.join(this.answerDirectory(threadTs), "asked-from"), "utf-8").trim();
+            const micros = tsToMicros(ts);
+            return Number.isNaN(micros) ? undefined : micros;
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return undefined;
+            throw error;
+        }
+    }
+    /** Keeps the earliest ask's ts; a later ask leaves it where it is. */
+    rememberAskedFrom(threadTs, ts) {
+        const earlier = this.askedFrom(threadTs);
+        if (earlier !== undefined && earlier <= tsToMicros(ts))
+            return;
+        fs.mkdirSync(this.answerDirectory(threadTs), { recursive: true, mode: 0o700 });
+        fs.writeFileSync(path.join(this.answerDirectory(threadTs), "asked-from"), ts, { mode: 0o600 });
+    }
+    answerFile(threadTs, askId) {
+        return path.join(this.answerDirectory(threadTs), `${createHash("sha256").update(askId).digest("hex")}.json`);
+    }
+    answerDirectory(threadTs) {
+        return path.join(this.options.directory, "answers", safeName(threadTs));
+    }
+    hasChangedAnswer(remembered, verdict) {
+        return remembered !== undefined && (verdict.ambiguous || (verdict.chosen !== undefined && !sameAnswers(remembered.chosen, verdict.chosen)));
+    }
+    async answerOf(message, ask) {
+        const names = reactionsFor(ask);
+        const reactions = await this.completeReactions(message, names);
+        if (names.some((name) => this.marked(reactions, name) === UNKNOWN))
+            throw new Error(`Slack did not identify every reaction on ask ${ask.id}`);
+        const marked = names.filter((name) => this.marked(reactions, name) === true);
+        if (ask.form === "approval") {
+            return { chosen: marked.length === 1 ? [marked[0] === "white_check_mark" ? "approve" : "reject"] : undefined, ambiguous: marked.length > 1, observed: marked };
+        }
+        const selected = KEYCAPS.slice(0, ask.answers.length).filter((name) => marked.includes(name));
+        if (ask.form === "choice" && selected.length > 1)
+            return { ambiguous: true, observed: selected };
+        if (ask.form === "choices" && !marked.includes(SUBMIT_REACTION))
+            return { ambiguous: false, observed: selected };
+        if (ask.form === "choice" && selected.length !== 1)
+            return { ambiguous: false, observed: selected };
+        return { chosen: selected.map((name) => ask.answers[KEYCAPS.indexOf(name)]), ambiguous: false, observed: selected };
+    }
+    async completeReactions(message, names) {
+        const listed = message.reactions ?? [];
+        if (names.some((name) => this.marked(listed, name) === UNKNOWN))
+            return this.allReactions(message.ts);
+        return listed;
+    }
+    async explainAmbiguity(threadTs, messages, ask, observed) {
+        if (hasAskEvent(messages, ASK_AMBIGUOUS_EVENT, ask.id))
+            return;
+        await this.api.call("chat.postMessage", { channel: this.options.channel, thread_ts: threadTs, text: `I saw conflicting answers for ${ask.id}: ${observed.join(", ")}. Please leave one answer.`, metadata: askMetadata(ASK_AMBIGUOUS_EVENT, ask) });
+        rememberAskEvent(messages, ASK_AMBIGUOUS_EVENT, ask);
+    }
+    async acknowledgeTaken(threadTs, messages, ask, chosen) {
+        if (hasAskEvent(messages, ASK_TAKEN_EVENT, ask.id))
+            return;
+        await this.api.call("chat.postMessage", { channel: this.options.channel, thread_ts: threadTs, text: `Amy already took ${ask.id}: ${chosen.join(", ")}.`, metadata: askMetadata(ASK_TAKEN_EVENT, ask) });
+        rememberAskEvent(messages, ASK_TAKEN_EVENT, ask);
+    }
     async channelChecks(scopes) {
         const label = `slack channel ${this.options.channel}`;
         try {
@@ -203,6 +610,8 @@ export class SlackConversation {
                 isPrivate ? "groups:read" : "channels:read",
                 isPrivate ? "groups:history" : "channels:history",
                 "files:read",
+                "reactions:write",
+                "reactions:read",
             ];
             const missing = needed.filter((scope) => !scopes.includes(scope));
             checks.push({
@@ -222,7 +631,7 @@ export class SlackConversation {
      */
     async startThread(workId, title) {
         const channel = this.options.channel;
-        const ts = await this.threads.open(workId, channel, async (recoverSince) => {
+        const ts = await this.threadMap.open(workId, channel, async (recoverSince) => {
             const recovered = recoverSince === undefined ? undefined : await this.findRoot(workId, recoverSince);
             if (recovered)
                 return { ts: recovered, posted: false };
@@ -258,9 +667,16 @@ export class SlackConversation {
             message.metadata.event_payload?.work_id === workId);
         return root?.ts;
     }
-    /** Every message in the thread after `afterMicros`, across pages. */
-    threadMessages(ts, afterMicros) {
-        return this.pages("conversations.replies", { channel: this.options.channel, ts, oldest: microsToTs(afterMicros) });
+    /** Every message in the thread after `afterMicros`, or from it on when `inclusive`: Slack leaves the bound out by default. */
+    async threadMessages(ts, afterMicros, inclusive = false) {
+        // Work and chat consume Slack's same channel-wide replies allowance.
+        // Every request records it, so the next scheduled chat read never races a
+        // work-thread request under a one-call-per-minute installation.
+        writeJsonFile(this.repliesQuota(), { at: this.clock().getTime() });
+        return this.pages("conversations.replies", {
+            channel: this.options.channel, ts, oldest: microsToTs(afterMicros), include_all_metadata: "true",
+            ...(inclusive ? { inclusive: "true" } : {}),
+        });
     }
     async pages(method, args) {
         const messages = [];
@@ -273,6 +689,56 @@ export class SlackConversation {
         } while (cursor);
         return messages;
     }
+    /**
+     * What the operator marked their reply as, by their own reaction on it and
+     * nobody else's — never by its text. Both marks read as the decision, the
+     * one that moves the work, because a person who put both meant to be done.
+     * Re-read on every look, so marking a reply after it was answered counts.
+     *
+     * Slack may list only some of a reaction's users while `count` holds them
+     * all. Only a mark whose answer could still change the kind is asked again
+     * in full, and a reply the operator may have marked is never read as
+     * unmarked: if the full list still cannot say, the read fails and says why.
+     */
+    async kindOf(message) {
+        const listed = this.kindFrom(message.reactions ?? []);
+        if (listed !== UNKNOWN)
+            return listed;
+        const full = this.kindFrom(await this.allReactions(message.ts));
+        if (full !== UNKNOWN)
+            return full;
+        throw new Error(`cannot tell whether the operator marked reply ${message.ts}: Slack lists only part of who reacted to it`);
+    }
+    /** The kind these reactions say, or UNKNOWN when a list too short to tell could change it. */
+    kindFrom(reactions) {
+        const marks = this.options.marks ?? DEFAULT_MARKS;
+        const decision = this.marked(reactions, marks.decision);
+        if (decision === true)
+            return "decision";
+        const discussion = this.marked(reactions, marks.discussion);
+        if (decision === UNKNOWN || discussion === UNKNOWN)
+            return UNKNOWN;
+        return discussion ? "discussion" : undefined;
+    }
+    /** Whether the operator put this reaction on, or UNKNOWN when Slack's list is short and leaves them out. */
+    marked(reactions, name) {
+        const reaction = reactions.find((candidate) => candidate.name === name);
+        if (!reaction)
+            return false;
+        const users = reaction.users ?? [];
+        if (users.includes(this.options.operator))
+            return true;
+        return (reaction.count ?? users.length) > users.length ? UNKNOWN : false;
+    }
+    async allReactions(ts) {
+        try {
+            const { body } = await this.api.call("reactions.get", { channel: this.options.channel, timestamp: ts, full: "true" });
+            return (body.message?.reactions ?? []);
+        }
+        catch (error) {
+            throw new Error(`cannot tell whether the operator marked reply ${ts}: ${messageOf(error)}`, { cause: error });
+        }
+    }
     /** By author id, never by a marker in the text. */
     isOperatorAnswer(message, threadTs, bot) {
         if (!message.ts || message.ts === threadTs)
@@ -349,6 +815,51 @@ export class SlackConversation {
         return target;
     }
 }
+function askMetadata(event, ask) {
+    return JSON.stringify({ event_type: event, event_payload: { ask } });
+}
+function readAsk(message) {
+    if (message.metadata?.event_type !== ASK_EVENT || !message.ts)
+        return undefined;
+    const ask = message.metadata.event_payload?.ask;
+    if (!isAsk(ask))
+        return undefined;
+    return { message, ask };
+}
+function isAsk(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const ask = value;
+    if (typeof ask.id !== "string" || typeof ask.prompt !== "string" || !Array.isArray(ask.answers))
+        return false;
+    if (ask.form === "approval")
+        return ask.answers.length === 2 && ask.answers[0] === "approve" && ask.answers[1] === "reject";
+    return ask.form === "choice" || ask.form === "choices";
+}
+function hasAskEvent(messages, event, askId) {
+    return messages.some((message) => message.metadata?.event_type === event && readMetadataAskId(message) === askId);
+}
+/** Make a successful notice visible to duplicate asks in this same poll. */
+function rememberAskEvent(messages, event, ask) {
+    messages.push({ metadata: { event_type: event, event_payload: { ask } } });
+}
+function readMetadataAskId(message) {
+    const ask = message.metadata?.event_payload?.ask;
+    return ask && typeof ask === "object" && typeof ask.id === "string" ? ask.id : undefined;
+}
+function validAsk(ask) {
+    return ask.answers.length >= 2 && ask.answers.length <= 10 && ask.answers.every((answer) => answer.trim().length > 0 && answer.length <= 64) && new Set(ask.answers).size === ask.answers.length;
+}
+function reactionsFor(ask) {
+    return ask.form === "approval" ? APPROVAL_REACTIONS : ask.form === "choice" ? KEYCAPS.slice(0, ask.answers.length) : [...KEYCAPS.slice(0, ask.answers.length), SUBMIT_REACTION];
+}
+function sameAnswers(left, right) {
+    return left.length === right.length && left.every((answer, index) => answer === right[index]);
+}
+function renderAsk(text, ask, fallback) {
+    const answers = ask.answers.map((answer, index) => `${fallback ? `${index + 1}.` : ask.form === "approval" ? (index === 0 ? "✅" : "❌") : `${index + 1}️⃣`} ${answer}`);
+    return [text === ask.prompt ? "" : text, ask.prompt, ...answers].filter(Boolean).join("\n");
+}
 /**
  * Whether a file was already downloaded, marking it used if so: retention
  * counts from the last use. One pruned between the look and the touch is a
@@ -410,6 +921,33 @@ function removeIfStale(file, cutoff) {
     fs.rmSync(aside, { force: true });
     return true;
 }
+function jsonIn(directory) {
+    try {
+        return fs.readdirSync(directory).filter((name) => name.endsWith(".json"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+}
+function readJson(file) {
+    try {
+        return JSON.parse(fs.readFileSync(file, "utf-8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT" || error instanceof SyntaxError)
+            return undefined;
+        throw error;
+    }
+}
+/** Written aside and renamed, so a reader never sees half of it. */
+function writeJsonFile(file, value) {
+    fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+    const partial = path.join(path.dirname(file), `.${randomUUID()}.partial`);
+    fs.writeFileSync(partial, `${JSON.stringify(value)}\n`, { mode: 0o600 });
+    fs.renameSync(partial, file);
+}
 function mtimeOf(file) {
     try {
         return fs.statSync(file).mtimeMs;