@timqi/pier 0.0.4 → 0.0.6

package/dist/channels/runtime.js

@@ -1,13 +1,17 @@
 // Channel lifecycle: which adapters are running, and where their sessions
 // live. Keeps main.ts wiring-only and gives the Console one call to apply a
-// config change. Lark is configurable but has no adapter yet.
+// config change.
 import { logger } from "../log.js";
+import { LarkChannel } from "./lark.js";
 import { SlackChannel } from "./slack.js";
 import { TelegramChannel } from "./telegram.js";
 /** Platforms with an adapter, and what each needs before it can start. */
 const ADAPTERS = [
     { platform: "telegram", needsAppToken: false, build: (deps) => new TelegramChannel(deps) },
     { platform: "slack", needsAppToken: true, build: (deps) => new SlackChannel(deps) },
+    // Lark's "token" is the App ID and "appToken" the App Secret; the adapter
+    // needs both before it can start, same gate as Slack's two credentials.
+    { platform: "lark", needsAppToken: true, build: (deps) => new LarkChannel(deps) },
 ];
 // Lifecycle news, which is not what the injected sink below is for: that one
 // is a warning sink the adapters share, and "slack started" is not a warning.

package/dist/channels/slack-api.js

@@ -9,6 +9,7 @@
 //
 // No SDK: `apps.connections.open` plus Node's built-in WebSocket is the whole
 // protocol, and @slack/socket-mode would pull a dependency tree to wrap it.
+import { readCapped } from "../core/inbox.js";
 const BASE = "https://slack.com/api";
 /**
  * Did Slack refuse the payload because of the *block* itself? The `markdown`
@@ -278,7 +279,7 @@ export class SlackApi {
      * Slack file URLs are private: they need the bot token as a bearer header and
      * answer HTML (a login page) rather than an error when it is missing.
      */
-    async downloadFile(file) {
+    async downloadFile(file, maxBytes) {
         const url = file.url_private_download ?? file.url_private;
         if (!url)
             throw new Error("slack file has no private url");
@@ -289,6 +290,7 @@ export class SlackApi {
         if (!res.ok)
             throw new Error(`slack file download: ${res.status}`);
         const mimeType = res.headers.get("content-type")?.split(";")[0] ?? file.mimetype ?? "application/octet-stream";
-        return { bytes: new Uint8Array(await res.arrayBuffer()), mimeType };
+        // Bounded mid-stream: the event's size metadata is the platform's word.
+        return { bytes: await readCapped(res.body, maxBytes), mimeType };
     }
 }

package/dist/channels/slack-panel.js

@@ -4,7 +4,7 @@
 // The modal is what makes this half smaller than Telegram's: `private_metadata`
 // carries the conversation with the dialog, so a submitted path needs no
 // adapter-side state to be understood, and survives a reload.
-import { ChatPanel, PANEL_PREFIX, } from "./panel.js";
+import { ChatPanel, CWD_PLACEHOLDER, CWD_TAIL, PANEL_PREFIX, } from "./panel.js";
 import { context, escapeMrkdwn as esc, section } from "./slack-render.js";
 /** The modal's ids. `private_metadata` carries which conversation it is for. */
 const CWD_VIEW = "cfg_cwd";
@@ -94,14 +94,11 @@ export class SlackPanel extends ChatPanel {
                     type: "input",
                     block_id: CWD_BLOCK,
                     label: { type: "plain_text", text: "Working directory" },
-                    hint: {
-                        type: "plain_text",
-                        text: "An absolute path. A new session starts there; the current one stays in its own directory.",
-                    },
+                    hint: { type: "plain_text", text: `An absolute path. ${CWD_TAIL}` },
                     element: {
                         type: "plain_text_input",
                         action_id: CWD_INPUT,
-                        placeholder: { type: "plain_text", text: "/path/to/project" },
+                        placeholder: { type: "plain_text", text: CWD_PLACEHOLDER },
                     },
                 },
             ],

