pi-discord-bot 0.1.1

package/dist/discord-ui.js

@@ -0,0 +1,172 @@
+import { ActionRowBuilder, ButtonBuilder, ButtonStyle, EmbedBuilder, StringSelectMenuBuilder, } from "discord.js";
+export function formatWorkingText(text, working) {
+    return working ? `${text}\n\n...` : text;
+}
+export function chunkText(text, max = 1900) {
+    if (text.length <= max)
+        return [text];
+    const chunks = [];
+    let remaining = text;
+    while (remaining.length > max) {
+        let cut = remaining.lastIndexOf("\n", max);
+        if (cut < max * 0.5)
+            cut = remaining.lastIndexOf(" ", max);
+        if (cut < max * 0.5)
+            cut = max;
+        chunks.push(remaining.slice(0, cut).trimEnd());
+        remaining = remaining.slice(cut).trimStart();
+    }
+    if (remaining.length > 0)
+        chunks.push(remaining);
+    return chunks;
+}
+export function truncate(text, max = 180) {
+    return text.length <= max ? text : `${text.slice(0, max - 3)}...`;
+}
+export async function sendOrEditAnchor(params) {
+    const { slashInteraction, sendable, text } = params;
+    if (slashInteraction) {
+        if (params.replyMessageId) {
+            await slashInteraction.editReply(text);
+            return { replyMessageId: params.replyMessageId };
+        }
+        const response = await slashInteraction.editReply(text);
+        return { replyMessageId: response.id };
+    }
+    if (params.replyMessageId) {
+        const message = await sendable.messages.fetch(params.replyMessageId);
+        await message.edit(text);
+        return { replyMessageId: params.replyMessageId };
+    }
+    const sent = await sendable.send(text);
+    return { replyMessageId: sent.id };
+}
+export function buildModelSelectionCard(params) {
+    const page = params.page ?? 0;
+    const pageSize = 25;
+    const pageCount = Math.max(1, Math.ceil(params.models.length / pageSize));
+    const safePage = Math.min(Math.max(page, 0), pageCount - 1);
+    const start = safePage * pageSize;
+    const pageModels = params.models.slice(start, start + pageSize);
+    const customId = `model:${params.messageId}:${Date.now()}:select`;
+    const options = pageModels.map((value) => ({ label: value.slice(0, 100), value, default: value === params.currentModel }));
+    const embed = new EmbedBuilder()
+        .setTitle(`🤖 ${params.title ?? "Select a model"}`)
+        .setDescription([
+        `> **Current model**\n> \`${params.currentModel}\``,
+        pageCount > 1 ? `📄 Page **${safePage + 1}** of **${pageCount}** · ${params.models.length} models available` : `${params.models.length} models available`,
+        "Use the dropdown to pick a model" + (pageCount > 1 ? ", or **Prev / Next** to browse." : "."),
+    ].join("\n\n"))
+        .setColor(0x5865F2)
+        .setFooter({ text: "Selection expires in 2 minutes" })
+        .setTimestamp();
+    const rows = [
+        new ActionRowBuilder().addComponents(new StringSelectMenuBuilder().setCustomId(customId).setPlaceholder("Choose a model").addOptions(options)),
+    ];
+    const prevId = `model:${params.messageId}:${Date.now()}:prev`;
+    const nextId = `model:${params.messageId}:${Date.now()}:next`;
+    const closeId = `model:${params.messageId}:${Date.now()}:close`;
+    if (pageCount > 1) {
+        rows.push(new ActionRowBuilder().addComponents(new ButtonBuilder().setCustomId(prevId).setLabel("Prev").setStyle(ButtonStyle.Secondary).setDisabled(safePage === 0), new ButtonBuilder().setCustomId(`model:${params.messageId}:${Date.now()}:page`).setLabel(`Page ${safePage + 1}/${pageCount}`).setStyle(ButtonStyle.Secondary).setDisabled(true), new ButtonBuilder().setCustomId(nextId).setLabel("Next").setStyle(ButtonStyle.Secondary).setDisabled(safePage >= pageCount - 1), new ButtonBuilder().setCustomId(closeId).setLabel("Done").setStyle(ButtonStyle.Success)));
+    }
+    return { embed, rows, ids: { customId, prevId, nextId, closeId }, pageCount };
+}
+export function buildScopedModelSelectionCard(params) {
+    const page = params.page ?? 0;
+    const pageSize = 25;
+    const pageCount = Math.max(1, Math.ceil(params.models.length / pageSize));
+    const safePage = Math.min(Math.max(page, 0), pageCount - 1);
+    const start = safePage * pageSize;
+    const pageModels = params.models.slice(start, start + pageSize);
+    const customId = `scoped:${params.messageId}:${Date.now()}:select`;
+    const options = pageModels.map((value) => ({ label: value.slice(0, 100), value, default: params.currentModels.includes(value) }));
+    const embed = new EmbedBuilder()
+        .setTitle("🎯 Scoped models")
+        .setDescription([
+        params.currentModels.length > 0
+            ? `> **Current scope**\n${params.currentModels.map((model) => `> • \`${model}\``).join("\n")}`
+            : "> **Current scope**\n> All available models",
+        pageCount > 1 ? `📄 Page **${safePage + 1}** of **${pageCount}** · ${params.models.length} models available` : `${params.models.length} models available`,
+        "Select zero or more models, or browse with **Prev / Next**.",
+    ].join("\n\n"))
+        .setColor(0x57F287)
+        .setFooter({ text: "Selection expires in 2 minutes" })
+        .setTimestamp();
+    const rows = [
+        new ActionRowBuilder().addComponents(new StringSelectMenuBuilder().setCustomId(customId).setPlaceholder("Select scoped models").setMinValues(0).setMaxValues(options.length).addOptions(options)),
+    ];
+    const prevId = `scoped:${params.messageId}:${Date.now()}:prev`;
+    const nextId = `scoped:${params.messageId}:${Date.now()}:next`;
+    const closeId = `scoped:${params.messageId}:${Date.now()}:close`;
+    if (pageCount > 1) {
+        rows.push(new ActionRowBuilder().addComponents(new ButtonBuilder().setCustomId(prevId).setLabel("Prev").setStyle(ButtonStyle.Secondary).setDisabled(safePage === 0), new ButtonBuilder().setCustomId(`scoped:${params.messageId}:${Date.now()}:page`).setLabel(`Page ${safePage + 1}/${pageCount}`).setStyle(ButtonStyle.Secondary).setDisabled(true), new ButtonBuilder().setCustomId(nextId).setLabel("Next").setStyle(ButtonStyle.Secondary).setDisabled(safePage >= pageCount - 1), new ButtonBuilder().setCustomId(closeId).setLabel("Done").setStyle(ButtonStyle.Success)));
+    }
+    return { embed, rows, ids: { customId, prevId, nextId, closeId }, pageCount };
+}
+export function buildSessionCard(params) {
+    const embed = new EmbedBuilder().setTitle(params.title);
+    for (const field of params.fields)
+        embed.addFields({ name: field.name, value: field.value.slice(0, 1024), inline: field.inline ?? false });
+    return embed;
+}
+export function buildTreeSelectionCard(params) {
+    const page = params.page ?? 0;
+    const pageSize = 20;
+    const pageCount = Math.max(1, Math.ceil(params.entries.length / pageSize));
+    const safePage = Math.min(Math.max(page, 0), pageCount - 1);
+    const start = safePage * pageSize;
+    const pageEntries = params.entries.slice(start, start + pageSize);
+    const customId = `tree:${params.messageId}:${Date.now()}:select`;
+    const options = pageEntries.map((entry) => ({
+        label: `${entry.isCurrent ? "● " : ""}${"· ".repeat(Math.min(entry.depth, 3))}${entry.preview}`.slice(0, 100),
+        description: `${entry.type} · ${entry.id}${entry.label ? ` · ${entry.label}` : ""}`.slice(0, 100),
+        value: entry.id,
+        default: entry.isCurrent,
+    }));
+    const descriptionLines = [params.description];
+    if (pageEntries.length > 0) {
+        descriptionLines.push("", ...pageEntries.map((entry, index) => {
+            const prefix = entry.isCurrent ? "**● Current**" : `**${start + index + 1}.**`;
+            const indent = "› ".repeat(Math.min(entry.depth, 4));
+            return `${prefix} ${indent}\`${entry.id}\`\n${truncate(entry.preview, 140)}${entry.label ? `\n_Label:_ ${entry.label}` : ""}`;
+        }));
+    }
+    const embed = new EmbedBuilder()
+        .setTitle(`🌳 ${params.title}`)
+        .setDescription(descriptionLines.join("\n").slice(0, 4096))
+        .setColor(0xFEE75C)
+        .setFooter({ text: `Page ${safePage + 1}/${pageCount} · Selection expires in 2 minutes` })
+        .setTimestamp();
+    const rows = [];
+    if (options.length > 0) {
+        rows.push(new ActionRowBuilder().addComponents(new StringSelectMenuBuilder().setCustomId(customId).setPlaceholder("Select an entry to navigate to").addOptions(options)));
+    }
+    const prevId = `tree:${params.messageId}:${Date.now()}:prev`;
+    const nextId = `tree:${params.messageId}:${Date.now()}:next`;
+    const closeId = `tree:${params.messageId}:${Date.now()}:close`;
+    rows.push(new ActionRowBuilder().addComponents(new ButtonBuilder().setCustomId(prevId).setLabel("Prev").setStyle(ButtonStyle.Secondary).setDisabled(safePage === 0), new ButtonBuilder().setCustomId(`tree:${params.messageId}:${Date.now()}:page`).setLabel(`Page ${safePage + 1}/${pageCount}`).setStyle(ButtonStyle.Secondary).setDisabled(true), new ButtonBuilder().setCustomId(nextId).setLabel("Next").setStyle(ButtonStyle.Secondary).setDisabled(safePage >= pageCount - 1), new ButtonBuilder().setCustomId(closeId).setLabel("Done").setStyle(ButtonStyle.Success)));
+    return { embed, rows, options, ids: { customId, prevId, nextId, closeId } };
+}
+export function buildSettingsCard(summary, baseId) {
+    const embed = new EmbedBuilder()
+        .setTitle("Settings")
+        .setDescription("Use the buttons below to update Pi settings for this Discord harness.")
+        .addFields({ name: "Current", value: summary.slice(0, 1024) });
+    const row1 = new ActionRowBuilder().addComponents(new ButtonBuilder().setCustomId(`${baseId}:thinking`).setLabel("Cycle thinking").setStyle(ButtonStyle.Primary), new ButtonBuilder().setCustomId(`${baseId}:transport`).setLabel("Cycle transport").setStyle(ButtonStyle.Primary));
+    const row2 = new ActionRowBuilder().addComponents(new ButtonBuilder().setCustomId(`${baseId}:steering`).setLabel("Toggle steering").setStyle(ButtonStyle.Secondary), new ButtonBuilder().setCustomId(`${baseId}:followup`).setLabel("Toggle follow-up").setStyle(ButtonStyle.Secondary), new ButtonBuilder().setCustomId(`${baseId}:compact`).setLabel("Toggle auto compact").setStyle(ButtonStyle.Secondary));
+    const row3 = new ActionRowBuilder().addComponents(new ButtonBuilder().setCustomId(`${baseId}:done`).setLabel("Done").setStyle(ButtonStyle.Success));
+    return { embed, rows: [row1, row2, row3] };
+}
+export function buildApprovalCard(params) {
+    const embed = new EmbedBuilder()
+        .setTitle(params.title)
+        .setDescription(params.description);
+    if (params.bullets && params.bullets.length > 0) {
+        embed.addFields({ name: "Summary", value: params.bullets.map((bullet) => `• ${bullet}`).join("\n").slice(0, 1024) });
+    }
+    if (params.caution) {
+        embed.addFields({ name: "Caution", value: params.caution.slice(0, 1024) });
+    }
+    const row = new ActionRowBuilder().addComponents(new ButtonBuilder().setCustomId(params.approveId).setLabel(params.approveLabel ?? "Approve").setStyle(ButtonStyle.Success), new ButtonBuilder().setCustomId(params.rejectId).setLabel("Cancel").setStyle(ButtonStyle.Secondary));
+    return { embed, rows: [row] };
+}

