@isaacriehm/cairn 0.1.0 → 0.1.4

package/dist/frontend/discord/index.js

@@ -1,1104 +0,0 @@
-import { ActionRowBuilder, ButtonBuilder, ButtonStyle, Client, EmbedBuilder, Events, GatewayIntentBits, Partials, } from "discord.js";
-import { randomBytes } from "node:crypto";
-import { logger } from "../../logger.js";
-import { writeInboxRow } from "../inbox.js";
-import { classifyTier0 } from "../../tier0/index.js";
-import { transcribeUrl, whisperModelExists } from "../../voice/index.js";
-import { isOwner, parseOwnerIds } from "./acl.js";
-import { CATEGORY_NAMES, createTaskChannel, ensureCategories, moveChannelToCategory, slugifyForChannel, } from "./channels.js";
-import { registerSlashCommands, SLASH_COMMAND_NAMES } from "./slash.js";
-const log = logger("frontend.discord");
-const VOICE_MIME_PREFIXES = ["audio/", "video/ogg"];
-/**
- * Real Discord adapter. Implements `FrontendAdapter`. Phase 5 wires:
- *   - slash command surface per `WORKFLOW_GUIDE.md` §3
- *   - channel-per-task lifecycle in 📋/🟢/📦 categories
- *   - ACL on `DISCORD_OWNER_USER_IDS`
- *   - free-text → regex Tier-0 stub (real Ollama in Phase 6)
- *   - voice attachments → inbox row only (Whisper transcription Phase 6)
- *   - button interactions for approval / dialog round-trips
- *
- * Inbox rows are the only output Phase 5 produces — the orchestrator (Phase
- * 8) is the consumer. No code dispatch lives here.
- */
-export class DiscordFrontendAdapter {
-    name = "discord";
-    opts;
-    ownerIds;
-    client;
-    confidenceFloor;
-    tier0Opts;
-    taskHandler;
-    voiceHandler;
-    slashHandler;
-    freeTextHandler;
-    interactionHandler;
-    pendingApprovals = new Map();
-    pendingDialogs = new Map();
-    /**
-     * §3.4 win 1 — bundleId → messageId for in-place dialog edit. When a
-     * follow-up DialogSpec arrives with `replaceBundleId` set, the adapter
-     * fetches that message and edits it (new prompt + new buttons) instead
-     * of posting a fresh one. Single edited message replaces the N+1
-     * scroll explosion.
-     */
-    dialogMessageIds = new Map();
-    /**
-     * In-memory map of taskId → live status messageId. The live status
-     * message is one embed per task that gets edited in place on each
-     * postTaskUpdate call (instead of spamming the channel with a new
-     * message per phase). Restart loses the mapping; a fresh run posts a
-     * new live status message.
-     */
-    liveStatusMessages = new Map();
-    /**
-     * Channels that have responded with Unknown Channel (Discord error
-     * 10003). Once flagged dead, subsequent postTaskUpdate / sendTyping
-     * / requestDialog calls bail without hitting Discord. This stops the
-     * 8s typing heartbeat from spamming logs after the operator deletes
-     * a per-task channel mid-run.
-     */
-    deadChannels = new Set();
-    started = false;
-    constructor(opts) {
-        this.opts = opts;
-        this.confidenceFloor = opts.confidenceFloor ?? 0.85;
-        this.tier0Opts = opts.tier0 ?? {};
-        this.ownerIds = parseOwnerIds(opts.ownerUserIdsEnv);
-        if (this.ownerIds.size === 0) {
-            log.warn("DISCORD_OWNER_USER_IDS empty — no commands will be accepted; configure before live use");
-        }
-        this.client = new Client({
-            intents: [
-                GatewayIntentBits.Guilds,
-                GatewayIntentBits.GuildMessages,
-                GatewayIntentBits.MessageContent,
-                GatewayIntentBits.GuildMessageReactions,
-                GatewayIntentBits.DirectMessages,
-                GatewayIntentBits.DirectMessageReactions,
-            ],
-            partials: [Partials.Channel, Partials.Message, Partials.Reaction],
-        });
-    }
-    async start() {
-        if (this.started)
-            return;
-        this.client.on(Events.InteractionCreate, (i) => {
-            void this.handleInteraction(i);
-        });
-        this.client.on(Events.MessageCreate, (m) => {
-            void this.handleMessage(m);
-        });
-        this.client.once(Events.ClientReady, (c) => {
-            log.info({ user: c.user.tag, guildId: this.opts.guildId }, "discord client ready");
-        });
-        await this.client.login(this.opts.token);
-        if (!this.opts.skipSlashRegistration) {
-            const appId = this.opts.applicationId ?? this.client.application?.id;
-            if (!appId) {
-                await this.client.destroy();
-                throw new Error("could not resolve application id for slash registration");
-            }
-            const registered = await registerSlashCommands({
-                token: this.opts.token,
-                appId,
-                guildId: this.opts.guildId,
-            });
-            log.info({ count: registered.length }, "slash commands registered");
-        }
-        const guild = await this.requireGuild();
-        await ensureCategories(guild);
-        log.info({ categories: Object.values(CATEGORY_NAMES) }, "categories ensured");
-        this.started = true;
-    }
-    async stop() {
-        if (!this.started)
-            return;
-        for (const pending of this.pendingApprovals.values()) {
-            clearTimeout(pending.timeoutHandle);
-            pending.resolve({
-                bundleId: pending.bundleId,
-                decision: "ask",
-                timedOut: true,
-                reason: "adapter stopped",
-            });
-        }
-        this.pendingApprovals.clear();
-        for (const pending of this.pendingDialogs.values()) {
-            clearTimeout(pending.timeoutHandle);
-            pending.resolve({
-                bundleId: pending.bundleId,
-                choiceId: "e_other",
-                timedOut: true,
-                freeText: "(adapter stopped before reply)",
-            });
-        }
-        this.pendingDialogs.clear();
-        this.dialogMessageIds.clear();
-        await this.client.destroy();
-        this.started = false;
-        log.info("discord adapter stopped");
-    }
-    onTask(handler) {
-        this.taskHandler = handler;
-    }
-    onVoice(handler) {
-        this.voiceHandler = handler;
-    }
-    onSlash(handler) {
-        this.slashHandler = handler;
-    }
-    onFreeText(handler) {
-        this.freeTextHandler = handler;
-    }
-    onInteraction(handler) {
-        this.interactionHandler = handler;
-    }
-    async postTaskUpdate(update) {
-        const channelId = update.channelId;
-        if (!channelId) {
-            log.warn({ taskId: update.taskId }, "postTaskUpdate without channelId; dropping");
-            return;
-        }
-        if (this.isChannelDead(channelId))
-            return;
-        let channel;
-        try {
-            channel = await this.client.channels.fetch(channelId);
-        }
-        catch (err) {
-            if (isUnknownChannelError(err)) {
-                this.markChannelDead(channelId);
-                return;
-            }
-            throw err;
-        }
-        if (!channel || !channel.isTextBased() || !("send" in channel)) {
-            log.warn({ channelId }, "postTaskUpdate target channel not text-based");
-            return;
-        }
-        const text = channel;
-        const embed = buildPhaseEmbed(update);
-        // §3.3 win 3 — single edited live-status embed; no secondary content
-        // post. body / activity / tools / recentEvents all render inside this
-        // one embed via fields. Long bodies are truncated to 1024 chars + a
-        // pointer to log.jsonl (operator can grep the full content there).
-        const existingMsgId = this.liveStatusMessages.get(update.taskId);
-        if (existingMsgId !== undefined) {
-            try {
-                const msg = await text.messages.fetch(existingMsgId);
-                await msg.edit({ embeds: [embed] });
-                return;
-            }
-            catch (err) {
-                log.warn({ err: String(err), taskId: update.taskId }, "live status edit failed; recreating");
-                this.liveStatusMessages.delete(update.taskId);
-            }
-        }
-        try {
-            const sent = await text.send({ embeds: [embed] });
-            this.liveStatusMessages.set(update.taskId, sent.id);
-        }
-        catch (err) {
-            log.warn({ err: String(err), taskId: update.taskId }, "live status send failed");
-        }
-    }
-    async requestApproval(bundle) {
-        const channelId = bundle.channelId;
-        if (!channelId) {
-            throw new Error("requestApproval requires bundle.channelId");
-        }
-        if (this.isChannelDead(channelId)) {
-            // Same dead-channel sentinel as requestDialog — orchestrator
-            // treats timeout as ask/abandon.
-            return { bundleId: bundle.bundleId, decision: "ask", timedOut: true };
-        }
-        let channel;
-        try {
-            channel = await this.client.channels.fetch(channelId);
-        }
-        catch (err) {
-            if (isUnknownChannelError(err)) {
-                this.markChannelDead(channelId);
-                return { bundleId: bundle.bundleId, decision: "ask", timedOut: true };
-            }
-            throw err;
-        }
-        if (!channel || !("send" in channel) || !channel.isTextBased()) {
-            throw new Error(`approval target channel not text-based: ${channelId}`);
-        }
-        const buttonIds = {
-            approve: `harness:approve:${bundle.bundleId}`,
-            reject: `harness:reject:${bundle.bundleId}`,
-            ask: `harness:ask:${bundle.bundleId}`,
-        };
-        const row = new ActionRowBuilder().addComponents(new ButtonBuilder()
-            .setCustomId(buttonIds.approve)
-            .setStyle(ButtonStyle.Success)
-            .setLabel("Approve & Push")
-            .setEmoji("🟢"), new ButtonBuilder()
-            .setCustomId(buttonIds.reject)
-            .setStyle(ButtonStyle.Danger)
-            .setLabel("Reject + tell me why")
-            .setEmoji("🔴"), new ButtonBuilder()
-            .setCustomId(buttonIds.ask)
-            .setStyle(ButtonStyle.Secondary)
-            .setLabel("Ask follow-up")
-            .setEmoji("❓"));
-        const embed = new EmbedBuilder()
-            .setTitle(`🎬 UAT — ${bundle.runId}`)
-            .setColor(0x1abc9c)
-            .setDescription(bundle.goal)
-            .setTimestamp(new Date());
-        if (bundle.diffSummary) {
-            embed.addFields({ name: "diff", value: bundle.diffSummary.slice(0, 1024) });
-        }
-        if (bundle.acceptance && bundle.acceptance.length > 0) {
-            const acText = bundle.acceptance
-                .map((ac) => {
-                const mark = ac.status === "pass" ? "✓" : ac.status === "fail" ? "✗" : "○";
-                return `${mark} ${ac.id}${ac.note ? ` — ${ac.note}` : ""}`;
-            })
-                .join("\n");
-            embed.addFields({ name: "acceptance", value: acText.slice(0, 1024) });
-        }
-        const sentApproval = await channel.send({
-            embeds: [embed],
-            components: [row],
-        });
-        try {
-            await sentApproval.react("👀");
-        }
-        catch (err) {
-            log.warn({ err: String(err) }, "approval 👀 react failed");
-        }
-        const timeoutMs = bundle.timeoutMs ?? 24 * 60 * 60 * 1000;
-        return new Promise((resolve) => {
-            const timeoutHandle = setTimeout(() => {
-                this.pendingApprovals.delete(bundle.bundleId);
-                resolve({ bundleId: bundle.bundleId, decision: "ask", timedOut: true });
-            }, timeoutMs);
-            this.pendingApprovals.set(bundle.bundleId, {
-                bundleId: bundle.bundleId,
-                resolve,
-                timeoutHandle,
-            });
-        });
-    }
-    async requestDialog(spec) {
-        const channelId = spec.channelId;
-        if (!channelId) {
-            throw new Error("requestDialog requires spec.channelId");
-        }
-        if (this.isChannelDead(channelId)) {
-            // Operator can't see the prompt — return a dead-channel sentinel
-            // (timed-out so the orchestrator's existing timeout-handling
-            // branch fires).
-            return { bundleId: spec.bundleId, choiceId: "e_other", timedOut: true };
-        }
-        let channel;
-        try {
-            channel = await this.client.channels.fetch(channelId);
-        }
-        catch (err) {
-            if (isUnknownChannelError(err)) {
-                this.markChannelDead(channelId);
-                return { bundleId: spec.bundleId, choiceId: "e_other", timedOut: true };
-            }
-            throw err;
-        }
-        if (!channel || !("send" in channel) || !channel.isTextBased()) {
-            throw new Error(`dialog target channel not text-based: ${channelId}`);
-        }
-        const choiceMap = new Map();
-        const choiceLabels = new Map();
-        const builders = [];
-        for (const choice of spec.choices.slice(0, 5)) {
-            const buttonId = `harness:dialog:${spec.bundleId}:${choice.id}`;
-            choiceMap.set(buttonId, choice.id);
-            choiceLabels.set(choice.id, choice.label);
-            builders.push(new ButtonBuilder()
-                .setCustomId(buttonId)
-                .setStyle(ButtonStyle.Secondary)
-                .setLabel(choice.label.slice(0, 80)));
-        }
-        const row = new ActionRowBuilder().addComponents(...builders);
-        // Plain content has a 2000-char cap, but operator-walked dialogs
-        // can include 4 long ambiguity candidates that blow past it.
-        // Discord embeds get 4096 chars in the description, so longer
-        // prompts go there. Short prompts stay as content for the
-        // visually-cleaner default rendering.
-        const pingPrefix = spec.pingOperators === true && this.ownerIds.size > 0
-            ? Array.from(this.ownerIds)
-                .map((id) => `<@${id}>`)
-                .join(" ") + " "
-            : "";
-        const sendOpts = { components: [row] };
-        const useEmbed = spec.prompt.length > 1800;
-        if (useEmbed) {
-            sendOpts.embeds = [
-                new EmbedBuilder()
-                    .setDescription(spec.prompt.slice(0, 4096))
-                    .setColor(0x3498db),
-            ];
-            // Pings only render in `content`, not embed description, so
-            // when we use an embed for body, ping prefix lives on content.
-            if (pingPrefix.length > 0)
-                sendOpts.content = pingPrefix.trim();
-        }
-        else {
-            sendOpts.content = pingPrefix + spec.prompt;
-        }
-        // §3.4 win 1 — try to edit the previous walk step's message in place.
-        let messageId;
-        if (spec.replaceBundleId !== undefined) {
-            const prevMsgId = this.dialogMessageIds.get(spec.replaceBundleId);
-            if (prevMsgId !== undefined) {
-                try {
-                    const prevMsg = await channel.messages.fetch(prevMsgId);
-                    await prevMsg.edit({
-                        content: sendOpts.content ?? "",
-                        embeds: sendOpts.embeds ?? [],
-                        components: sendOpts.components,
-                    });
-                    messageId = prevMsg.id;
-                }
-                catch (err) {
-                    log.warn({ err: String(err), prev: spec.replaceBundleId }, "dialog edit-in-place failed; falling back to fresh send");
-                }
-            }
-        }
-        if (messageId === undefined) {
-            const sentMessage = await channel.send(sendOpts);
-            messageId = sentMessage.id;
-            try {
-                await sentMessage.react("👀");
-            }
-            catch (err) {
-                log.warn({ err: String(err), bundleId: spec.bundleId }, "dialog 👀 react failed");
-            }
-        }
-        this.dialogMessageIds.set(spec.bundleId, messageId);
-        if (spec.replaceBundleId !== undefined &&
-            spec.replaceBundleId !== spec.bundleId) {
-            this.dialogMessageIds.delete(spec.replaceBundleId);
-        }
-        const timeoutMs = spec.timeoutMs ?? 5 * 60 * 1000;
-        const compactOnAnswer = spec.compactOnAnswer !== false;
-        return new Promise((resolve) => {
-            const timeoutHandle = setTimeout(() => {
-                this.pendingDialogs.delete(spec.bundleId);
-                this.dialogMessageIds.delete(spec.bundleId);
-                resolve({ bundleId: spec.bundleId, choiceId: "e_other", timedOut: true });
-            }, timeoutMs);
-            this.pendingDialogs.set(spec.bundleId, {
-                bundleId: spec.bundleId,
-                resolve,
-                choiceMap,
-                choiceLabels,
-                timeoutHandle,
-                compactOnAnswer,
-            });
-        });
-    }
-    async isChannelAlive(channelId) {
-        if (this.isChannelDead(channelId))
-            return false;
-        try {
-            const ch = await this.client.channels.fetch(channelId);
-            return ch !== null;
-        }
-        catch (err) {
-            if (isUnknownChannelError(err)) {
-                this.markChannelDead(channelId);
-            }
-            return false;
-        }
-    }
-    startTyping(channelId) {
-        let stopped = false;
-        const ping = async () => {
-            if (stopped)
-                return;
-            if (this.isChannelDead(channelId)) {
-                stopped = true;
-                return;
-            }
-            try {
-                const channel = await this.client.channels.fetch(channelId);
-                if (channel && channel.isTextBased() && "sendTyping" in channel) {
-                    await channel.sendTyping();
-                }
-            }
-            catch (err) {
-                if (isUnknownChannelError(err)) {
-                    this.markChannelDead(channelId);
-                    stopped = true;
-                    return;
-                }
-                log.warn({ err: String(err), channelId }, "sendTyping failed");
-            }
-        };
-        void ping();
-        // Discord's typing indicator decays after ~10s; refresh every 8s.
-        const handle = setInterval(() => void ping(), 8_000);
-        return () => {
-            stopped = true;
-            clearInterval(handle);
-        };
-    }
-    async notify(level, message) {
-        log[level === "warn" ? "warn" : level === "error" ? "error" : "info"]({ message }, "frontend notify");
-        // No default channel for ad-hoc notifications. Discord-side surfacing
-        // belongs to per-run channels (postTaskUpdate). This is a logging
-        // fallback — Phase 5 has no system channel concept.
-    }
-    // ── private ────────────────────────────────────────────────────────────
-    /**
-     * Discord error 10003 = Unknown Channel. Operator deleted the
-     * per-task channel after the harness recorded its id. Once flagged,
-     * silently no-op on every subsequent send/edit/typing call so we
-     * don't spam logs while the orchestrator winds the run down.
-     */
-    isChannelDead(channelId) {
-        return this.deadChannels.has(channelId);
-    }
-    markChannelDead(channelId) {
-        if (!this.deadChannels.has(channelId)) {
-            this.deadChannels.add(channelId);
-            log.warn({ channelId }, "channel marked dead — operator likely deleted it; further posts/typing/dialogs will no-op");
-        }
-    }
-    async requireGuild() {
-        const guild = await this.client.guilds.fetch(this.opts.guildId);
-        if (!guild) {
-            throw new Error(`guild not accessible: ${this.opts.guildId}`);
-        }
-        return guild;
-    }
-    async handleInteraction(interaction) {
-        try {
-            if (interaction.isChatInputCommand()) {
-                await this.handleSlash(interaction);
-                return;
-            }
-            if (interaction.isButton()) {
-                await this.handleButton(interaction);
-                return;
-            }
-        }
-        catch (err) {
-            log.error({ err: String(err) }, "interaction handler threw");
-        }
-    }
-    async handleSlash(interaction) {
-        const command = interaction.commandName;
-        const userId = interaction.user.id;
-        if (!isOwner(this.ownerIds, userId)) {
-            await interaction.reply({
-                content: "Not authorized.",
-                ephemeral: true,
-            });
-            return;
-        }
-        if (!SLASH_COMMAND_NAMES.includes(command)) {
-            await interaction.reply({ content: `Unknown command: ${command}`, ephemeral: true });
-            return;
-        }
-        const options = {};
-        for (const opt of interaction.options.data) {
-            if (opt.value !== undefined && opt.value !== null)
-                options[opt.name] = opt.value;
-        }
-        const slashEvent = {
-            source: this.name,
-            command,
-            options,
-            authorId: userId,
-            receivedAt: new Date().toISOString(),
-            ...(interaction.channelId ? { channelId: interaction.channelId } : {}),
-            ...(interaction.guildId ? { guildId: interaction.guildId } : {}),
-            messageId: interaction.id,
-        };
-        if (command === "task") {
-            await this.handleTaskCommand(interaction, slashEvent);
-            return;
-        }
-        await writeInboxRow({
-            repoRoot: this.opts.repoRoot,
-            source: this.name,
-            kind: "slash",
-            payload: { slash: slashEvent },
-        });
-        if (this.slashHandler)
-            await this.slashHandler(slashEvent);
-        await interaction.reply({
-            content: `Queued \`/${command}\` (run-id pending).`,
-            ephemeral: true,
-        });
-    }
-    async handleTaskCommand(interaction, slashEvent) {
-        const body = typeof slashEvent.options["body"] === "string" ? slashEvent.options["body"] : "";
-        const taskId = newTaskId();
-        const bodySlug = slugifyForChannel(body);
-        let createdChannelId;
-        if (interaction.guild) {
-            try {
-                const categories = await ensureCategories(interaction.guild);
-                const channel = await createTaskChannel({
-                    guild: interaction.guild,
-                    category: categories.active,
-                    taskId,
-                    bodySlug,
-                });
-                createdChannelId = channel.id;
-                // §3.4 win — no standalone "🆕 Task" drop card. The orchestrator
-                // surfaces the body inside the live-status embed (PostUpdate.taskBody
-                // field) so the channel shows a single self-updating message per task
-                // instead of two.
-            }
-            catch (err) {
-                log.error({ err: String(err) }, "failed to create task channel");
-            }
-        }
-        const task = {
-            source: this.name,
-            intent: "code_task",
-            rawText: body,
-            authorId: slashEvent.authorId,
-            receivedAt: slashEvent.receivedAt,
-            ...(createdChannelId ? { channelId: createdChannelId } : {}),
-            ...(slashEvent.guildId ? { guildId: slashEvent.guildId } : {}),
-            messageId: slashEvent.messageId ?? "",
-        };
-        await writeInboxRow({
-            repoRoot: this.opts.repoRoot,
-            source: this.name,
-            kind: "task",
-            payload: { task, slash: slashEvent, task_id: taskId },
-        });
-        if (this.taskHandler)
-            await this.taskHandler(task);
-        const replyLines = [`📋 Task ${taskId} queued.`];
-        if (createdChannelId)
-            replyLines.push(`Channel: <#${createdChannelId}>`);
-        await interaction.reply({ content: replyLines.join("\n"), ephemeral: true });
-    }
-    async handleButton(interaction) {
-        const userId = interaction.user.id;
-        if (!isOwner(this.ownerIds, userId)) {
-            await interaction.reply({ content: "Not authorized.", ephemeral: true });
-            return;
-        }
-        const customId = interaction.customId;
-        const parts = customId.split(":");
-        const namespace = parts[0];
-        const kind = parts[1];
-        if (namespace !== "harness") {
-            await interaction.reply({ content: "Unknown button.", ephemeral: true });
-            return;
-        }
-        if (kind === "approve" || kind === "reject" || kind === "ask") {
-            const bundleId = parts.slice(2).join(":");
-            const pending = this.pendingApprovals.get(bundleId);
-            if (pending) {
-                clearTimeout(pending.timeoutHandle);
-                this.pendingApprovals.delete(bundleId);
-                pending.resolve({ bundleId, decision: kind });
-            }
-            const interactionEvent = {
-                source: this.name,
-                bundleId,
-                choiceId: kind,
-                authorId: userId,
-                receivedAt: new Date().toISOString(),
-                ...(interaction.channelId ? { channelId: interaction.channelId } : {}),
-                ...(interaction.guildId ? { guildId: interaction.guildId } : {}),
-                messageId: interaction.id,
-            };
-            await writeInboxRow({
-                repoRoot: this.opts.repoRoot,
-                source: this.name,
-                kind: "interaction",
-                payload: { interaction: interactionEvent },
-            });
-            if (this.interactionHandler)
-                await this.interactionHandler(interactionEvent);
-            await interaction.deferUpdate();
-            await this.ackReact(interaction, kind);
-            return;
-        }
-        if (kind === "voice-confirm") {
-            const transcriptId = parts[2] ?? "";
-            const choiceId = parts[3] ?? "";
-            const interactionEvent = {
-                source: this.name,
-                bundleId: transcriptId,
-                choiceId,
-                authorId: userId,
-                receivedAt: new Date().toISOString(),
-                ...(interaction.channelId ? { channelId: interaction.channelId } : {}),
-                ...(interaction.guildId ? { guildId: interaction.guildId } : {}),
-                messageId: interaction.id,
-            };
-            await writeInboxRow({
-                repoRoot: this.opts.repoRoot,
-                source: this.name,
-                kind: "interaction",
-                payload: { interaction: interactionEvent, voice_transcript_id: transcriptId },
-            });
-            if (this.interactionHandler)
-                await this.interactionHandler(interactionEvent);
-            await interaction.deferUpdate();
-            await this.ackReact(interaction, choiceId);
-            return;
-        }
-        if (kind === "dialog") {
-            // bundleId may contain colons (e.g. `TSK-XXX:Q1` from the
-            // tightener per-question walk), so the choiceId is always the
-            // LAST segment and bundleId is everything between `dialog:` and
-            // the last `:`.
-            const choiceId = parts[parts.length - 1] ?? "";
-            const bundleId = parts.slice(2, -1).join(":");
-            const pending = this.pendingDialogs.get(bundleId);
-            const compact = pending?.compactOnAnswer ?? true;
-            const choiceLabel = pending?.choiceLabels.get(choiceId) ?? choiceId.toUpperCase();
-            if (pending) {
-                clearTimeout(pending.timeoutHandle);
-                this.pendingDialogs.delete(bundleId);
-                // Don't drop the messageId here — the next walk step's
-                // requestDialog (with replaceBundleId=this) needs to fetch + edit
-                // it. The next requestDialog deletes the old entry once it
-                // claims the message.
-                pending.resolve({ bundleId, choiceId });
-            }
-            const interactionEvent = {
-                source: this.name,
-                bundleId,
-                choiceId,
-                authorId: userId,
-                receivedAt: new Date().toISOString(),
-                ...(interaction.channelId ? { channelId: interaction.channelId } : {}),
-                ...(interaction.guildId ? { guildId: interaction.guildId } : {}),
-                messageId: interaction.id,
-            };
-            await writeInboxRow({
-                repoRoot: this.opts.repoRoot,
-                source: this.name,
-                kind: "interaction",
-                payload: { interaction: interactionEvent },
-            });
-            if (this.interactionHandler)
-                await this.interactionHandler(interactionEvent);
-            // Walk steps (compactOnAnswer=false) defer to the next dialog's
-            // edit-in-place; touching the message here would race the next
-            // step and either drop its content or its buttons. Only terminal
-            // dialogs (confirm, UAT, ad-hoc operator question) compact.
-            if (compact) {
-                try {
-                    const original = interaction.message;
-                    const annotated = (original.content ?? "").trim() +
-                        `\n\n> **Answered:** ${choiceId.toUpperCase()} — ${choiceLabel}`;
-                    await interaction.update({
-                        content: annotated.slice(0, 2000),
-                        components: [],
-                    });
-                }
-                catch (err) {
-                    log.warn({ err: String(err), bundleId, choiceId }, "dialog message compact-update failed");
-                    try {
-                        await interaction.deferUpdate();
-                    }
-                    catch {
-                        /* noop */
-                    }
-                }
-            }
-            else {
-                try {
-                    await interaction.deferUpdate();
-                }
-                catch (err) {
-                    log.warn({ err: String(err), bundleId, choiceId }, "dialog deferUpdate failed");
-                }
-            }
-            await this.ackReact(interaction, choiceId);
-            return;
-        }
-        await interaction.deferUpdate();
-    }
-    /**
-     * Stamp the bot's processing on the message: success → ✅, decline →
-     * ❌, ask → ❓. Best-effort; reaction failures don't bubble.
-     */
-    async ackReact(interaction, decision) {
-        let emoji = "✅";
-        if (decision === "reject" ||
-            decision === "cancel" ||
-            decision === "no" ||
-            decision === "edit") {
-            emoji = "❌";
-        }
-        else if (decision === "ask" || decision === "ship_anyway") {
-            emoji = "⚡";
-        }
-        try {
-            await interaction.message.react(emoji);
-        }
-        catch (err) {
-            log.warn({ err: String(err), choice: decision }, "ackReact failed");
-        }
-    }
-    async handleMessage(message) {
-        if (message.author.bot)
-            return;
-        const userId = message.author.id;
-        if (!isOwner(this.ownerIds, userId))
-            return;
-        // Voice attachments take precedence — bypass text classification path.
-        const voiceAttachments = message.attachments.filter((a) => {
-            const mime = a.contentType ?? "";
-            return VOICE_MIME_PREFIXES.some((p) => mime.startsWith(p));
-        });
-        if (voiceAttachments.size > 0) {
-            for (const attachment of voiceAttachments.values()) {
-                await this.handleVoiceAttachment(message, userId, attachment);
-            }
-            return;
-        }
-        const text = message.content?.trim() ?? "";
-        if (text.length === 0)
-            return;
-        const classification = await classifyTier0(text, this.tier0Opts);
-        const event = {
-            source: this.name,
-            intent: classification.intent,
-            rawText: text,
-            authorId: userId,
-            receivedAt: new Date().toISOString(),
-            channelId: message.channelId,
-            messageId: message.id,
-            ...(message.guildId ? { guildId: message.guildId } : {}),
-        };
-        if (classification.intent === "code_task") {
-            const taskId = newTaskId();
-            const task = {
-                source: this.name,
-                intent: "code_task",
-                rawText: text,
-                authorId: userId,
-                receivedAt: event.receivedAt,
-                channelId: message.channelId,
-                messageId: message.id,
-                ...(message.guildId ? { guildId: message.guildId } : {}),
-            };
-            await writeInboxRow({
-                repoRoot: this.opts.repoRoot,
-                source: this.name,
-                kind: "task",
-                payload: { task, free_text: event, task_id: taskId, classification },
-            });
-            if (this.taskHandler)
-                await this.taskHandler(task);
-            try {
-                await message.react("📋");
-            }
-            catch {
-                // permission optional
-            }
-            return;
-        }
-        await writeInboxRow({
-            repoRoot: this.opts.repoRoot,
-            source: this.name,
-            kind: "free_text",
-            payload: { free_text: event, classification },
-        });
-        if (this.freeTextHandler)
-            await this.freeTextHandler(event);
-        try {
-            await message.react(classification.intent === "unknown" ? "❓" : "✅");
-        }
-        catch {
-            // optional
-        }
-    }
-    async handleVoiceAttachment(message, userId, attachment) {
-        const transcriptId = `VTX-${Date.now().toString(36)}-${randomBytes(2).toString("hex")}`;
-        let transcript = null;
-        let transcribeError = null;
-        if (!whisperModelExists()) {
-            transcribeError = "whisper model not installed (Phase 16 init or manual download)";
-        }
-        else {
-            try {
-                transcript = await transcribeUrl(attachment.url, { language: "en" });
-            }
-            catch (err) {
-                transcribeError = err instanceof Error ? err.message : String(err);
-            }
-        }
-        let classification = null;
-        if (transcript && transcript.text.length > 0) {
-            try {
-                classification = await classifyTier0(transcript.text, this.tier0Opts);
-            }
-            catch (err) {
-                log.warn({ err: String(err) }, "tier0 classify on transcript failed");
-            }
-        }
-        const voice = {
-            source: this.name,
-            attachmentUrl: attachment.url,
-            authorId: userId,
-            channelId: message.channelId,
-            messageId: message.id,
-            receivedAt: new Date().toISOString(),
-            ...(attachment.contentType ? { mime: attachment.contentType } : {}),
-            ...(message.guildId ? { guildId: message.guildId } : {}),
-        };
-        const belowFloor = transcript !== null && transcript.avgLogprob < this.confidenceFloor;
-        const transcriptPayload = transcript
-            ? {
-                id: transcriptId,
-                text: transcript.text,
-                avg_logprob: transcript.avgLogprob,
-                language: transcript.language,
-                duration_ms: transcript.durationMs,
-                segments: transcript.segments.length,
-                confidence_floor: this.confidenceFloor,
-                below_floor: belowFloor,
-            }
-            : null;
-        await writeInboxRow({
-            repoRoot: this.opts.repoRoot,
-            source: this.name,
-            kind: "voice",
-            payload: {
-                voice,
-                transcript: transcriptPayload,
-                transcribe_error: transcribeError,
-                classification,
-            },
-        });
-        if (this.voiceHandler)
-            await this.voiceHandler(voice);
-        if (transcribeError !== null) {
-            try {
-                await message.react("⚠️");
-            }
-            catch {
-                // optional
-            }
-            try {
-                await message.reply(`Transcription failed: \`${transcribeError.slice(0, 200)}\`. Inbox row dropped without transcript.`);
-            }
-            catch {
-                // optional
-            }
-            return;
-        }
-        if (transcript && belowFloor) {
-            try {
-                const row = new ActionRowBuilder().addComponents(new ButtonBuilder()
-                    .setCustomId(`harness:voice-confirm:${transcriptId}:yes`)
-                    .setStyle(ButtonStyle.Success)
-                    .setLabel("Confirm")
-                    .setEmoji("🟢"), new ButtonBuilder()
-                    .setCustomId(`harness:voice-confirm:${transcriptId}:no`)
-                    .setStyle(ButtonStyle.Danger)
-                    .setLabel("Re-record")
-                    .setEmoji("🔴"));
-                const pct = (transcript.avgLogprob * 100).toFixed(0);
-                const summary = transcript.text.length > 220
-                    ? `${transcript.text.slice(0, 217)}...`
-                    : transcript.text;
-                await message.reply({
-                    content: `Heard: "${summary}" (confidence ${pct}%) — confirm?`,
-                    components: [row],
-                });
-            }
-            catch (err) {
-                log.warn({ err: String(err) }, "voice confirm prompt failed");
-            }
-            return;
-        }
-        try {
-            await message.react("👂");
-        }
-        catch {
-            // optional
-        }
-    }
-}
-function newTaskId() {
-    return `TSK-${Date.now().toString(36)}-${randomBytes(2).toString("hex")}`;
-}
-/**
- * True when the error is a discord.js DiscordAPIError with code 10003
- * (Unknown Channel). The harness flags the channel dead and silently
- * no-ops every subsequent post against it.
- */
-function isUnknownChannelError(err) {
-    if (typeof err !== "object" || err === null)
-        return false;
-    const e = err;
-    return e["code"] === 10003;
-}
-/**
- * Map orchestrator phase names → embed colors. Mirrors the harness
- * pipeline: tighten → prep → run → sense → review → uat → done.
- *
- * `blocked` is cyan (waiting-on-operator), distinct from failure
- * orange — operator should read the color as "your move", not "broken".
- */
-const PHASE_COLOR = {
-    queued: 0x607d8b,
-    tightening: 0x3498db,
-    blocked: 0x4a90e2,
-    prepping: 0x95a5a6,
-    running: 0xf1c40f,
-    sensing: 0xe67e22,
-    reviewing: 0x9b59b6,
-    uat: 0x1abc9c,
-    backpropping: 0x6f42c1,
-    succeeded: 0x2ecc71,
-    failed: 0xe74c3c,
-};
-const PHASE_EMOJI = {
-    queued: "🟦",
-    tightening: "🪛",
-    blocked: "⏳",
-    prepping: "🧰",
-    running: "🟡",
-    sensing: "🔎",
-    reviewing: "🔬",
-    uat: "🧪",
-    backpropping: "📐",
-    succeeded: "🟢",
-    failed: "🔴",
-};
-const PHASE_LABEL = {
-    queued: "queued",
-    tightening: "tightening spec",
-    blocked: "awaiting you",
-    prepping: "prepping workspace",
-    running: "agent running",
-    sensing: "sensors sweeping",
-    reviewing: "reviewer checking",
-    uat: "UAT in flight",
-    backpropping: "backprop",
-    succeeded: "shipped",
-    failed: "failed",
-};
-/** §3.4 win 3 — class-specific failure color so operator routes per class. */
-const FAILURE_COLOR = {
-    sensor: 0xff8c00, // orange — mechanical / structural fail; usually fixable
-    reviewer: 0x9b59b6, // purple — inferential reject; needs spec or code thinking
-    uat: 0x3498db, // blue — operator rejected the bundle
-    hard: 0xff0000, // red — process / infra error
-    halt: 0x2c2c2c, // dark grey — operator pulled the cord
-};
-const FAILURE_EMOJI = {
-    sensor: "🟧",
-    reviewer: "🟪",
-    uat: "🟦",
-    hard: "🟥",
-    halt: "⚫",
-};
-function buildPhaseEmbed(update) {
-    const isFailure = update.status === "failed" && update.failureClass !== undefined;
-    const color = isFailure
-        ? FAILURE_COLOR[update.failureClass] ?? 0xff0000
-        : PHASE_COLOR[update.status] ?? 0x808080;
-    const emoji = isFailure
-        ? FAILURE_EMOJI[update.failureClass] ?? "🔴"
-        : PHASE_EMOJI[update.status] ?? "•";
-    const titleSuffix = isFailure ? ` — failed: ${update.failureClass}` : "";
-    const phaseLabel = PHASE_LABEL[update.status] ?? update.status;
-    const descLines = [`**${phaseLabel}**`];
-    if (update.taskBody !== undefined && update.taskBody.length > 0) {
-        descLines.push("");
-        const trimmed = update.taskBody.trim();
-        const truncated = trimmed.length > 1024
-            ? `${trimmed.slice(0, 1010)}…`
-            : trimmed;
-        // Quote-block so the spec stays visually distinct from status.
-        descLines.push(...truncated.split("\n").map((line) => `> ${line}`));
-    }
-    if (update.recentEvents !== undefined && update.recentEvents.length > 0) {
-        descLines.push("");
-        descLines.push("**recent**");
-        for (const ev of update.recentEvents)
-            descLines.push(ev);
-    }
-    const description = descLines.join("\n").slice(0, 4000);
-    const embed = new EmbedBuilder()
-        .setTitle(`${emoji} ${update.taskId}${titleSuffix}`)
-        .setColor(color)
-        .setDescription(description);
-    if (update.runId) {
-        embed.addFields({ name: "run", value: `\`${update.runId}\``, inline: true });
-    }
-    if (update.activity !== undefined && update.activity.length > 0) {
-        embed.addFields({
-            name: "activity",
-            value: update.activity.slice(0, 1024),
-            inline: false,
-        });
-    }
-    if (update.tools?.files !== undefined &&
-        update.tools.files.length > 0) {
-        embed.addFields({
-            name: "files",
-            value: capFieldValue(update.tools.files.map((f) => `\`${f}\``).join("\n")),
-            inline: false,
-        });
-    }
-    if (update.tools?.bash !== undefined && update.tools.bash.length > 0) {
-        embed.addFields({
-            name: "shell",
-            value: capFieldValue(update.tools.bash.map((c) => `\`${c}\``).join("\n")),
-            inline: false,
-        });
-    }
-    if (update.tools?.searches !== undefined &&
-        update.tools.searches.length > 0) {
-        embed.addFields({
-            name: "searches",
-            value: capFieldValue(update.tools.searches.map((s) => `\`${s}\``).join("\n")),
-            inline: false,
-        });
-    }
-    if (update.body !== undefined && update.body.length > 0) {
-        let value = update.body;
-        if (value.length > 1024) {
-            value = `${value.slice(0, 1010)}…\n_+${update.body.length - 1010} chars in log.jsonl_`;
-        }
-        embed.addFields({ name: "details", value, inline: false });
-    }
-    if (update.remediation !== undefined) {
-        const lines = [
-            `**reason:** ${update.remediation.reason.slice(0, 400)}`,
-        ];
-        if (update.remediation.suggestedActions.length > 0) {
-            lines.push("**next:**");
-            for (const a of update.remediation.suggestedActions.slice(0, 5)) {
-                lines.push(`• ${a}`);
-            }
-        }
-        embed.addFields({
-            name: "remediation",
-            value: capFieldValue(lines.join("\n")),
-            inline: false,
-        });
-    }
-    embed.setTimestamp(new Date());
-    return embed;
-}
-function capFieldValue(text) {
-    return text.length > 1024 ? `${text.slice(0, 1018)}\n…` : text;
-}
-// re-export utilities for callers (orchestrator, smoke)
-export { CATEGORY_NAMES, ensureCategories, moveChannelToCategory, slugifyForChannel, };
-//# sourceMappingURL=index.js.map