@timqi/pier 0.1.3 → 0.1.5

package/dist/channels/slack-tool.js

@@ -1,416 +0,0 @@
-// The agent-facing Slack tool: the model states an intent, Pier performs it,
-// and the token never leaves Pier. Every read goes to Slack — only it knows
-// about an edit or a deletion. Affordable because a workspace-internal app gets
-// Tier 3 (~50+ req/min) on history/replies; a distributed non-Marketplace app
-// is capped at 1 req/min, and that is the decision to revisit.
-import { Type } from "typebox";
-import { saveInboundAll } from "../core/inbox.js";
-import { MAX_INBOUND_BYTES } from "../core/inbound-file.js";
-import { MARKDOWN_MAX } from "./slack-render.js";
-/** So a wide range cannot blow up the model's context. */
-const MAX_MESSAGES = 400;
-const MAX_PAGES = 10;
-const INBOX_CHANNEL = "slack";
-/** A `ts` is `<epoch seconds>.<microseconds>`: sorts as a number, not as a
- *  string. Never rewritten — it is the id a reply must match exactly. */
-const tsToNumber = (ts) => Number(ts);
-const tsToIso = (ts) => new Date(Math.floor(tsToNumber(ts) * 1000)).toISOString();
-const tsToMinute = (ts) => `${tsToIso(ts).slice(0, 16)}Z`;
-/** Epoch seconds at the year 2100: past this, the caller meant milliseconds. */
-const MAX_SECONDS = 4_102_444_800;
-/** Accepts an ISO date, an epoch-seconds number, or a raw Slack ts. */
-export function toTs(value) {
-    if (value === undefined || value === "")
-        return undefined;
-    const raw = typeof value === "number" ? String(value) : value.trim();
-    const numeric = /^\d+(\.\d+)?$/.test(raw);
-    const seconds = numeric ? Number(raw) : Date.parse(raw) / 1000;
-    if (Number.isNaN(seconds))
-        throw new Error(`not a time: ${value}`);
-    // Milliseconds: Slack takes the window without complaint and answers an empty
-    // read indistinguishable from a channel where nobody spoke.
-    if (seconds > MAX_SECONDS) {
-        throw new Error(`${value} is past the year 2100 — Slack times are epoch seconds, not milliseconds`);
-    }
-    return numeric ? raw : String(seconds);
-}
-/** Asked before the description is paid for. `handleSlackTool` keeps its own
- *  checks: a session opened while Slack was configured outlives the switch. */
-export function slackToolAvailable(store) {
-    const config = store.get("slack");
-    return config.enabled && !!config.token && config.agentTool;
-}
-export function slackToolSpec(execute, available) {
-    return {
-        name: "slack",
-        label: "Slack",
-        description: "Read and write Slack through Pier, which holds the bot token. Operations: context (which Slack conversation this session is in), read_channel (transcript for a time range), read_thread (one thread; only what is new since a message via after), read_message (the one at ts), fetch_file (save a file a transcript names, by its F… id), post, edit/delete (Pier's own messages only), channels (what Pier can reach). Omit channel and thread_ts to act on the conversation you are in. since/until/after accept ISO 8601, epoch seconds or a ts. Every read fetches live; nothing is kept between calls. @mentions, #channels and links need Slack's own syntax — read the pier-slack skill before posting.",
-        parameters: Type.Object({
-            // A JSON-Schema enum emits far fewer tokens than typebox's anyOf-of-consts.
-            operation: Type.Unsafe({
-                type: "string",
-                enum: [
-                    "context",
-                    "read_channel",
-                    "read_thread",
-                    "read_message",
-                    "fetch_file",
-                    "post",
-                    "edit",
-                    "delete",
-                    "channels",
-                ],
-            }),
-            channel: Type.Optional(Type.String()),
-            since: Type.Optional(Type.String()),
-            until: Type.Optional(Type.String()),
-            after: Type.Optional(Type.String()),
-            ts: Type.Optional(Type.String()),
-            file: Type.Optional(Type.String()),
-            limit: Type.Optional(Type.Number()),
-            thread_ts: Type.Optional(Type.String()),
-            text: Type.Optional(Type.String()),
-        }),
-        available,
-        skill: "pier-slack",
-        execute,
-    };
-}
-const required = (value, field) => {
-    if (typeof value !== "string" || !value.trim())
-        throw new Error(`${field} is required`);
-    return value.trim();
-};
-/** Slack rejects an oversized message outright; a refusal the agent can act
- *  on beats a post that silently never happened. */
-const messageText = (raw) => {
-    const text = required(raw, "text");
-    if (text.length > MARKDOWN_MAX) {
-        throw new Error(`text is ${text.length} chars; Slack accepts ${MARKDOWN_MAX} per message`);
-    }
-    return text;
-};
-const record = (raw) => raw && typeof raw === "object" && !Array.isArray(raw) ? raw : undefined;
-export async function handleSlackTool(deps, raw, callerSessionId = "") {
-    const input = record(raw);
-    if (!input)
-        throw new Error("slack tool parameters required");
-    const config = deps.store.get("slack");
-    // The error says which switch: "it does nothing" is the most expensive
-    // failure for a model to diagnose.
-    if (!config.enabled || !config.token)
-        throw new Error("the Slack channel is not configured in Pier");
-    if (!config.agentTool)
-        throw new Error("Slack agent access is switched off in Pier's Console");
-    const client = deps.client();
-    if (!client)
-        throw new Error("the Slack client is unavailable");
-    if (input.operation === "channels") {
-        // Only what Pier has seen: Slack has no reliable "list my channels".
-        return config.chats.map((chat) => ({
-            id: chat.id,
-            name: chat.name,
-            kind: chat.kind,
-            respondsToMessages: chat.enabled,
-        }));
-    }
-    const at = deps.here(callerSessionId);
-    if (input.operation === "context") {
-        if (!at) {
-            return {
-                inSlack: false,
-                note: "This session was not reached through Slack, so there is no current conversation. Name a channel explicitly.",
-            };
-        }
-        const chat = config.chats.find((c) => c.id === at.channel);
-        return {
-            inSlack: true,
-            channel: at.channel,
-            channelName: chat?.name ?? at.channel,
-            kind: chat?.kind ?? null,
-            threadTs: at.threadTs,
-            note: "Omit channel and thread_ts to read or post here. Speaker ids for mentions come from read_thread.",
-        };
-    }
-    // Before the channel default: a file id is unique workspace-wide.
-    if (input.operation === "fetch_file") {
-        return fetchFile(deps, client, required(input.file, "file"));
-    }
-    const channel = input.channel === undefined || input.channel === ""
-        ? at?.channel ??
-            (() => {
-                throw new Error("channel is required: this session was not reached through Slack, so there is no current conversation");
-            })()
-        : resolveChannel(deps, required(input.channel, "channel"));
-    // Slack's bounds are inclusive-ish, so the boundary message is dropped here.
-    const after = toTs(input.after);
-    const limit = Math.min(Number(input.limit) || MAX_MESSAGES, MAX_MESSAGES);
-    if (input.operation === "read_channel") {
-        const since = after ?? toTs(input.since);
-        const until = toTs(input.until);
-        return readChannel(deps, client, channel, since, until, after, limit);
-    }
-    if (input.operation === "read_thread") {
-        const threadTs = typeof input.thread_ts === "string" && input.thread_ts.trim()
-            ? input.thread_ts.trim()
-            : at?.threadTs;
-        if (!threadTs)
-            throw new Error("thread_ts is required outside a Slack thread");
-        return readThread(deps, client, channel, threadTs, after, limit);
-    }
-    if (input.operation === "read_message") {
-        const asked = typeof input.thread_ts === "string" ? input.thread_ts.trim() : "";
-        return readMessage(deps, client, channel, required(input.ts, "ts"), asked || undefined);
-    }
-    if (input.operation === "post") {
-        const text = messageText(input.text);
-        // `thread_ts: "none"` is the explicit way to start a top-level message.
-        const asked = typeof input.thread_ts === "string" ? input.thread_ts.trim() : "";
-        const threadTs = asked === "none"
-            ? undefined
-            : asked || (channel === at?.channel ? at?.threadTs : undefined);
-        const sent = await client.postMessage({
-            channel,
-            thread_ts: threadTs,
-            text,
-            // Slack's own markdown renderer: the agent writes markdown, not mrkdwn.
-            blocks: [{ type: "markdown", text }],
-        });
-        return {
-            channel,
-            ts: sent.ts,
-            at: sent.ts ? tsToIso(sent.ts) : null,
-            threadTs: threadTs ?? sent.ts,
-            ...inertMention(text),
-        };
-    }
-    if (input.operation === "edit") {
-        const ts = required(input.ts, "ts");
-        const text = messageText(input.text);
-        // `conversations.history` cannot see inside a thread, so the read below
-        // needs the thread `post` would default to.
-        const asked = typeof input.thread_ts === "string" ? input.thread_ts.trim() : "";
-        const inThread = asked || (channel === at?.channel ? at?.threadTs : undefined);
-        // Slack keeps no version, so this log is the only record of what was replaced.
-        const was = await previousText(client, channel, ts, inThread);
-        try {
-            await client.updateMessage({ channel, ts, text, blocks: [{ type: "markdown", text }] });
-        }
-        catch (err) {
-            throw new Error(explain(err));
-        }
-        deps.log(`slack tool edited ${ts} in ${channel}; was: ${was ?? "(not captured)"}`);
-        return { channel, ts, edited: true, ...inertMention(text) };
-    }
-    if (input.operation === "delete") {
-        // Never defaulted from `here`: an implied target is the one mistake with no undo.
-        const ts = required(input.ts, "ts");
-        try {
-            await client.deleteMessage(channel, ts);
-        }
-        catch (err) {
-            throw new Error(explain(err));
-        }
-        deps.log(`slack tool deleted ${ts} in ${channel}`);
-        return { channel, ts, deleted: true };
-    }
-    throw new Error(`unknown slack operation: ${String(input.operation)}`);
-}
-/** `conversations.history` never returns what was posted inside a thread, so
- *  a reply has to be asked for through its thread. */
-async function oneMessage(client, channel, ts, threadTs) {
-    const page = threadTs
-        ? await client.replies(channel, threadTs, { oldest: ts, limit: 20 })
-        : await client.history(channel, { oldest: ts, latest: ts, limit: 1 });
-    return page.messages.find((msg) => msg.ts === ts);
-}
-async function previousText(client, channel, ts, threadTs) {
-    try {
-        const text = (await oneMessage(client, channel, ts, threadTs))?.text;
-        return text === undefined ? undefined : text.slice(0, 200).replace(/\s+/g, " ");
-    }
-    catch {
-        // The caller logs "not captured"; refusing the edit over it would be worse.
-        return undefined;
-    }
-}
-/** A plain `@alice` looks like it worked and notifies nobody. Reported, not
- *  refused: a name in prose is legitimate. */
-function inertMention(text) {
-    const prose = text
-        .replace(/```[\s\S]*?```|`[^`]*`/g, "") // code says @ and # for other reasons
-        .replace(/<[^>]*>/g, ""); // already Slack syntax
-    const hit = /(?:^|\s)([@#][A-Za-z][\w.-]*)/.exec(prose)?.[1];
-    if (!hit)
-        return {};
-    const as = hit.startsWith("@")
-        ? /^@(here|channel|everyone)$/.test(hit) ? `<!${hit.slice(1)}>` : "<@U…>"
-        : "<#C…>";
-    return {
-        hint: `${hit} is plain text and notified nobody — Slack needs ${as}. ` +
-            `Edit this ts if it was meant to reach someone.`,
-    };
-}
-function resolveChannel(deps, given) {
-    if (/^[CDG][A-Z0-9]+$/.test(given))
-        return given;
-    const wanted = given.replace(/^#/, "").toLowerCase();
-    const chats = deps.store.get("slack").chats;
-    const hit = chats.find((chat) => chat.name.replace(/^#/, "").toLowerCase() === wanted);
-    if (hit)
-        return hit.id;
-    throw new Error(`unknown channel ${given}; use an id or one of: ${chats.map((c) => c.name).join(", ") || "(none discovered yet)"}`);
-}
-async function readChannel(deps, client, channel, since, until, after, limit) {
-    const fetched = await fetchPages(deps, (cursor) => client.history(channel, { oldest: since, latest: until, cursor }), `history for ${channel}`);
-    const all = newerThan(transcript(fetched.messages), after);
-    // Truncated at the newest end: the oldest `limit` messages read as a transcript.
-    const window = all.slice(0, limit);
-    return {
-        channel,
-        range: `${since ? tsToMinute(since) : "start"} → ${until ? tsToMinute(until) : "now"}`,
-        count: window.length,
-        ...(fetched.truncated || all.length > window.length ? { truncated: true } : {}),
-        ...(fetched.incomplete ? { incomplete: fetched.incomplete } : {}),
-        format: LINE_FORMAT,
-        messages: await lines(deps, client, window),
-    };
-}
-/** Exported for the adapter, which inlines a small shared thread. */
-export async function readThread(deps, client, channel, threadTs, after, limit) {
-    const fetched = await fetchPages(deps, (cursor) => client.replies(channel, threadTs, { oldest: after, cursor }), `thread ${threadTs} in ${channel}`);
-    const all = newerThan(transcript(fetched.messages), after);
-    const messages = all.slice(0, limit);
-    return {
-        channel,
-        threadTs,
-        count: messages.length,
-        ...(fetched.truncated || all.length > messages.length ? { truncated: true } : {}),
-        ...(fetched.incomplete ? { incomplete: fetched.incomplete } : {}),
-        format: LINE_FORMAT,
-        messages: await lines(deps, client, messages),
-    };
-}
-async function readMessage(deps, client, channel, ts, threadTs) {
-    const found = await oneMessage(client, channel, ts, threadTs);
-    if (!found) {
-        throw new Error(threadTs
-            ? `no message ${ts} in thread ${threadTs}`
-            : `no message ${ts} in that channel — a reply posted inside a thread needs thread_ts`);
-    }
-    const [line] = await lines(deps, client, [found]);
-    return {
-        channel,
-        ...(found.thread_ts ? { threadTs: found.thread_ts } : {}),
-        format: LINE_FORMAT,
-        message: line,
-    };
-}
-/** Explicit, not automatic: one read can name a hundred uploads, and the agent
- *  knows which one the question is about. `files.info` every call: the signed
- *  url expires. */
-async function fetchFile(deps, client, id) {
-    let file;
-    try {
-        file = await client.filesInfo(id);
-    }
-    catch (err) {
-        // Manifest scopes apply only at app creation, so an older install refuses
-        // for a reason no agent can guess.
-        if (/missing_scope/.test(String(err))) {
-            throw new Error("Pier's Slack app cannot read files — add the files:read scope to the Slack app " +
-                "under OAuth & Permissions and reinstall it");
-        }
-        throw new Error(explain(err));
-    }
-    const [marker] = await saveInboundAll(INBOX_CHANNEL, [{
-            label: file.name ?? id,
-            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: () => client.downloadFile(file, MAX_INBOUND_BYTES),
-        }], deps.log);
-    return marker;
-}
-/** A page that fails mid-walk keeps the pages before it, plus why it stopped:
- *  an exception alone cannot be told from a quiet channel. */
-async function fetchPages(deps, page, what) {
-    const messages = [];
-    let cursor;
-    for (let i = 0; i < MAX_PAGES; i++) {
-        let batch;
-        try {
-            batch = await page(cursor);
-        }
-        catch (err) {
-            if (messages.length === 0)
-                throw new Error(explain(err));
-            deps.log(`${what} stopped after ${messages.length} messages: ${String(err)}`);
-            return { messages, truncated: true, incomplete: explain(err) };
-        }
-        messages.push(...batch.messages);
-        cursor = batch.nextCursor;
-        if (!cursor || messages.length >= MAX_MESSAGES)
-            break;
-    }
-    if (cursor)
-        deps.log(`${what} truncated at ${messages.length} messages`);
-    return { messages, truncated: cursor !== undefined };
-}
-/** Error codes an agent can act on become the action; the rest keep their
- *  searchable raw code. */
-function explain(err) {
-    const code = /slack [\w.]+: (\w+)/.exec(String(err))?.[1] ?? "";
-    return {
-        channel_not_found: "no such channel, or Pier's bot cannot see it — check the channels operation",
-        not_in_channel: "Pier's bot is not in that channel; someone has to run `/invite @Pier` there before it can read",
-        missing_scope: "Pier's Slack app lacks the scope for this call; the operator must reinstall it",
-        ratelimited: "Slack rate-limited Pier; wait a minute, and narrow the range if this was a read",
-        thread_not_found: "no thread with that ts in this channel",
-        cant_delete_message: "Slack only lets Pier delete what its own bot posted; a person's message has to be deleted by them",
-        cant_update_message: "Slack only lets Pier edit what its own bot posted; anyone else's message can only be replied to",
-        edit_window_closed: "Slack's edit window for that message has closed; post a correction instead of rewriting it",
-        message_not_found: "no message with that ts in this channel — a ts only means anything in the conversation it came from",
-        file_not_found: "no file with that id, or Pier's bot cannot see it — the F… id comes from a transcript line",
-    }[code] ?? String(err);
-}
-/** Strictly newer, so `after: <last ts I saw>` never repeats that message. */
-const newerThan = (messages, after) => after === undefined ? messages : messages.filter((m) => tsToNumber(m.ts) > tsToNumber(after));
-/** Oldest first, one per ts: page bounds are inclusive-ish, so a paged read
- *  can repeat the message on the seam. */
-function transcript(messages) {
-    const byTs = new Map();
-    for (const msg of messages)
-        if (msg.ts)
-            byTs.set(msg.ts, msg);
-    return [...byTs.values()].sort((a, b) => tsToNumber(a.ts) - tsToNumber(b.ts));
-}
-/** Lines, not objects: four hundred six-key objects spend most of their tokens
- *  on key names. The id is the only thing `<@…>` can be built from. Terse: the
- *  adapter puts this string in a prompt, so every word is paid for per read. */
-const LINE_FORMAT = "<ts> | <time, UTC> | <name>[<id>] | <text>, then — when there are any —"
-    + " [thread: <n> replies] and one [file: <name> <F… id> <size>] per upload";
-/** Enough to judge a fetch against the 32 MB cap without arithmetic. */
-const sizeLabel = (bytes) => bytes < 1024
-    ? `${bytes}B`
-    : bytes < 1024 * 1024
-        ? `${Math.round(bytes / 1024)}KB`
-        : `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
-/** Without this a PDF somebody posted reads as an empty message. */
-const uploads = (files) => (files ?? []).map((file) => ` [file: ${file.name ?? file.mimetype ?? "file"} ${file.id}${file.size === undefined ? "" : ` ${sizeLabel(file.size)}`}]`).join("");
-const speaker = (msg) => msg.user ?? msg.bot_id ?? null;
-async function lines(deps, client, messages) {
-    // The store is not consulted: a member need not be bound to have spoken.
-    const ids = messages.map(speaker).filter((id) => !!id);
-    const names = await deps.directory.names(client, ids);
-    return messages.map((msg) => {
-        const id = speaker(msg);
-        const known = id ? names.get(id) : undefined;
-        const who = id ? (known && known !== id ? `${known}[${id}]` : `[${id}]`) : "[unknown]";
-        const replies = msg.reply_count && (msg.thread_ts ?? msg.ts) === msg.ts
-            ? ` [thread: ${msg.reply_count} replies]`
-            : "";
-        return `${msg.ts} | ${tsToMinute(msg.ts)} | ${who} | ${msg.text ?? ""}${replies}${uploads(msg.files)}`;
-    });
-}

package/dist/channels/telegram-api.js

@@ -1,86 +0,0 @@
-// Thin Telegram Bot API client: HTTP and payload shapes only, no policy; the
-// one file that talks to api.telegram.org. Long polling, so Pier needs no
-// inbound HTTP. Behind a proxy: NODE_USE_ENV_PROXY=1 and HTTPS_PROXY.
-import { readCapped } from "../core/inbox.js";
-const BASE = "https://api.telegram.org";
-export class TelegramApi {
-    token;
-    constructor(token) {
-        this.token = token;
-    }
-    async call(method, payload, timeoutMs = 30_000, retry = true) {
-        // FormData is re-sendable, so the flood retry below still works on it.
-        const multipart = payload instanceof FormData;
-        const res = await fetch(`${BASE}/bot${this.token}/${method}`, {
-            method: "POST",
-            headers: multipart ? undefined : { "content-type": "application/json" },
-            body: multipart ? payload : JSON.stringify(payload),
-            signal: AbortSignal.timeout(timeoutMs),
-        });
-        const body = (await res.json());
-        if (body.ok)
-            return body.result;
-        // A long turn split into chunks hits ~1 msg/s per chat; `retry_after` is
-        // the exact wait. Obeyed once; a second 429 throws.
-        const after = body.parameters?.retry_after;
-        if (retry && after !== undefined && after <= 60) {
-            await new Promise((r) => setTimeout(r, (after + 1) * 1000));
-            return this.call(method, payload, timeoutMs, false);
-        }
-        throw new Error(`telegram ${method}: ${body.description ?? res.status}`);
-    }
-    getMe() {
-        return this.call("getMe", {});
-    }
-    getUpdates(offset, timeoutSeconds) {
-        return this.call("getUpdates", { offset, timeout: timeoutSeconds, allowed_updates: ["message", "callback_query"] }, (timeoutSeconds + 15) * 1000);
-    }
-    sendMessage(payload) {
-        return this.call("sendMessage", payload);
-    }
-    async sendFile({ chat_id, message_thread_id, file }) {
-        const form = new FormData();
-        form.set("chat_id", String(chat_id));
-        if (message_thread_id !== undefined)
-            form.set("message_thread_id", String(message_thread_id));
-        const field = file.image ? "photo" : "document";
-        // A Blob part must be backed by an ArrayBuffer, not a Buffer's ArrayBufferLike.
-        form.set(field, new Blob([new Uint8Array(file.bytes)]), file.name);
-        // 30s is the budget for a JSON call, not for megabytes on a slow link.
-        await this.call(file.image ? "sendPhoto" : "sendDocument", form, 120_000);
-    }
-    async editMessage(payload) {
-        await this.call("editMessageText", payload);
-    }
-    async deleteMessage(chatId, messageId) {
-        await this.call("deleteMessage", { chat_id: chatId, message_id: messageId });
-    }
-    async clearKeyboard(chatId, messageId) {
-        await this.call("editMessageReplyMarkup", { chat_id: chatId, message_id: messageId });
-    }
-    async setReaction(chatId, messageId, emoji) {
-        await this.call("setMessageReaction", {
-            chat_id: chatId,
-            message_id: messageId,
-            reaction: emoji ? [{ type: "emoji", emoji }] : [],
-        });
-    }
-    createForumTopic(chatId, name) {
-        return this.call("createForumTopic", { chat_id: chatId, name });
-    }
-    async answerCallbackQuery(id, text) {
-        await this.call("answerCallbackQuery", { callback_query_id: id, text });
-    }
-    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");
-        const res = await fetch(`${BASE}/file/bot${this.token}/${file.file_path}`, {
-            signal: AbortSignal.timeout(60_000),
-        });
-        if (!res.ok)
-            throw new Error(`telegram file download: ${res.status}`);
-        const name = file.file_path.split("/").pop() || "file";
-        return { bytes: await readCapped(res.body, maxBytes), name };
-    }
-}