package/dist/discord-ui.test.js

@@ -0,0 +1,37 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { buildApprovalCard, buildTreeSelectionCard, chunkText, formatWorkingText, truncate } from "./discord-ui.js";
+test("chunkText splits long text into safe chunks", () => {
+    const text = "a ".repeat(1500);
+    const chunks = chunkText(text, 100);
+    assert.ok(chunks.length > 1);
+    assert.ok(chunks.every((chunk) => chunk.length <= 100));
+});
+test("formatWorkingText and truncate are stable", () => {
+    assert.equal(formatWorkingText("hello", true), "hello\n\n...");
+    assert.equal(formatWorkingText("hello", false), "hello");
+    assert.equal(truncate("abcdef", 5), "ab...");
+});
+test("buildTreeSelectionCard creates options and rows", () => {
+    const card = buildTreeSelectionCard({
+        title: "Session tree",
+        description: "desc",
+        messageId: "123",
+        entries: [
+            { id: "a", depth: 0, type: "message", preview: "root", isCurrent: true },
+            { id: "b", depth: 1, type: "message", preview: "child", isCurrent: false },
+        ],
+    });
+    assert.equal(card.options.length, 2);
+    assert.equal(card.rows.length, 2);
+});
+test("buildApprovalCard includes action row", () => {
+    const card = buildApprovalCard({
+        title: "Approve",
+        description: "Do it?",
+        approveId: "yes",
+        rejectId: "no",
+        bullets: ["one"],
+    });
+    assert.equal(card.rows.length, 1);
+});