package/dist/channels/slack-render.js

@@ -7,7 +7,7 @@
 // escaped; unlike Telegram's HTML parser Slack degrades unknown syntax to
 // literal text instead of rejecting the message, so the risk here is an ugly
 // reply rather than a lost one.
-import { chunkText } from "./chunk.js";
+import { balanceFences, chunkText } from "./chunk.js";
 /**
  * A `markdown` block's budget: Slack caps them at 12,000 cumulative chars per
  * message, and one message carries one. This is the normal path.
@@ -63,30 +63,10 @@ export function toMrkdwn(markdown) {
 }
 /**
  * Split rendered mrkdwn into sendable chunks at the last blank line or newline
- * that fits, then re-balance code fences across the cut.
- *
- * Telegram can be cut mid-`<pre>` and shrug — its parser closes the tag itself.
- * Slack does not: an unterminated ``` swallows the rest of that message, and
- * the next chunk starts *outside* a fence, so the tail of a long code block
- * renders as prose. Closing and reopening around the boundary is what keeps a
- * split code block readable.
+ * that fits, then re-balance code fences across the cut (see chunk.ts for why
+ * an unbalanced fence is a mangled reply here and not on Telegram).
  */
 export const chunk = (text, max) => balanceFences(chunkText(text, max));
-/**
- * Close a fence a chunk left open, and reopen it on the next one. Counting `\`
- * runs is enough because `toMrkdwn` has already normalised every fence to a
- * bare ``` on its own line.
- */
-function balanceFences(parts) {
-    let open = false;
-    return parts.map((part) => {
-        const reopened = open ? `\`\`\`\n${part}` : part;
-        // The prepended fence counts too, so a chunk that closes the block it
-        // inherited comes out even and clears the flag.
-        open = ((reopened.match(/```/g) ?? []).length % 2) === 1;
-        return open ? `${reopened}\n\`\`\`` : reopened;
-    });
-}
 /**
  * The body of a turn, as Slack's own markdown renderer sees it. Preferred over
  * `section` for everything the agent wrote: it takes the markdown unmodified

package/dist/channels/slack.js

@@ -22,11 +22,13 @@
 //
 // Everything policy-shaped (mention/bind gates, per-chat overrides) is in
 // config.ts, platform-blind and shared with Telegram.
-import { saveInbound } from "../core/inbox.js";
-import { fileMarker, lostMarker, MAX_INBOUND_BYTES } from "../core/inbound-file.js";
+import { saveInboundAll } from "../core/inbox.js";
+import { MAX_INBOUND_BYTES } from "../core/inbound-file.js";
+import { bindHint, bindResult, picked, STALE_OPTION, STOPPED } from "./lines.js";
 import { logger } from "../log.js";
 import { Chains } from "./chains.js";
 import { parseCommand } from "./commands.js";
+import { Dedup } from "./dedup.js";
 import { Gatekeeper } from "./gatekeeper.js";
 import { ReceiptLedger, Receipts } from "./receipts.js";
 import { SlackDirectory } from "./slack-directory.js";
@@ -112,7 +114,7 @@ export class SlackChannel {
     /** The inbound gate and the bind-hint throttle; see gatekeeper.ts. */
     gate;
     /** `event_id`s already handled, against Slack's at-least-once delivery. */
-    seen = new Map();
+    seen;
     /** The in-chat settings panel; absent when no control was wired (tests). */
     panel;
     /** Channel kinds/names and user names, cached; see slack-directory.ts. */
@@ -138,6 +140,7 @@ export class SlackChannel {
         this.chains = new Chains(this.log, MAX_ACTIVE_CHATS);
         this.directory = deps.directory ?? new SlackDirectory(this.log);
         this.gate = new Gatekeeper(deps.store, "slack", this.log, "channel");
+        this.seen = new Dedup(this.log, DEDUP_TTL_MS, DEDUP_MAX);
         this.api = deps.client ?? new SlackApi(config.token, config.appToken, this.log);
         this.out = new SlackOutbound(this.api, this.log);
         this.receipts = new Receipts(
@@ -210,7 +213,7 @@ export class SlackChannel {
                 this.log(`ignored event type ${event.type}`);
                 return;
             }
-            if (this.duplicate(payload?.event_id))
+            if (this.seen.duplicate(payload?.event_id))
                 return;
             const channel = event.channel;
             if (!channel)
@@ -230,29 +233,6 @@ export class SlackChannel {
         }
         this.log(`ignored envelope type ${env.type}`);
     }
-    /**
-     * Slack redelivers an envelope it did not see acknowledged, so the same
-     * `event_id` can arrive twice. Bounded and time-limited: the map is fed by
-     * every message in every channel the bot is in.
-     */
-    duplicate(eventId) {
-        if (!eventId)
-            return false;
-        const now = Date.now();
-        if (this.seen.size > DEDUP_MAX) {
-            for (const [id, at] of this.seen) {
-                if (now - at > DEDUP_TTL_MS)
-                    this.seen.delete(id);
-            }
-        }
-        const at = this.seen.get(eventId);
-        if (at !== undefined && now - at <= DEDUP_TTL_MS) {
-            this.log(`duplicate event ${eventId} ignored`);
-            return true;
-        }
-        this.seen.set(eventId, now);
-        return false;
-    }
     async onMessage(event, onMessage) {
         // Our own echo, another app, or a subtype that is not a person talking.
         if (event.bot_id || !event.user || event.user === this.me)
@@ -304,15 +284,19 @@ export class SlackChannel {
         // Downloading only past the gate: an unauthorized sender must not be able
         // to make the bot pull bytes on their behalf.
         const markers = await this.saveAttachments(files);
+        // A Slack thread is many people talking into one session, so the agent is
+        // told who spoke — and the id, which is what a mention needs. Resolved
+        // *before* the mark: every await between mark() and dispatch is a window
+        // in which a previous turn can end and settle, taking this receipt with it
+        // (paid for on Lark first).
+        const sender = { id: event.user, name: await this.directory.user(this.api, event.user) };
         this.receipts.mark(here.conversationId, channel, ts);
         // IM messages steer by default: a follow-up that waits for the turn to end
         // is the wrong default when the human is watching a 👀 in a thread.
         onMessage({
             key: here,
             senderId: event.user,
-            // A Slack thread is many people talking into one session, so the agent is
-            // told who spoke — and the id, which is what a mention needs.
-            sender: { id: event.user, name: await this.directory.user(this.api, event.user) },
+            sender,
             text: [text, ...markers].filter(Boolean).join("\n"),
             mode: "steer",
         });
@@ -356,7 +340,10 @@ export class SlackChannel {
             return;
         const text = offeredLabel(message.blocks, actionId);
         if (text === undefined) {
+            // The person clicked and would otherwise see nothing happen (5b).
             this.log(`unknown action ${actionId} in channel ${channel}`);
+            await this.api.postMessage({ channel, thread_ts: threadTs, text: STALE_OPTION })
+                .catch((err) => this.log(`stale-option notice failed: ${String(err)}`));
             return;
         }
         // The options belonged to the turn that just ended; once one is taken the
@@ -366,25 +353,21 @@ export class SlackChannel {
         // A bot cannot post as the user, so the pick is echoed and marked as one.
         // Without it the thread shows an answer to a request nobody can see being
         // made, and there is no message of the user's to carry the eyes.
+        const sender = { id: user, name: await this.directory.user(this.api, user) };
         const echo = await this.api.postMessage({
             channel,
             thread_ts: threadTs,
-            text: `\u25b8 ${escapeMrkdwn(text)}`,
+            text: picked(escapeMrkdwn(text)),
         }).catch((err) => {
             this.log(`option echo failed: ${String(err)}`);
             return undefined;
         });
         // The receipt goes on the echo, not on the bot message that held the
-        // buttons: the eyes mean "this input is being worked on".
+        // buttons: the eyes mean "this input is being worked on". No await
+        // between mark and dispatch — see onMessage.
         if (echo?.ts)
             this.receipts.mark(key.conversationId, channel, echo.ts);
-        onMessage({
-            key,
-            senderId: user,
-            sender: { id: user, name: await this.directory.user(this.api, user) },
-            text,
-            mode: "steer",
-        });
+        onMessage({ key, senderId: user, sender, text, mode: "steer" });
     }
     /**
      * Drop the actions row, keeping the reply itself exactly as it was. A turn
@@ -404,7 +387,7 @@ export class SlackChannel {
      */
     async abortTurn(key, channel, threadTs) {
         await this.deps.control?.abort(key);
-        await this.api.postMessage({ channel, thread_ts: threadTs, text: "⏹ Stopped." });
+        await this.api.postMessage({ channel, thread_ts: threadTs, text: STOPPED });
     }
     // --- bind ------------------------------------------------------------------
     /**
@@ -417,7 +400,7 @@ export class SlackChannel {
         await this.api.postMessage({
             channel,
             thread_ts: threadTs,
-            text: "You are not bound yet. Ask the operator for a bind code, then send `bind <code>`.",
+            text: bindHint("`bind <code>`"),
         }).catch((err) => this.log(`bind hint failed: ${String(err)}`));
     }
     async bind(channel, userId, threadTs, code) {
@@ -426,7 +409,7 @@ export class SlackChannel {
         await this.api.postMessage({
             channel,
             thread_ts: threadTs,
-            text: ok ? `Bound as ${escapeMrkdwn(name)}.` : "That bind code is invalid or expired.",
+            text: bindResult(ok, escapeMrkdwn(name)),
         });
     }
     // --- addressing ------------------------------------------------------------
@@ -459,27 +442,17 @@ export class SlackChannel {
         }
         return name ?? channel;
     }
-    /** Save uploads to the inbox; each becomes a prompt line — a failed one
-     *  becomes a lost-marker line, never silence (5b). */
-    async saveAttachments(files) {
-        const markers = [];
-        for (const file of files) {
-            // Metadata check before the fetch: any type is welcome, but a movie
-            // buffered whole into memory is not.
-            if (file.size !== undefined && file.size > MAX_INBOUND_BYTES) {
-                markers.push(lostMarker(file.name ?? "attachment", "too large"));
-                continue;
-            }
-            try {
-                const { bytes, mimeType } = await this.api.downloadFile(file);
-                markers.push(fileMarker(await saveInbound(this.id, file.name, mimeType, bytes)));
-            }
-            catch (err) {
-                this.log(`file download failed: ${String(err)}`);
-                markers.push(lostMarker(file.name ?? "attachment", "download failed"));
-            }
-        }
-        return markers;
+    /** The upload list as the shared save loop wants it (the loop itself, size
+     *  gate and lost markers included, is core/inbox.ts). */
+    saveAttachments(files) {
+        return saveInboundAll(this.id, files.map((file) => ({
+            label: file.name ?? "attachment",
+            name: file.name,
+            mimeType: file.mimetype ?? "application/octet-stream",
+            size: file.size,
+            // The response's content-type wins: Slack's metadata is a guess.
+            fetch: async () => this.api.downloadFile(file, MAX_INBOUND_BYTES),
+        })), this.log);
     }
     // --- outbound --------------------------------------------------------------
     /**
@@ -498,15 +471,9 @@ export class SlackChannel {
             await this.receipts.settle(conversation);
             return;
         }
-        try {
-            await this.out.reply(channel, threadTs, reply);
-        }
-        finally {
-            // Always: the turn ended either way, and a 👀 left on a user's message
-            // because the reply failed to send would sit there until the stale sweep
-            // half an hour later, looking like the agent is still working.
-            await this.receipts.settle(conversation);
-        }
+        // settleAfter: the turn ended either way, and a 👀 left up because the
+        // reply failed to send looks like work until the stale sweep.
+        await this.receipts.settleAfter(conversation, () => this.out.reply(channel, threadTs, reply));
     }
     /** A system note, posted without touching the receipts: the turn it triggers
      * has not ended yet. */

package/dist/channels/telegram-api.js

@@ -5,6 +5,7 @@
 //
 // Behind a proxy, run node with NODE_USE_ENV_PROXY=1 and HTTPS_PROXY set;
 // nothing here needs to know.
+import { readCapped } from "../core/inbox.js";
 const BASE = "https://api.telegram.org";
 export class TelegramApi {
     token;
@@ -62,7 +63,8 @@ export class TelegramApi {
     async answerCallbackQuery(id, text) {
         await this.call("answerCallbackQuery", { callback_query_id: id, text });
     }
-    async downloadFile(fileId) {
+    /** Bounded mid-stream: metadata size is the platform's word, not a cap. */
+    async downloadFile(fileId, maxBytes) {
         const file = await this.call("getFile", { file_id: fileId });
         if (!file.file_path)
             throw new Error("telegram getFile: no file_path");
@@ -72,6 +74,6 @@ export class TelegramApi {
         if (!res.ok)
             throw new Error(`telegram file download: ${res.status}`);
         const name = file.file_path.split("/").pop() || "file";
-        return { bytes: new Uint8Array(await res.arrayBuffer()), name };
+        return { bytes: await readCapped(res.body, maxBytes), name };
     }
 }

package/dist/channels/telegram-panel.js

@@ -5,7 +5,7 @@
 // Asking for a working directory costs a Map here: a forced reply arrives as
 // an ordinary message, so the prompt's message id has to be remembered to
 // recognize the answer. Slack's modal carries that context itself.
-import { ChatPanel, PANEL_PREFIX, } from "./panel.js";
+import { ChatPanel, CWD_PLACEHOLDER, CWD_TAIL, PANEL_PREFIX, } from "./panel.js";
 import { escapeHtml as esc } from "./telegram-render.js";
 const button = (b) => ({ text: b.label, callback_data: `${PANEL_PREFIX}${b.action}` });
 export class TelegramPanel extends ChatPanel {
@@ -84,8 +84,8 @@ export class TelegramPanel extends ChatPanel {
             chat_id: state.chatId,
             message_thread_id: state.topicId,
             // Said plainly: this is not an edit, it is a new session.
-            text: "Reply with an absolute path. A new session starts there; the current one stays in its own directory.",
-            reply_markup: { force_reply: true, input_field_placeholder: "/path/to/project" },
+            text: `Reply with an absolute path. ${CWD_TAIL}`,
+            reply_markup: { force_reply: true, input_field_placeholder: CWD_PLACEHOLDER },
         });
         this.cwdPrompts.set(key.conversationId, sent.message_id);
     }

package/dist/channels/telegram.js

@@ -12,8 +12,9 @@
 // Everything policy-shaped (mention/bind gates, per-chat overrides) is in
 // config.ts, platform-blind and shared with the adapters still to come.
 import { formatTurnMeta, isSilentReply, originLabel, quietLabel } from "../core/reply.js";
-import { saveInbound } from "../core/inbox.js";
-import { fileMarker, lostMarker, MAX_INBOUND_BYTES } from "../core/inbound-file.js";
+import { saveInboundAll } from "../core/inbox.js";
+import { MAX_INBOUND_BYTES } from "../core/inbound-file.js";
+import { bindHint, bindResult, picked, STALE_OPTION, STOPPED } from "./lines.js";
 import { logger } from "../log.js";
 import { Chains } from "./chains.js";
 import { parseCommand } from "./commands.js";
@@ -240,8 +241,14 @@ export class TelegramChannel {
             return;
         const text = offeredLabel(msg, query.data);
         if (text === undefined) {
-            await this.api.answerCallbackQuery(query.id, "That option is no longer on this message.")
-                .catch(() => { });
+            // Said in the chat, not as a second answerCallbackQuery: a query may be
+            // answered exactly once, and the toast already went to the ack above —
+            // against the real API the second answer is silently dropped.
+            await this.api.sendMessage({
+                chat_id: chatId,
+                message_thread_id: msg.message_thread_id,
+                text: STALE_OPTION,
+            }).catch((err) => this.log(`stale-option notice failed: ${String(err)}`));
             return;
         }
         // The options belonged to the turn that just ended; once one is taken the
@@ -258,7 +265,7 @@ export class TelegramChannel {
         const echo = await this.api.sendMessage({
             chat_id: chatId,
             message_thread_id: msg.message_thread_id,
-            text: `\u25b8 ${escapeHtml(text)}`,
+            text: picked(escapeHtml(text)),
             parse_mode: "HTML",
         }).catch((err) => {
             this.log(`option echo failed: ${String(err)}`);
@@ -284,7 +291,7 @@ export class TelegramChannel {
         await this.api.sendMessage({
             chat_id: msg.chat.id,
             message_thread_id: msg.message_thread_id,
-            text: "⏹ Stopped.",
+            text: STOPPED,
         });
     }
     /**
@@ -296,7 +303,7 @@ export class TelegramChannel {
             return;
         await this.api.sendMessage({
             chat_id: msg.chat.id,
-            text: "You are not bound yet. Ask the operator for a bind code, then send /bind <code>.",
+            text: bindHint("/bind <code>"),
         }).catch((err) => this.log(`bind hint failed: ${String(err)}`));
     }
     async bind(msg, code) {
@@ -305,7 +312,7 @@ export class TelegramChannel {
         const ok = this.deps.store.redeemBindCode("telegram", code, { id: String(user.id), name });
         await this.api.sendMessage({
             chat_id: msg.chat.id,
-            text: ok ? `Bound as ${name}.` : "That bind code is invalid or expired.",
+            text: bindResult(ok, name),
         });
     }
     /**
@@ -355,32 +362,28 @@ export class TelegramChannel {
             return msg.message_thread_id;
         }
     }
-    /** Save the message's attachments to the inbox; each becomes a prompt
-     *  line — a failed one becomes a lost-marker line, never silence (5b). */
-    async saveAttachments(msg) {
+    /** The message's attachments as the shared save loop wants them (the loop
+     *  itself, size gate and lost markers included, is core/inbox.ts). */
+    saveAttachments(msg) {
         // Telegram sends a photo as a size ladder — the last entry is the largest.
         const photo = msg.photo?.at(-1);
         const doc = msg.document;
-        const wanted = [
-            ...(photo ? [{ id: photo.file_id, name: undefined, label: "photo", mime: "image/jpeg", size: photo.file_size }] : []),
-            ...(doc ? [{ id: doc.file_id, name: doc.file_name, label: doc.file_name ?? "file", mime: doc.mime_type ?? "application/octet-stream", size: doc.file_size }] : []),
-        ];
-        const markers = [];
-        for (const { id, name, label, mime, size } of wanted) {
-            if (size !== undefined && size > MAX_INBOUND_BYTES) {
-                markers.push(lostMarker(label, "too large"));
-                continue;
-            }
-            try {
-                const file = await this.api.downloadFile(id);
-                markers.push(fileMarker(await saveInbound(this.id, name ?? file.name, mime, file.bytes)));
-            }
-            catch (err) {
-                this.log(`attachment download failed: ${String(err)}`);
-                markers.push(lostMarker(label, "download failed"));
-            }
-        }
-        return markers;
+        return saveInboundAll(this.id, [
+            ...(photo ? [{
+                    label: "photo",
+                    mimeType: "image/jpeg",
+                    size: photo.file_size,
+                    // Telegram only learns a filename from getFile, so the fetch's wins.
+                    fetch: async () => this.api.downloadFile(photo.file_id, MAX_INBOUND_BYTES),
+                }] : []),
+            ...(doc ? [{
+                    label: doc.file_name ?? "file",
+                    name: doc.file_name,
+                    mimeType: doc.mime_type ?? "application/octet-stream",
+                    size: doc.file_size,
+                    fetch: async () => this.api.downloadFile(doc.file_id, MAX_INBOUND_BYTES),
+                }] : []),
+        ], this.log);
     }
     // --- addressing ------------------------------------------------------------
     /** Mentioned, replying to the bot, or a slash command aimed at this bot. */
@@ -419,27 +422,28 @@ export class TelegramChannel {
         const quiet = isSilentReply(reply)
             ? `<i>${quietLabel(reply.silence && escapeHtml(reply.silence))}</i>`
             : "";
-        const body = (text ? toTelegramHtml(text) : quiet) + turnFooter(reply.meta);
-        try {
-            if (body.trim()) {
-                const parts = chunk(body);
-                for (const [i, part] of parts.entries()) {
-                    await this.api.sendMessage({
-                        chat_id: chatId,
-                        message_thread_id: topicId,
-                        text: part,
-                        parse_mode: "HTML",
-                        // Next-step buttons ride the last chunk; a click sends the label.
-                        reply_markup: i === parts.length - 1 ? buttons : undefined,
-                    });
-                }
+        // A turn that is only its options still has to carry them: with no text,
+        // no silence marker and no meta the body is empty, and a keyboard cannot
+        // ride a message that was never sent — so it gets the smallest one.
+        const body = ((text ? toTelegramHtml(text) : quiet) + turnFooter(reply.meta)) ||
+            (buttons ? "…" : "");
+        // settleAfter: a 👀 left up because the reply failed would sit there until
+        // the stale sweep, looking like the agent is still working.
+        await this.receipts.settleAfter(conversation, async () => {
+            if (!body.trim())
+                return;
+            const parts = chunk(body);
+            for (const [i, part] of parts.entries()) {
+                await this.api.sendMessage({
+                    chat_id: chatId,
+                    message_thread_id: topicId,
+                    text: part,
+                    parse_mode: "HTML",
+                    // Next-step buttons ride the last chunk; a click sends the label.
+                    reply_markup: i === parts.length - 1 ? buttons : undefined,
+                });
             }
-        }
-        finally {
-            // Always: a 👀 left up because the reply failed would sit there until the
-            // stale sweep, looking like the agent is still working.
-            await this.receipts.settle(conversation);
-        }
+        });
     }
     /**
      * A system note: quoted, labelled with where it came from, and deliberately

package/dist/channels/types.js

@@ -10,6 +10,15 @@
 const PLATFORMS = ["telegram", "slack", "lark"];
 /** Validate at the boundary: an unknown platform is a 404, not a new row. */
 export const isChannelPlatform = (v) => typeof v === "string" && PLATFORMS.includes(v);
+/**
+ * The chat a conversation id belongs to. Every adapter spells its ids
+ * `<chatId>` or `<chatId>/<thread>` — Telegram's topic, Slack's thread_ts,
+ * Lark's root message — so the chat half has one decoder instead of one per
+ * platform (control.ts used to import all three adapters for exactly this).
+ * The *thread* half stays with each adapter: its type and meaning genuinely
+ * differ per platform.
+ */
+export const chatOf = (conversationId) => conversationId.split("/", 1)[0] ?? "";
 export const defaultChannelConfig = () => ({
     enabled: false,
     token: "",

package/dist/cli.js

@@ -178,7 +178,9 @@ async function signalService(command) {
 }
 async function backup() {
     const [{ backupDb }, { PIER_DB }] = await Promise.all([import("./db.js"), import("./paths.js")]);
-    const path = backupDb(PIER_DB);
+    // This tree's version: the updater runs `backup` before npm replaces it, so
+    // it is the release the copy pairs with.
+    const path = backupDb(version, PIER_DB);
     process.stdout.write(path ? `backed up ${path}\n` : `no database yet — nothing to back up.\n`);
 }
 function commandPath(name) {