package/dist/channels/telegram-panel.js

@@ -1,97 +0,0 @@
-// Telegram's half of the settings panel (panel.ts has the rest). A forced reply
-// arrives as an ordinary message, so the prompt's id is remembered to recognize it.
-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 {
-    deps;
-    platform = "telegram";
-    fence = ["<code>", "</code>"];
-    cwdPrompts = new Map();
-    constructor(deps) {
-        super(deps);
-        this.deps = deps;
-    }
-    esc(text) {
-        return esc(text);
-    }
-    gateExtras(chat, policy) {
-        return chat.kind === "forum" ? ` · topics ${policy.topicMode ? "on" : "off"}` : "";
-    }
-    // --- rendering ---------------------------------------------------------------
-    text(view, note) {
-        const body = view.groups
-            .map((g) => [`<b>${g.title}</b>${g.suffix ?? ""}`, ...g.lines].join("\n"))
-            .join("\n\n");
-        return note ? `${body}\n\n<i>${esc(note)}</i>` : body;
-    }
-    /** A long model id does not share a row with anything. */
-    keyboard(view) {
-        return {
-            inline_keyboard: [
-                ...(view.picks ?? []).map((pick) => [button(pick)]),
-                ...view.rows.map((row) => row.map(button)),
-            ],
-        };
-    }
-    async open(key, chatId, topicId) {
-        const view = await this.view(key, chatId);
-        const sent = await this.deps.api.sendMessage({
-            chat_id: chatId,
-            message_thread_id: topicId,
-            text: this.text(view),
-            parse_mode: "HTML",
-            reply_markup: this.keyboard(view),
-        });
-        this.remember(key, { chatId, topicId, messageId: sent.message_id, models: [] });
-    }
-    async draw(state, view, note) {
-        await this.deps.api.editMessage({
-            chat_id: state.chatId,
-            message_id: state.messageId,
-            text: this.text(view, note),
-            parse_mode: "HTML",
-            reply_markup: this.keyboard(view),
-        }).catch((err) => this.deps.log(`panel edit failed: ${String(err)}`));
-    }
-    async erase(state) {
-        await this.deps.api.deleteMessage(state.chatId, state.messageId)
-            .catch((err) => this.deps.log(`panel close failed: ${String(err)}`));
-    }
-    // --- actions -----------------------------------------------------------------
-    /** Returns false when the payload is not ours. */
-    async onCallback(query, key) {
-        return this.dispatch(key, query.data ?? "", undefined, async () => {
-            const message = query.message;
-            if (message)
-                await this.open(key, String(message.chat.id), message.message_thread_id);
-        });
-    }
-    // --- working directory (one typed answer) ------------------------------------
-    async promptCwd(key, state) {
-        const sent = await this.deps.api.sendMessage({
-            chat_id: state.chatId,
-            message_thread_id: state.topicId,
-            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);
-    }
-    /** True when this message was the answer and must not reach the agent. */
-    async consumeCwdReply(msg, key) {
-        const pending = this.cwdPrompts.get(key.conversationId);
-        if (!pending || msg.reply_to_message?.message_id !== pending)
-            return false;
-        this.cwdPrompts.delete(key.conversationId);
-        const path = (msg.text ?? "").trim();
-        const started = await this.startSessionIn(key, path);
-        // The answer was typed in the chat, so the outcome is said there too.
-        await this.deps.api.sendMessage({
-            chat_id: msg.chat.id,
-            message_thread_id: msg.message_thread_id,
-            text: "error" in started ? started.error : `New session in <code>${esc(path)}</code>.`,
-            parse_mode: "HTML",
-        });
-        return true;
-    }
-}

package/dist/channels/telegram-render.js

@@ -1,69 +0,0 @@
-import { chunkText } from "./chunk.js";
-// How a reply looks on Telegram: markdown → Bot API HTML. Telegram's parser
-// rejects the whole message on any tag outside its documented set (b, i, s,
-// code, pre, a), so text is escaped first and only those are reintroduced.
-const MAX_CHARS = 3800; // Telegram's hard limit is 4096; leave room for tags.
-export const escapeHtml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-/** Inline emphasis, applied after escaping so `<b>` can only come from us. */
-function inline(text) {
-    return text
-        // Links first: their label may itself carry emphasis.
-        .replace(/\[([^\]\n]+)\]\((https?:\/\/[^\s)]+)\)/g, (_m, label, url) => `<a href="${url.replace(/"/g, "&quot;")}">${label}</a>`)
-        .replace(/\*\*([^\n*]+)\*\*/g, "<b>$1</b>")
-        .replace(/~~([^\n~]+)~~/g, "<s>$1</s>")
-        .replace(/(^|[\s(])[*_]([^\n*_]+)[*_](?=[\s).,!?:;]|$)/g, "$1<i>$2</i>")
-        .replace(/^#{1,6}[ \t]+(.+)$/gm, "<b>$1</b>");
-}
-/** Code is stashed before escaping so emphasis inside it stays literal. */
-export function toTelegramHtml(markdown) {
-    const stash = [];
-    const keep = (html) => `\uE000${stash.push(html) - 1}\uE001`;
-    let out = markdown.replace(/```([\w.+-]*)\n?([\s\S]*?)```/g, (_m, lang, code) => keep(lang
-        ? `<pre><code class="language-${escapeHtml(lang)}">${escapeHtml(code.replace(/\n+$/, ""))}</code></pre>`
-        : `<pre>${escapeHtml(code.replace(/\n+$/, ""))}</pre>`));
-    out = out.replace(/`([^`\n]+)`/g, (_m, code) => keep(`<code>${escapeHtml(code)}</code>`));
-    out = inline(escapeHtml(out));
-    return out.replace(/\uE000(\d+)\uE001/g, (_m, i) => stash[Number(i)] ?? "");
-}
-/** A cut inside a <pre> block is fine: Telegram closes the tag on its own. */
-export const chunk = (html) => chunkText(html, MAX_CHARS);
-// --- next-step buttons -------------------------------------------------------
-/** `callback_data` caps at 64 bytes (~21 CJK characters), so buttons send an
- *  index and the label is read back off the message's own keyboard. */
-export const OFFER_PREFIX = "sg:";
-// Buttons in one row split its width evenly, so packing is budgeted by display
-// width, not count.
-const ROW_WIDTH = 26;
-const ROW_BUTTONS = 3;
-/** CJK, fullwidth punctuation and emoji take two cells. */
-const displayWidth = (label) => [...label].reduce((n, ch) => n + ((ch.codePointAt(0) ?? 0) > 0x2e7f ? 2 : 1), 0);
-/** A row that is already wide stops accepting: a long label squeezed in
- *  truncates everything beside it. */
-export function keyboard(labels) {
-    if (!labels.length)
-        return undefined;
-    const rows = [];
-    let used = 0;
-    labels.forEach((label, index) => {
-        const width = displayWidth(label);
-        const row = rows.at(-1);
-        const button = { text: label, callback_data: `${OFFER_PREFIX}${index}` };
-        if (!row || row.length >= ROW_BUTTONS || used + width > ROW_WIDTH) {
-            rows.push([button]);
-            used = width;
-            return;
-        }
-        row.push(button);
-        used += width;
-    });
-    return { inline_keyboard: rows };
-}
-/** A payload we never wrote (an older label-as-payload button) passes through. */
-export function offeredLabel(msg, data) {
-    if (!data.startsWith(OFFER_PREFIX))
-        return data;
-    return msg.reply_markup?.inline_keyboard
-        .flat()
-        .find((button) => button.callback_data === data)
-        ?.text;
-}