package/dist/discord.js

@@ -0,0 +1,389 @@
+import { Client, GatewayIntentBits, Partials, } from "discord.js";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { createDiscordContext } from "./discord-context.js";
+import { buildSlashEvent, handleButtonInteraction, handleSelectMenuInteraction, slashCommandToText, } from "./discord-interactions.js";
+import { buildSlashCommands, isAllowedDiscordMessage, loadDiscordPolicy } from "./discord-policy.js";
+import * as log from "./log.js";
+import { buildApprovalCard, buildModelSelectionCard, buildScopedModelSelectionCard, buildSessionCard, buildSettingsCard, buildTreeSelectionCard, } from "./discord-ui.js";
+import { clearPending, registerManyPending, registerPending, resolveOnTimeout } from "./discord-registry.js";
+class ChannelQueue {
+    queue = [];
+    processing = false;
+    enqueue(fn) {
+        this.queue.push(fn);
+        void this.processNext();
+    }
+    async processNext() {
+        if (this.processing || this.queue.length === 0)
+            return;
+        this.processing = true;
+        const fn = this.queue.shift();
+        try {
+            await fn();
+        }
+        catch (err) {
+            log.warn("queue error", err instanceof Error ? err.message : String(err));
+        }
+        this.processing = false;
+        await this.processNext();
+    }
+}
+export class DiscordBot {
+    handler;
+    store;
+    workingDir;
+    client;
+    queues = new Map();
+    botUserIdPromise;
+    pendingSlashInteractions = new Map();
+    pendingModelSelections = new Map();
+    pendingModelPages = new Map();
+    pendingScopedSelections = new Map();
+    pendingScopedPages = new Map();
+    pendingApprovals = new Map();
+    pendingSettingsActions = new Map();
+    pendingTreeSelections = new Map();
+    pendingTreePages = new Map();
+    constructor(token, handler, store, workingDir) {
+        this.handler = handler;
+        this.store = store;
+        this.workingDir = workingDir;
+        this.client = new Client({
+            intents: [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMessages, GatewayIntentBits.DirectMessages, GatewayIntentBits.MessageContent],
+            partials: [Partials.Channel],
+        });
+        this.botUserIdPromise = new Promise((resolve) => {
+            this.client.once("ready", () => resolve(this.client.user.id));
+        });
+        this.client.on("messageCreate", (message) => {
+            void this.onMessage(message);
+        });
+        this.client.on("interactionCreate", (interaction) => {
+            if (interaction.isChatInputCommand())
+                void this.onSlashCommand(interaction);
+            else if (interaction.isStringSelectMenu())
+                void this.onSelectMenu(interaction);
+            else if (interaction.isButton())
+                void this.onButton(interaction);
+        });
+        void this.client.login(token);
+    }
+    get policyPath() {
+        return join(this.workingDir, "discord-policy.json");
+    }
+    loadPolicy() {
+        return loadDiscordPolicy(this.policyPath);
+    }
+    get interactionState() {
+        return {
+            pendingSlashInteractions: this.pendingSlashInteractions,
+            pendingModelSelections: this.pendingModelSelections,
+            pendingModelPages: this.pendingModelPages,
+            pendingScopedSelections: this.pendingScopedSelections,
+            pendingScopedPages: this.pendingScopedPages,
+            pendingApprovals: this.pendingApprovals,
+            pendingSettingsActions: this.pendingSettingsActions,
+            pendingTreeSelections: this.pendingTreeSelections,
+            pendingTreePages: this.pendingTreePages,
+        };
+    }
+    queueFor(key) {
+        let queue = this.queues.get(key);
+        if (!queue) {
+            queue = new ChannelQueue();
+            this.queues.set(key, queue);
+        }
+        return queue;
+    }
+    async start() {
+        await this.botUserIdPromise;
+        log.info(`connected to Discord as ${this.client.user?.tag ?? this.client.user?.id}`);
+        await this.registerSlashCommands();
+        await this.backfillKnownConversations();
+    }
+    async registerSlashCommands() {
+        const policy = this.loadPolicy();
+        if (policy.slashCommands?.enabled === false)
+            return;
+        if (!this.client.application)
+            return;
+        const commands = buildSlashCommands();
+        const guildId = policy.slashCommands?.guildId;
+        if (guildId) {
+            await this.client.application.commands.set(commands, guildId);
+            log.info(`registered slash commands in guild ${guildId}`);
+        }
+        else {
+            await this.client.application.commands.set(commands);
+            log.info("registered global slash commands");
+        }
+    }
+    async onMessage(message) {
+        if (message.author.bot)
+            return;
+        const botUserId = await this.botUserIdPromise;
+        const gate = isAllowedDiscordMessage(message, botUserId, this.loadPolicy());
+        if (!gate.allowed) {
+            log.info(`skipping message ${message.id}: ${gate.reason}`);
+            return;
+        }
+        const conversationKey = this.getConversationKey(message);
+        const isDm = message.channel.type === 1;
+        const cleanedText = isDm ? message.content.trim() : message.content.replace(new RegExp(`<@!?${botUserId}>`, "g"), "").trim();
+        if (cleanedText.toLowerCase() === "stop") {
+            if (this.handler.isRunning(conversationKey))
+                await this.handler.handleStop(conversationKey, this);
+            else
+                await this.postMessage(message.channel, "Nothing running.");
+            return;
+        }
+        const attachments = await this.store.storeAttachments(conversationKey, message.attachments.values());
+        this.store.appendLog(conversationKey, {
+            date: new Date(message.createdTimestamp).toISOString(),
+            messageId: message.id,
+            channelId: message.channel.id,
+            guildId: message.guildId ?? undefined,
+            threadId: message.channel.isThread() ? message.channel.id : undefined,
+            authorId: message.author.id,
+            authorName: message.author.username,
+            text: cleanedText,
+            attachments,
+            isBot: false,
+        });
+        const event = {
+            type: isDm ? "dm" : "mention",
+            source: "message",
+            channelId: message.channel.id,
+            guildId: message.guildId ?? undefined,
+            threadId: message.channel.isThread() ? message.channel.id : undefined,
+            messageId: message.id,
+            userId: message.author.id,
+            userName: message.author.username,
+            text: cleanedText,
+            attachments: attachments,
+        };
+        this.queueFor(conversationKey).enqueue(() => this.handler.handleEvent(event, this));
+    }
+    async onSelectMenu(interaction) {
+        await handleSelectMenuInteraction(interaction, this.interactionState);
+    }
+    async onButton(interaction) {
+        await handleButtonInteraction(interaction, this.interactionState);
+    }
+    async onSlashCommand(interaction) {
+        const conversationKey = this.getConversationKeyFromIds(interaction.guildId ?? undefined, interaction.channelId, interaction.channel?.isThread() ? interaction.channel.id : undefined, interaction.user.id);
+        if (interaction.commandName === "stop") {
+            await interaction.reply({ content: "Stopping current run if there is one...", ephemeral: true });
+            await this.handler.handleStop(conversationKey, this);
+            return;
+        }
+        const text = slashCommandToText(interaction);
+        if (!text)
+            return;
+        log.info(`slash command ${interaction.commandName} from ${interaction.user.username} in ${conversationKey}`);
+        await interaction.deferReply();
+        this.pendingSlashInteractions.set(interaction.id, interaction);
+        const event = buildSlashEvent(interaction, text);
+        const key = this.getConversationKeyFromIds(event.guildId, event.channelId, event.threadId, event.userId);
+        this.queueFor(key).enqueue(() => this.handler.handleEvent(event, this));
+    }
+    getConversationKey(message) {
+        return this.getConversationKeyFromIds(message.guildId ?? undefined, message.channel.id, message.channel.isThread() ? message.channel.id : undefined, message.author.id);
+    }
+    getConversationKeyFromIds(guildId, channelId, threadId, userId) {
+        if (threadId && guildId)
+            return `guild:${guildId}:thread:${threadId}`;
+        if (guildId)
+            return `guild:${guildId}:channel:${channelId}`;
+        return `dm:${userId}`;
+    }
+    async getEventTarget(event) {
+        const channel = await this.client.channels.fetch(event.channelId);
+        if (!channel?.isTextBased())
+            throw new Error(`Channel ${event.channelId} is not text-based`);
+        const slashInteraction = event.source === "slash" ? this.pendingSlashInteractions.get(event.messageId) ?? null : null;
+        return { channel, sendable: channel, slashInteraction };
+    }
+    async promptModelSelection(event, params) {
+        const { sendable, slashInteraction } = await this.getEventTarget(event);
+        const card = buildModelSelectionCard({ ...params, messageId: event.messageId });
+        if (slashInteraction)
+            await slashInteraction.editReply({ content: "", embeds: [card.embed], components: card.rows });
+        else
+            await sendable.send({ embeds: [card.embed], components: card.rows });
+        log.info(`opened model selector for ${event.userName}`);
+        return await new Promise((resolve) => {
+            registerPending({ registry: this.pendingModelSelections, key: card.ids.customId, userId: event.userId, resolve: (value) => resolve(value) });
+            if (card.pageCount > 1) {
+                registerManyPending({ registry: this.pendingModelPages, keys: [card.ids.prevId, card.ids.nextId, card.ids.closeId], userId: event.userId, resolve: (value) => resolve(value) });
+            }
+            resolveOnTimeout({ run: () => {
+                    log.info(`model selector timed out for ${event.userName}`);
+                    clearPending(this.pendingModelSelections, [card.ids.customId]);
+                    clearPending(this.pendingModelPages, [card.ids.prevId, card.ids.nextId, card.ids.closeId]);
+                    resolve(null);
+                    return true;
+                } });
+        });
+    }
+    async promptScopedModelSelection(event, params) {
+        const { sendable, slashInteraction } = await this.getEventTarget(event);
+        const card = buildScopedModelSelectionCard({ ...params, messageId: event.messageId });
+        if (slashInteraction)
+            await slashInteraction.editReply({ content: "", embeds: [card.embed], components: card.rows });
+        else
+            await sendable.send({ embeds: [card.embed], components: card.rows });
+        return await new Promise((resolve) => {
+            registerPending({ registry: this.pendingScopedSelections, key: card.ids.customId, userId: event.userId, resolve: (value) => resolve(value) });
+            if (card.pageCount > 1) {
+                registerManyPending({ registry: this.pendingScopedPages, keys: [card.ids.prevId, card.ids.nextId, card.ids.closeId], userId: event.userId, resolve: (value) => resolve(value) });
+            }
+            resolveOnTimeout({ run: () => {
+                    clearPending(this.pendingScopedSelections, [card.ids.customId]);
+                    clearPending(this.pendingScopedPages, [card.ids.prevId, card.ids.nextId, card.ids.closeId]);
+                    resolve(null);
+                    return true;
+                } });
+        });
+    }
+    async showSessionCard(event, params) {
+        const { sendable, slashInteraction } = await this.getEventTarget(event);
+        const embed = buildSessionCard(params);
+        if (slashInteraction)
+            await slashInteraction.editReply({ content: "", embeds: [embed], components: [] });
+        else
+            await sendable.send({ embeds: [embed] });
+    }
+    async promptTreeSelection(event, params) {
+        const { sendable, slashInteraction } = await this.getEventTarget(event);
+        const card = buildTreeSelectionCard({ ...params, messageId: event.messageId });
+        if (slashInteraction)
+            await slashInteraction.editReply({ content: "", embeds: [card.embed], components: card.rows });
+        else
+            await sendable.send({ embeds: [card.embed], components: card.rows });
+        log.info(`opened tree browser for ${event.userName}`);
+        return await new Promise((resolve) => {
+            if (card.options.length > 0)
+                registerPending({ registry: this.pendingTreeSelections, key: card.ids.customId, userId: event.userId, resolve: (value) => resolve(value) });
+            registerManyPending({ registry: this.pendingTreePages, keys: [card.ids.prevId, card.ids.nextId, card.ids.closeId], userId: event.userId, resolve: (value) => resolve(value) });
+            resolveOnTimeout({ run: () => {
+                    log.info(`tree browser timed out for ${event.userName}`);
+                    if (card.options.length > 0)
+                        clearPending(this.pendingTreeSelections, [card.ids.customId]);
+                    clearPending(this.pendingTreePages, [card.ids.prevId, card.ids.nextId, card.ids.closeId]);
+                    resolve(null);
+                    return true;
+                } });
+        });
+    }
+    async promptSettingsCard(event, summary) {
+        const { sendable, slashInteraction } = await this.getEventTarget(event);
+        const baseId = `settings:${event.messageId}:${Date.now()}`;
+        const card = buildSettingsCard(summary, baseId);
+        if (slashInteraction)
+            await slashInteraction.editReply({ content: "", embeds: [card.embed], components: card.rows });
+        else
+            await sendable.send({ embeds: [card.embed], components: card.rows });
+        return await new Promise((resolve) => {
+            const keys = ["thinking", "transport", "steering", "followup", "compact", "done"].map((suffix) => `${baseId}:${suffix}`);
+            registerManyPending({ registry: this.pendingSettingsActions, keys, userId: event.userId, resolve });
+            resolveOnTimeout({ run: () => {
+                    if (clearPending(this.pendingSettingsActions, keys))
+                        resolve(null);
+                    return true;
+                } });
+        });
+    }
+    async requestApproval(event, params) {
+        const { sendable, slashInteraction } = await this.getEventTarget(event);
+        const baseId = `approve:${event.messageId}:${Date.now()}`;
+        const approveId = `${baseId}:approve`;
+        const rejectId = `${baseId}:reject`;
+        const card = buildApprovalCard({ ...params, approveId, rejectId });
+        if (slashInteraction)
+            await slashInteraction.editReply({ content: "", embeds: [card.embed], components: card.rows });
+        else
+            await sendable.send({ embeds: [card.embed], components: card.rows });
+        log.info(`opened approval card for ${event.userName}: ${params.title}`);
+        return await new Promise((resolve) => {
+            registerManyPending({ registry: this.pendingApprovals, keys: [approveId, rejectId], userId: event.userId, resolve });
+            resolveOnTimeout({ run: () => {
+                    if (clearPending(this.pendingApprovals, [approveId, rejectId]))
+                        resolve(false);
+                    return true;
+                } });
+        });
+    }
+    async createContext(event) {
+        return createDiscordContext({
+            client: this.client,
+            store: this.store,
+            event,
+            pendingSlashInteractions: this.pendingSlashInteractions,
+            getConversationKeyFromIds: (guildId, channelId, threadId, userId) => this.getConversationKeyFromIds(guildId, channelId, threadId, userId),
+            requestApproval: (approvalEvent, approvalParams) => this.requestApproval(approvalEvent, approvalParams),
+        });
+    }
+    async postMessage(channel, text) {
+        const resolved = typeof channel === "string" ? await this.client.channels.fetch(channel) : channel;
+        if (!resolved?.isTextBased())
+            throw new Error("Channel is not text-based");
+        const msg = await resolved.send(text);
+        return msg.id;
+    }
+    async backfillKnownConversations() {
+        const entries = readdirSync(this.workingDir, { withFileTypes: true }).filter((entry) => entry.isDirectory());
+        for (const entry of entries) {
+            const key = entry.name;
+            const logPath = join(this.workingDir, key, "log.jsonl");
+            if (!existsSync(logPath))
+                continue;
+            const lines = readFileSync(logPath, "utf-8").split("\n").filter(Boolean);
+            if (lines.length === 0)
+                continue;
+            let last = null;
+            for (let i = lines.length - 1; i >= 0; i--) {
+                try {
+                    const parsed = JSON.parse(lines[i]);
+                    if (parsed.channelId && parsed.messageId) {
+                        last = parsed;
+                        break;
+                    }
+                }
+                catch { }
+            }
+            if (!last?.channelId)
+                continue;
+            try {
+                const channel = await this.client.channels.fetch(last.channelId);
+                if (!channel?.isTextBased())
+                    continue;
+                const messages = await channel.messages.fetch({ limit: 100, after: last.messageId });
+                const sorted = [...messages.values()].sort((a, b) => a.createdTimestamp - b.createdTimestamp);
+                for (const message of sorted) {
+                    if (!message.author)
+                        continue;
+                    const attachments = message.author.bot ? [] : await this.store.storeAttachments(key, message.attachments.values());
+                    this.store.appendLog(key, {
+                        date: new Date(message.createdTimestamp).toISOString(),
+                        messageId: message.id,
+                        channelId: message.channel.id,
+                        guildId: message.guildId ?? undefined,
+                        threadId: message.channel.isThread() ? message.channel.id : undefined,
+                        authorId: message.author.id,
+                        authorName: message.author.username,
+                        text: message.author.bot ? message.content : message.content.trim(),
+                        attachments,
+                        isBot: message.author.bot,
+                    });
+                }
+                if (sorted.length > 0)
+                    log.info(`backfilled ${sorted.length} messages for ${key}`);
+            }
+            catch (err) {
+                log.warn(`backfill failed for ${key}`, err instanceof Error ? err.message : String(err));
+            }
+        }
+    }
+}

package/dist/log.js

@@ -0,0 +1,9 @@
+export function info(message) {
+    console.log(`[info] ${message}`);
+}
+export function warn(message, error) {
+    console.warn(`[warn] ${message}${error ? `: ${error}` : ""}`);
+}
+export function error(message, err) {
+    console.error(`[error] ${message}`, err);
+}