@openacp/cli 0.6.10 → 2026.326.3

package/dist/{discord-OMC52Y54.js → adapter-77ZCVABT.js}

@@ -1,29 +1,15 @@
-import {
-  buildActionKeyboard,
-  detectAction,
-  storeAction
-} from "./chunk-I7WC6E5S.js";
 import {
   handleNew,
   handleNewChat,
   handleNewSessionButton
-} from "./chunk-XANPHG7W.js";
-import {
-  handleDangerous,
-  handleDangerousButton,
-  handleRestart,
-  handleTTS,
-  handleTTSButton,
-  handleUpdate,
-  handleVerbosity
-} from "./chunk-KIRH7TUJ.js";
+} from "./chunk-QSDZDHNS.js";
 import {
   handleCancel,
   handleCleanupButton,
   handleHandoff,
   handleSessions,
   handleStatus
-} from "./chunk-4CTX774K.js";
+} from "./chunk-GJOY37U7.js";
 import {
   buildDeepLink,
   createSessionThread,
@@ -31,24 +17,42 @@ import {
   ensureForums,
   ensureUnarchived,
   renameSessionThread
-} from "./chunk-BNLGTZ34.js";
+} from "./chunk-O5RG4YZY.js";
 import {
   handleAgentButton,
   handleAgents,
   handleInstall
-} from "./chunk-J4SJTKIK.js";
+} from "./chunk-NAM4ERUW.js";
 import {
   handleSettings,
   handleSettingsButton
-} from "./chunk-O7CPGUAI.js";
+} from "./chunk-4KGLKKQK.js";
 import {
   handleDoctor,
   handleDoctorButton
-} from "./chunk-2HMQOC7N.js";
+} from "./chunk-I3CGU5W7.js";
+import {
+  buildActionKeyboard,
+  detectAction,
+  storeAction
+} from "./chunk-HVBNCPAY.js";
+import {
+  handleDangerous,
+  handleDangerousButton,
+  handleRestart,
+  handleTTS,
+  handleTTSButton,
+  handleUpdate,
+  handleVerbosity
+} from "./chunk-MTSDOSXS.js";
 import {
   PRODUCT_GUIDE,
-  dispatchMessage,
-  evaluateNoise,
+  SendQueue,
+  ToolCallTracker
+} from "./chunk-5ZOFBTOR.js";
+import {
+  BaseRenderer,
+  MessagingAdapter,
   extractContentText,
   formatTokens,
   formatToolSummary,
@@ -58,93 +62,24 @@ import {
   splitMessage,
   stripCodeFences,
   truncateContent
-} from "./chunk-OWP7RZ62.js";
-import {
-  ChannelAdapter
-} from "./chunk-LBIKITQT.js";
-import "./chunk-NVPG6JCL.js";
-import "./chunk-JHYXKVV2.js";
-import "./chunk-33RP6K2O.js";
+} from "./chunk-V2M243KZ.js";
+import "./chunk-L7YNNBI5.js";
+import "./chunk-ODUM3D6X.js";
+import "./chunk-QVMEF6FB.js";
 import {
+  createChildLogger,
   log
-} from "./chunk-GAK6PIBW.js";
+} from "./chunk-XMMAGAT4.js";
 import "./chunk-VUNV25KB.js";
 
-// src/adapters/discord/adapter.ts
+// src/plugins/discord/adapter.ts
 import {
   Client,
   GatewayIntentBits,
   MessageFlags
 } from "discord.js";
 
-// src/adapters/discord/send-queue.ts
-var DiscordSendQueue = class {
-  items = [];
-  processing = false;
-  lastExec = 0;
-  minInterval;
-  constructor(minInterval = 1e3) {
-    this.minInterval = minInterval;
-  }
-  enqueue(fn, opts) {
-    const type = opts.type;
-    const key = opts.key;
-    return new Promise((resolve, reject) => {
-      if (type === "text" && key) {
-        const idx = this.items.findIndex(
-          (item) => item.type === "text" && item.key === key
-        );
-        if (idx !== -1) {
-          this.items[idx].resolve(void 0);
-          this.items[idx] = { fn, type, key, resolve, reject };
-          this.scheduleProcess();
-          return;
-        }
-      }
-      this.items.push({ fn, type, key, resolve, reject });
-      this.scheduleProcess();
-    });
-  }
-  onRateLimited() {
-    log.warn("[DiscordSendQueue] Rate limited \u2014 dropping queued text items");
-    const remaining = [];
-    for (const item of this.items) {
-      if (item.type === "text") {
-        item.resolve(void 0);
-      } else {
-        remaining.push(item);
-      }
-    }
-    this.items = remaining;
-  }
-  scheduleProcess() {
-    if (this.processing) return;
-    if (this.items.length === 0) return;
-    const elapsed = Date.now() - this.lastExec;
-    const delay = Math.max(0, this.minInterval - elapsed);
-    this.processing = true;
-    setTimeout(() => void this.processNext(), delay);
-  }
-  async processNext() {
-    const item = this.items.shift();
-    if (!item) {
-      this.processing = false;
-      return;
-    }
-    try {
-      const result = await item.fn();
-      item.resolve(result);
-    } catch (err) {
-      item.reject(err);
-    } finally {
-      this.lastExec = Date.now();
-      this.processing = false;
-      this.scheduleProcess();
-    }
-  }
-};
-
-// src/adapters/discord/formatting.ts
+// src/plugins/discord/formatting.ts
 function formatViewerLinks(links, filePath) {
   if (!links) return "";
   const fileName = filePath ? filePath.split("/").pop() || filePath : "";
@@ -230,97 +165,164 @@ function splitMessage2(text, maxLength = 1800) {
   return splitMessage(text, maxLength);
 }
 
-// src/adapters/discord/tool-call-tracker.ts
-var ToolCallTracker = class {
+// src/plugins/discord/renderer.ts
+var DiscordRenderer = class extends BaseRenderer {
+  renderToolCall(content, verbosity) {
+    const meta = content.metadata ?? {};
+    return { body: formatToolCall(meta, verbosity), format: "markdown" };
+  }
+  renderToolUpdate(content, verbosity) {
+    const meta = content.metadata ?? {};
+    return { body: formatToolUpdate(meta, verbosity), format: "markdown" };
+  }
+  renderPlan(content, verbosity) {
+    const entries = content.metadata?.entries ?? [];
+    return { body: formatPlan(entries, verbosity), format: "markdown" };
+  }
+  renderUsage(content, verbosity) {
+    const meta = content.metadata;
+    return { body: formatUsage(meta ?? {}, verbosity), format: "markdown" };
+  }
+  renderError(content) {
+    return { body: `\u274C **Error:** ${content.text}`, format: "markdown" };
+  }
+  renderNotification(notification) {
+    const emoji = {
+      completed: "\u2705",
+      error: "\u274C",
+      permission: "\u{1F510}",
+      input_required: "\u{1F4AC}",
+      budget_warning: "\u26A0\uFE0F"
+    };
+    const icon = emoji[notification.type] || "\u2139\uFE0F";
+    const name = notification.sessionName ? ` **${notification.sessionName}**` : "";
+    let text = `${icon}${name}: ${notification.summary}`;
+    if (notification.deepLink) {
+      text += `
+${notification.deepLink}`;
+    }
+    return { body: text, format: "markdown" };
+  }
+  renderSystemMessage(content) {
+    return { body: content.text, format: "markdown" };
+  }
+  renderSessionEnd(_content) {
+    return { body: "\u2705 Done", format: "markdown" };
+  }
+  renderModeChange(content) {
+    const modeId = content.metadata?.modeId ?? "";
+    return { body: `\u{1F504} **Mode:** ${modeId}`, format: "markdown" };
+  }
+  renderConfigUpdate() {
+    return { body: "\u2699\uFE0F **Config updated**", format: "markdown" };
+  }
+  renderModelUpdate(content) {
+    const modelId = content.metadata?.modelId ?? "";
+    return { body: `\u{1F916} **Model:** ${modelId}`, format: "markdown" };
+  }
+};
+
+// src/plugins/discord/tool-call-tracker.ts
+var log2 = createChildLogger({ module: "discord-tool-call-tracker" });
+var DiscordToolCallTracker = class {
   constructor(sendQueue) {
     this.sendQueue = sendQueue;
   }
-  sessions = /* @__PURE__ */ new Map();
+  tracker = new ToolCallTracker();
+  /** Platform-specific ready-promise + message per tool call, keyed by `${sessionId}:${toolId}`. */
+  platformState = /* @__PURE__ */ new Map();
   async trackNewCall(sessionId, thread, tool, verbosity = "medium") {
-    if (!this.sessions.has(sessionId)) {
-      this.sessions.set(sessionId, /* @__PURE__ */ new Map());
-    }
     let resolveReady;
     const ready = new Promise((r) => {
       resolveReady = r;
     });
-    const state = {
-      message: void 0,
-      name: tool.name,
-      kind: tool.kind,
-      rawInput: tool.rawInput,
-      viewerLinks: tool.viewerLinks,
-      viewerFilePath: tool.viewerFilePath,
-      ready
-    };
-    this.sessions.get(sessionId).set(tool.id, state);
+    const key = `${sessionId}:${tool.id}`;
+    this.platformState.set(key, { message: void 0, ready });
+    this.tracker.track(sessionId, tool, "0");
     const content = formatToolCall(tool, verbosity);
     try {
       const msg = await this.sendQueue.enqueue(() => thread.send({ content }), {
         type: "other"
       });
-      if (msg) state.message = msg;
+      if (msg) {
+        const state = this.platformState.get(key);
+        if (state) state.message = msg;
+      }
     } catch (err) {
-      log.warn(
+      log2.warn(
         { err, toolId: tool.id },
-        "[ToolCallTracker] trackNewCall() send failed"
+        "trackNewCall() send failed"
       );
     } finally {
       resolveReady();
     }
   }
   async updateCall(sessionId, update, verbosity = "medium") {
-    const toolState = this.sessions.get(sessionId)?.get(update.id);
-    if (!toolState) return;
-    if (update.viewerLinks) toolState.viewerLinks = update.viewerLinks;
-    if (update.viewerFilePath) toolState.viewerFilePath = update.viewerFilePath;
-    if (update.name) toolState.name = update.name;
-    if (update.kind) toolState.kind = update.kind;
+    const key = `${sessionId}:${update.id}`;
+    const state = this.platformState.get(key);
+    const tracked = this.tracker.update(sessionId, update.id, update.status, {
+      viewerLinks: update.viewerLinks,
+      viewerFilePath: update.viewerFilePath,
+      name: update.name,
+      kind: update.kind
+    });
+    if (!tracked) return;
     const isTerminal = update.status === "completed" || update.status === "failed";
     if (!isTerminal) return;
-    await toolState.ready;
-    if (!toolState.message) return;
-    log.debug(
+    if (state) {
+      await state.ready;
+    }
+    if (!state?.message) return;
+    log2.debug(
       {
         toolId: update.id,
         status: update.status,
-        hasViewerLinks: !!toolState.viewerLinks,
-        name: toolState.name,
-        msgId: toolState.message.id
+        hasViewerLinks: !!tracked.viewerLinks,
+        name: tracked.name,
+        msgId: state.message.id
       },
-      "[ToolCallTracker] Tool completed, preparing edit"
+      "Tool completed, preparing edit"
     );
     const merged = {
-      ...update,
-      name: toolState.name,
-      kind: toolState.kind,
-      rawInput: toolState.rawInput,
-      viewerLinks: toolState.viewerLinks,
-      viewerFilePath: toolState.viewerFilePath
+      id: update.id,
+      name: tracked.name,
+      kind: tracked.kind,
+      rawInput: tracked.rawInput,
+      viewerLinks: tracked.viewerLinks,
+      viewerFilePath: tracked.viewerFilePath,
+      displaySummary: tracked.displaySummary,
+      displayTitle: tracked.displayTitle,
+      displayKind: tracked.displayKind,
+      status: update.status,
+      content: update.content
     };
     const content = formatToolUpdate(merged, verbosity);
     try {
-      await this.sendQueue.enqueue(() => toolState.message.edit({ content }), {
+      await this.sendQueue.enqueue(() => state.message.edit({ content }), {
         type: "other"
       });
     } catch (err) {
-      log.warn(
+      log2.warn(
         {
           err,
-          msgId: toolState.message.id,
+          msgId: state.message.id,
           contentLen: content.length,
           hasViewerLinks: !!merged.viewerLinks
         },
-        "[ToolCallTracker] Tool update edit failed"
+        "Tool update edit failed"
       );
     }
   }
   cleanup(sessionId) {
-    this.sessions.delete(sessionId);
+    const active = this.tracker.getActive(sessionId);
+    for (const tool of active) {
+      this.platformState.delete(`${sessionId}:${tool.id}`);
+    }
+    this.tracker.clear(sessionId);
   }
 };
 
-// src/adapters/discord/streaming.ts
+// src/plugins/discord/streaming.ts
 var FLUSH_INTERVAL = 5e3;
 var MAX_DISPLAY_LENGTH = 1900;
 var MessageDraft = class {
@@ -469,8 +471,8 @@ var MessageDraft = class {
   }
 };
 
-// src/adapters/discord/draft-manager.ts
-var DraftManager = class {
+// src/plugins/discord/draft-manager.ts
+var DiscordDraftManager = class {
   constructor(sendQueue) {
     this.sendQueue = sendQueue;
   }
@@ -530,7 +532,7 @@ var DraftManager = class {
   }
 };
 
-// src/adapters/discord/activity.ts
+// src/plugins/discord/activity.ts
 import { EmbedBuilder } from "discord.js";
 var TYPING_REFRESH_MS = 8e3;
 var ThinkingIndicator = class {
@@ -731,7 +733,7 @@ var ActivityTracker = class {
   }
 };
 
-// src/adapters/discord/skill-command-manager.ts
+// src/plugins/discord/skill-command-manager.ts
 var DISCORD_MSG_LIMIT = 1900;
 function buildSkillContent(commands) {
   const sorted = [...commands].sort((a, b) => a.name.localeCompare(b.name));
@@ -825,7 +827,7 @@ var SkillCommandManager = class {
   }
 };
 
-// src/adapters/discord/permissions.ts
+// src/plugins/discord/permissions.ts
 import { ActionRowBuilder, ButtonBuilder, ButtonStyle } from "discord.js";
 import { nanoid } from "nanoid";
 var PermissionHandler = class {
@@ -912,10 +914,10 @@ ${request.description}`,
   }
 };
 
-// src/adapters/discord/commands/index.ts
+// src/plugins/discord/commands/index.ts
 import { SlashCommandBuilder } from "discord.js";
 
-// src/adapters/discord/commands/menu.ts
+// src/plugins/discord/commands/menu.ts
 import {
   ActionRowBuilder as ActionRowBuilder2,
   ButtonBuilder as ButtonBuilder2,
@@ -1006,12 +1008,12 @@ async function handleMenuButton(interaction, adapter) {
   try {
     switch (customId) {
       case "m:new": {
-        const { handleNew: handleNew2 } = await import("./new-session-FEO4J4VU.js");
+        const { handleNew: handleNew2 } = await import("./new-session-AVQCNXRG.js");
         await interaction.followUp({ content: "Use `/new` to create a new session.", ephemeral: true });
         break;
       }
       case "m:sessions": {
-        const { handleSessions: handleSessions2 } = await import("./session-IUSI7P5S.js");
+        const { handleSessions: handleSessions2 } = await import("./session-KZFA6Z26.js");
         await showSessionsList(interaction, adapter);
         break;
       }
@@ -1020,12 +1022,12 @@ async function handleMenuButton(interaction, adapter) {
         break;
       }
       case "m:agents": {
-        const { showAgentsList } = await import("./agents-QO7DKARJ.js");
+        const { showAgentsList } = await import("./agents-BWU4MRRD.js");
         await showAgentsList(interaction, adapter);
         break;
       }
       case "m:settings": {
-        const { showSettingsInfo } = await import("./settings-RQPAM4KC.js");
+        const { showSettingsInfo } = await import("./settings-MFYM7CZO.js");
         await showSettingsInfo(interaction, adapter);
         break;
       }
@@ -1034,7 +1036,7 @@ async function handleMenuButton(interaction, adapter) {
         break;
       }
       case "m:restart": {
-        const { handleRestart: handleRestart2 } = await import("./admin-6SYB6XCZ.js");
+        const { handleRestart: handleRestart2 } = await import("./admin-GBPZFFAU.js");
         if (!adapter.core.requestRestart) {
           await interaction.followUp({ content: "\u26A0\uFE0F Restart not available.", ephemeral: true });
         } else {
@@ -1053,7 +1055,7 @@ async function handleMenuButton(interaction, adapter) {
         break;
       }
       case "m:doctor": {
-        const { runDoctorInline } = await import("./doctor-OLYBO3V3.js");
+        const { runDoctorInline } = await import("./doctor-RF6BHMCC.js");
         await runDoctorInline(interaction, adapter);
         break;
       }
@@ -1130,7 +1132,7 @@ ${lines.join("\n")}${truncated}`,
   });
 }
 
-// src/adapters/discord/commands/integrate.ts
+// src/plugins/discord/commands/integrate.ts
 async function handleIntegrate(interaction, _adapter) {
   await interaction.deferReply({ ephemeral: true });
   await interaction.editReply(
@@ -1148,7 +1150,7 @@ async function handleIntegrateButton(interaction, _adapter) {
   }
 }
 
-// src/adapters/discord/commands/router.ts
+// src/plugins/discord/commands/router.ts
 async function handleSlashCommand(interaction, adapter) {
   const { commandName } = interaction;
   try {
@@ -1246,7 +1248,7 @@ async function setupButtonCallbacks(interaction, adapter) {
       return;
     }
     if (customId.startsWith("a:")) {
-      const { getAction, removeAction } = await import("./action-detect-P7ZE4NEM.js");
+      const { getAction, removeAction } = await import("./action-detect-QPA775HB.js");
       const actionId = customId.slice(2);
       const action = getAction(actionId);
       if (!action) {
@@ -1329,15 +1331,15 @@ async function setupButtonCallbacks(interaction, adapter) {
   }
 }
 async function executeNewSession(interaction, adapter, agentName, workspace) {
-  const { executeNewSession: doExecute } = await import("./new-session-FEO4J4VU.js");
+  const { executeNewSession: doExecute } = await import("./new-session-AVQCNXRG.js");
   await doExecute(interaction, adapter, agentName, workspace);
 }
 async function executeCancelSession(interaction, adapter) {
-  const { executeCancelSession: doCancel } = await import("./session-IUSI7P5S.js");
+  const { executeCancelSession: doCancel } = await import("./session-KZFA6Z26.js");
   await doCancel(interaction, adapter);
 }
 
-// src/adapters/discord/commands/index.ts
+// src/plugins/discord/commands/index.ts
 var SLASH_COMMANDS = [
   new SlashCommandBuilder().setName("new").setDescription("Create a new agent session").addStringOption(
     (o) => o.setName("agent").setDescription("Agent to use").setRequired(false)
@@ -1381,7 +1383,7 @@ async function registerSlashCommands(guild) {
   await guild.commands.set(SLASH_COMMANDS.map((cmd) => cmd.toJSON()));
 }
 
-// src/adapters/discord/assistant.ts
+// src/plugins/discord/assistant.ts
 async function spawnAssistant(core, threadId) {
   const config = core.configManager.get();
   log.info({ agent: config.defaultAgent, threadId }, "[discord-assistant] Creating assistant session...");
@@ -1551,7 +1553,7 @@ openacp api restart                      # Restart daemon
 ${PRODUCT_GUIDE}`;
 }
 
-// src/adapters/discord/media.ts
+// src/plugins/discord/media.ts
 var MAX_DOWNLOAD_SIZE = 100 * 1024 * 1024;
 var DISCORD_UPLOAD_LIMIT = 25 * 1024 * 1024;
 function isAttachmentTooLarge(size) {
@@ -1582,8 +1584,19 @@ async function downloadDiscordAttachment(url, fileName) {
   }
 }
 
-// src/adapters/discord/adapter.ts
-var DiscordAdapter = class extends ChannelAdapter {
+// src/plugins/discord/adapter.ts
+var DiscordAdapter = class extends MessagingAdapter {
+  name = "discord";
+  renderer = new DiscordRenderer();
+  capabilities = {
+    streaming: true,
+    richFormatting: true,
+    threads: true,
+    reactions: true,
+    fileUpload: true,
+    voice: false
+  };
+  core;
   client;
   discordConfig;
   sendQueue;
@@ -1592,17 +1605,20 @@ var DiscordAdapter = class extends ChannelAdapter {
   skillManager;
   permissionHandler;
   sessionTrackers = /* @__PURE__ */ new Map();
-  get verbosity() {
-    return this.discordConfig.displayVerbosity ?? "medium";
-  }
   guild;
   forumChannel;
   notificationChannel;
   assistantSession = null;
   assistantInitializing = false;
   fileService;
+  // Per-session thread context for concurrency safety in sendMessage handlers
+  _sessionContexts = /* @__PURE__ */ new Map();
   constructor(core, config) {
-    super(core, config);
+    super(
+      { configManager: core.configManager },
+      { ...config, maxMessageLength: 2e3, enabled: config.enabled ?? true }
+    );
+    this.core = core;
     this.discordConfig = config;
     this.client = new Client({
       intents: [
@@ -1611,9 +1627,9 @@ var DiscordAdapter = class extends ChannelAdapter {
         GatewayIntentBits.MessageContent
       ]
     });
-    this.sendQueue = new DiscordSendQueue();
-    this.toolTracker = new ToolCallTracker(this.sendQueue);
-    this.draftManager = new DraftManager(this.sendQueue);
+    this.sendQueue = new SendQueue({ minInterval: 1e3 });
+    this.toolTracker = new DiscordToolCallTracker(this.sendQueue);
+    this.draftManager = new DiscordDraftManager(this.sendQueue);
     this.fileService = core.fileService;
     this.client.rest.on("rateLimited", (info) => {
       log.warn(
@@ -1699,14 +1715,84 @@ var DiscordAdapter = class extends ChannelAdapter {
     log.info("[DiscordAdapter] Stopped");
   }
   // ─── Interaction handler ──────────────────────────────────────────────────
+  getCommandRegistry() {
+    return this.core.lifecycleManager?.serviceRegistry?.get("command-registry");
+  }
   setupInteractionHandler() {
     this.client.on("interactionCreate", async (interaction) => {
       try {
         if (interaction.isChatInputCommand()) {
+          const registry = this.getCommandRegistry();
+          if (registry) {
+            const commandName = interaction.commandName;
+            const def = registry.get(commandName);
+            if (def) {
+              const rawParts = [];
+              for (const opt of interaction.options.data) {
+                rawParts.push(String(opt.value ?? ""));
+              }
+              const channelId = interaction.channelId;
+              const sessionId = this.core.sessionManager.getSessionByThread("discord", channelId)?.id ?? null;
+              const response = await registry.execute(
+                `/${commandName} ${rawParts.join(" ")}`.trim(),
+                {
+                  raw: "",
+                  sessionId,
+                  channelId: "discord",
+                  userId: interaction.user.id,
+                  options: Object.fromEntries(
+                    interaction.options.data.map((o) => [o.name, String(o.value ?? "")])
+                  ),
+                  reply: async (content) => {
+                    if (typeof content === "string") {
+                      if (interaction.replied || interaction.deferred) {
+                        await interaction.editReply({ content });
+                      } else {
+                        await interaction.reply({ content });
+                      }
+                    }
+                  }
+                }
+              );
+              if (response.type !== "silent") {
+                await this.renderCommandResponse(response, interaction);
+              } else if (!interaction.replied && !interaction.deferred) {
+                await interaction.deferReply();
+              }
+              return;
+            }
+          }
           await handleSlashCommand(interaction, this);
           return;
         }
         if (interaction.isButton()) {
+          if (interaction.customId.startsWith("c/")) {
+            const registry = this.getCommandRegistry();
+            if (registry) {
+              const command = interaction.customId.slice(2);
+              const channelId = interaction.channelId;
+              const sessionId = this.core.sessionManager.getSessionByThread("discord", channelId)?.id ?? null;
+              const response = await registry.execute(command, {
+                raw: "",
+                sessionId,
+                channelId: "discord",
+                userId: interaction.user.id,
+                reply: async (content) => {
+                  if (typeof content === "string") {
+                    if (interaction.replied || interaction.deferred) {
+                      await interaction.editReply({ content });
+                    } else {
+                      await interaction.reply({ content, ephemeral: true });
+                    }
+                  }
+                }
+              });
+              if (response.type !== "silent") {
+                await this.renderCommandResponse(response, interaction);
+              }
+              return;
+            }
+          }
           const handled = await this.permissionHandler.handleButtonInteraction(interaction);
           if (!handled) {
             await setupButtonCallbacks(interaction, this);
@@ -1717,6 +1803,59 @@ var DiscordAdapter = class extends ChannelAdapter {
       }
     });
   }
+  // ─── CommandRegistry response rendering ──────────────────────────────────
+  async renderCommandResponse(response, interaction) {
+    const reply = async (opts) => {
+      if (interaction.replied || interaction.deferred) {
+        await interaction.editReply(opts);
+      } else {
+        await interaction.reply(opts);
+      }
+    };
+    switch (response.type) {
+      case "text":
+        await reply({ content: response.text });
+        break;
+      case "error":
+        await reply({ content: `\u26A0\uFE0F ${response.message}`, ephemeral: true });
+        break;
+      case "menu": {
+        const { ActionRowBuilder: ActionRowBuilder3, ButtonBuilder: ButtonBuilder3, ButtonStyle: ButtonStyle3, EmbedBuilder: EmbedBuilder2 } = await import("discord.js");
+        const embed = new EmbedBuilder2().setTitle(response.title);
+        const rows = [];
+        for (let i = 0; i < response.options.length && rows.length < 5; i += 5) {
+          const row = new ActionRowBuilder3();
+          const slice = response.options.slice(i, i + 5);
+          for (const opt of slice) {
+            row.addComponents(
+              new ButtonBuilder3().setCustomId(`c/${opt.command}`).setLabel(opt.label.slice(0, 80)).setStyle(ButtonStyle3.Secondary)
+            );
+          }
+          rows.push(row);
+        }
+        await reply({ embeds: [embed], components: rows });
+        break;
+      }
+      case "list": {
+        const { EmbedBuilder: EmbedBuilder2 } = await import("discord.js");
+        const desc = response.items.map((i) => `\u2022 **${i.label}**${i.detail ? ` \u2014 ${i.detail}` : ""}`).join("\n");
+        const embed = new EmbedBuilder2().setTitle(response.title).setDescription(desc);
+        await reply({ embeds: [embed] });
+        break;
+      }
+      case "confirm": {
+        const { ActionRowBuilder: ActionRowBuilder3, ButtonBuilder: ButtonBuilder3, ButtonStyle: ButtonStyle3 } = await import("discord.js");
+        const row = new ActionRowBuilder3().addComponents(
+          new ButtonBuilder3().setCustomId(`c/${response.onYes}`).setLabel("Yes").setStyle(ButtonStyle3.Success),
+          new ButtonBuilder3().setCustomId(`c/${response.onNo || "noop"}`).setLabel("No").setStyle(ButtonStyle3.Secondary)
+        );
+        await reply({ content: response.question, components: [row] });
+        break;
+      }
+      case "silent":
+        break;
+    }
+  }
   // ─── Message handler ──────────────────────────────────────────────────────
   setupMessageHandler() {
     this.client.on("messageCreate", async (message) => {
@@ -1926,213 +2065,229 @@ var DiscordAdapter = class extends ChannelAdapter {
     }
     return this.sessionTrackers.get(sessionId);
   }
-  // --- MessageHandlers for dispatchMessage ---
-  messageHandlers = {
-    onThought: async (ctx, _content) => {
-      const tracker = this.getOrCreateTracker(ctx.sessionId, ctx.thread);
-      await tracker.onThought();
-    },
-    onText: async (ctx, content) => {
-      const tracker = this.getOrCreateTracker(ctx.sessionId, ctx.thread);
-      await tracker.onTextStart();
-      const draft = this.draftManager.getOrCreate(ctx.sessionId, ctx.thread);
-      draft.append(content.text);
-      this.draftManager.appendText(ctx.sessionId, content.text);
-    },
-    onToolCall: async (ctx, content) => {
-      const meta = content.metadata ?? {};
-      const toolName = String(meta.name ?? content.text ?? "Tool");
-      const toolKind = String(meta.kind ?? "other");
-      const noiseAction = evaluateNoise(toolName, toolKind, meta.rawInput);
-      if (noiseAction === "hide" && this.verbosity !== "high") return;
-      if (noiseAction === "collapse" && this.verbosity === "low") return;
-      const tracker = this.getOrCreateTracker(ctx.sessionId, ctx.thread);
-      await tracker.onToolCall();
-      await this.draftManager.finalize(
-        ctx.sessionId,
-        ctx.thread,
-        ctx.isAssistant
-      );
-      await this.toolTracker.trackNewCall(
-        ctx.sessionId,
-        ctx.thread,
-        {
-          id: String(meta.id ?? ""),
-          name: toolName,
-          kind: meta.kind,
-          status: String(meta.status ?? "running"),
-          content: meta.content,
-          rawInput: meta.rawInput,
-          viewerLinks: meta.viewerLinks,
-          viewerFilePath: meta.viewerFilePath,
-          displaySummary: meta.displaySummary,
-          displayTitle: meta.displayTitle,
-          displayKind: meta.displayKind
-        },
-        this.verbosity
-      );
-    },
-    onToolUpdate: async (ctx, content) => {
-      const meta = content.metadata ?? {};
-      await this.toolTracker.updateCall(
-        ctx.sessionId,
-        {
-          id: String(meta.id ?? ""),
-          name: content.text || String(meta.name ?? ""),
-          kind: meta.kind,
-          status: String(meta.status ?? "completed"),
-          content: meta.content,
-          rawInput: meta.rawInput,
-          viewerLinks: meta.viewerLinks,
-          viewerFilePath: meta.viewerFilePath,
-          displaySummary: meta.displaySummary,
-          displayTitle: meta.displayTitle,
-          displayKind: meta.displayKind
-        },
-        this.verbosity
+  getSessionContext(sessionId) {
+    const ctx = this._sessionContexts.get(sessionId);
+    if (!ctx) {
+      throw new Error(`No thread context stored for session ${sessionId}`);
+    }
+    return ctx;
+  }
+  // ─── sendMessage ──────────────────────────────────────────────────────────
+  async sendMessage(sessionId, content) {
+    if (this.assistantInitializing && this.assistantSession && sessionId === this.assistantSession.id) {
+      return;
+    }
+    const thread = await this.getThread(sessionId);
+    if (!thread) return;
+    await ensureUnarchived(thread);
+    this._sessionContexts.set(sessionId, {
+      thread,
+      isAssistant: this.assistantSession != null && sessionId === this.assistantSession.id
+    });
+    try {
+      await super.sendMessage(sessionId, content);
+    } finally {
+      this._sessionContexts.delete(sessionId);
+    }
+  }
+  // ─── Handler overrides ─────────────────────────────────────────────────────
+  async handleThought(sessionId, _content, _verbosity) {
+    const { thread } = this.getSessionContext(sessionId);
+    const tracker = this.getOrCreateTracker(sessionId, thread);
+    await tracker.onThought();
+  }
+  async handleText(sessionId, content) {
+    const { thread } = this.getSessionContext(sessionId);
+    const tracker = this.getOrCreateTracker(sessionId, thread);
+    await tracker.onTextStart();
+    const draft = this.draftManager.getOrCreate(sessionId, thread);
+    draft.append(content.text);
+    this.draftManager.appendText(sessionId, content.text);
+  }
+  async handleToolCall(sessionId, content, verbosity) {
+    const { thread, isAssistant } = this.getSessionContext(sessionId);
+    const meta = content.metadata ?? {};
+    const toolName = String(meta.name ?? content.text ?? "Tool");
+    const tracker = this.getOrCreateTracker(sessionId, thread);
+    await tracker.onToolCall();
+    await this.draftManager.finalize(
+      sessionId,
+      thread,
+      isAssistant
+    );
+    await this.toolTracker.trackNewCall(
+      sessionId,
+      thread,
+      {
+        id: String(meta.id ?? ""),
+        name: toolName,
+        kind: meta.kind,
+        status: String(meta.status ?? "running"),
+        content: meta.content,
+        rawInput: meta.rawInput,
+        viewerLinks: meta.viewerLinks,
+        viewerFilePath: meta.viewerFilePath,
+        displaySummary: meta.displaySummary,
+        displayTitle: meta.displayTitle,
+        displayKind: meta.displayKind
+      },
+      verbosity
+    );
+  }
+  async handleToolUpdate(sessionId, content, verbosity) {
+    const meta = content.metadata ?? {};
+    await this.toolTracker.updateCall(
+      sessionId,
+      {
+        id: String(meta.id ?? ""),
+        name: content.text || String(meta.name ?? ""),
+        kind: meta.kind,
+        status: String(meta.status ?? "completed"),
+        content: meta.content,
+        rawInput: meta.rawInput,
+        viewerLinks: meta.viewerLinks,
+        viewerFilePath: meta.viewerFilePath,
+        displaySummary: meta.displaySummary,
+        displayTitle: meta.displayTitle,
+        displayKind: meta.displayKind
+      },
+      verbosity
+    );
+  }
+  async handlePlan(sessionId, content, verbosity) {
+    const { thread } = this.getSessionContext(sessionId);
+    const entries = content.metadata?.entries ?? [];
+    const tracker = this.getOrCreateTracker(sessionId, thread);
+    await tracker.onPlan(entries, verbosity);
+  }
+  async handleUsage(sessionId, content, verbosity) {
+    const { thread, isAssistant } = this.getSessionContext(sessionId);
+    await this.draftManager.finalize(
+      sessionId,
+      thread,
+      isAssistant
+    );
+    const meta = content.metadata ?? {};
+    const tracker = this.getOrCreateTracker(sessionId, thread);
+    await tracker.sendUsage(
+      {
+        tokensUsed: meta.tokensUsed,
+        contextSize: meta.contextSize,
+        cost: meta.cost
+      },
+      verbosity
+    );
+    try {
+      const deepLink = buildDeepLink(this.guild.id, thread.id);
+      await this.sendNotification({
+        sessionId,
+        type: "completed",
+        summary: content.text || "Session completed",
+        deepLink
+      });
+    } catch {
+    }
+  }
+  async handleSessionEnd(sessionId, _content) {
+    const { thread, isAssistant } = this.getSessionContext(sessionId);
+    await this.draftManager.finalize(
+      sessionId,
+      thread,
+      isAssistant
+    );
+    const tracker = this.getOrCreateTracker(sessionId, thread);
+    await tracker.cleanup();
+    this.toolTracker.cleanup(sessionId);
+    this.sessionTrackers.delete(sessionId);
+    await this.skillManager.cleanup(sessionId);
+    try {
+      await this.sendQueue.enqueue(
+        () => thread.send({ content: "\u2705 Done" }),
+        { type: "other" }
       );
-    },
-    onPlan: async (ctx, content) => {
-      const entries = content.metadata?.entries ?? [];
-      const tracker = this.getOrCreateTracker(ctx.sessionId, ctx.thread);
-      await tracker.onPlan(entries, this.verbosity);
-    },
-    onUsage: async (ctx, content) => {
-      await this.draftManager.finalize(
-        ctx.sessionId,
-        ctx.thread,
-        ctx.isAssistant
+    } catch {
+    }
+  }
+  async handleError(sessionId, content) {
+    const { thread, isAssistant } = this.getSessionContext(sessionId);
+    await this.draftManager.finalize(
+      sessionId,
+      thread,
+      isAssistant
+    );
+    const tracker = this.getOrCreateTracker(sessionId, thread);
+    await tracker.cleanup();
+    this.toolTracker.cleanup(sessionId);
+    this.sessionTrackers.delete(sessionId);
+    try {
+      await this.sendQueue.enqueue(
+        () => thread.send({ content: `\u274C Error: ${content.text}` }),
+        { type: "other" }
       );
-      const meta = content.metadata ?? {};
-      const tracker = this.getOrCreateTracker(ctx.sessionId, ctx.thread);
-      await tracker.sendUsage(
+    } catch {
+    }
+  }
+  async handleAttachment(sessionId, content) {
+    if (!content.attachment) return;
+    const { attachment } = content;
+    const { thread, isAssistant } = this.getSessionContext(sessionId);
+    await this.draftManager.finalize(
+      sessionId,
+      thread,
+      isAssistant
+    );
+    if (isAttachmentTooLarge(attachment.size)) {
+      log.warn(
         {
-          tokensUsed: meta.tokensUsed,
-          contextSize: meta.contextSize,
-          cost: meta.cost
+          sessionId,
+          fileName: attachment.fileName,
+          size: attachment.size
         },
-        this.verbosity
+        "[discord-media] File too large (>25MB)"
       );
-      try {
-        const deepLink = buildDeepLink(this.guild.id, ctx.thread.id);
-        await this.sendNotification({
-          sessionId: ctx.sessionId,
-          type: "completed",
-          summary: content.text || "Session completed",
-          deepLink
-        });
-      } catch {
-      }
-    },
-    onSessionEnd: async (ctx, _content) => {
-      await this.draftManager.finalize(
-        ctx.sessionId,
-        ctx.thread,
-        ctx.isAssistant
-      );
-      const tracker = this.getOrCreateTracker(ctx.sessionId, ctx.thread);
-      await tracker.cleanup();
-      this.toolTracker.cleanup(ctx.sessionId);
-      this.sessionTrackers.delete(ctx.sessionId);
-      await this.skillManager.cleanup(ctx.sessionId);
       try {
         await this.sendQueue.enqueue(
-          () => ctx.thread.send({ content: "\u2705 Done" }),
-          { type: "other" }
-        );
-      } catch {
-      }
-    },
-    onError: async (ctx, content) => {
-      await this.draftManager.finalize(
-        ctx.sessionId,
-        ctx.thread,
-        ctx.isAssistant
-      );
-      const tracker = this.getOrCreateTracker(ctx.sessionId, ctx.thread);
-      await tracker.cleanup();
-      this.toolTracker.cleanup(ctx.sessionId);
-      this.sessionTrackers.delete(ctx.sessionId);
-      try {
-        await this.sendQueue.enqueue(
-          () => ctx.thread.send({ content: `\u274C Error: ${content.text}` }),
+          () => thread.send({
+            content: `\u26A0\uFE0F File too large to send (${Math.round(attachment.size / 1024 / 1024)}MB): ${attachment.fileName}`
+          }),
           { type: "other" }
         );
       } catch {
       }
-    },
-    onAttachment: async (ctx, content) => {
-      if (!content.attachment) return;
-      const { attachment } = content;
-      await this.draftManager.finalize(
-        ctx.sessionId,
-        ctx.thread,
-        ctx.isAssistant
+      return;
+    }
+    try {
+      await this.sendQueue.enqueue(
+        () => thread.send({
+          files: [
+            { attachment: attachment.filePath, name: attachment.fileName }
+          ]
+        }),
+        { type: "other" }
       );
-      if (isAttachmentTooLarge(attachment.size)) {
-        log.warn(
-          {
-            sessionId: ctx.sessionId,
-            fileName: attachment.fileName,
-            size: attachment.size
-          },
-          "[discord-media] File too large (>25MB)"
-        );
-        try {
-          await this.sendQueue.enqueue(
-            () => ctx.thread.send({
-              content: `\u26A0\uFE0F File too large to send (${Math.round(attachment.size / 1024 / 1024)}MB): ${attachment.fileName}`
-            }),
-            { type: "other" }
-          );
-        } catch {
-        }
-        return;
-      }
-      try {
-        await this.sendQueue.enqueue(
-          () => ctx.thread.send({
-            files: [
-              { attachment: attachment.filePath, name: attachment.fileName }
-            ]
-          }),
-          { type: "other" }
-        );
-        if (attachment.type === "audio") {
-          const draft = this.draftManager.getDraft(ctx.sessionId);
-          if (draft) {
-            draft.stripPattern(/\[TTS\][\s\S]*?\[\/TTS\]/g).catch(() => {
-            });
-          }
+      if (attachment.type === "audio") {
+        const draft = this.draftManager.getDraft(sessionId);
+        if (draft) {
+          draft.stripPattern(/\[TTS\][\s\S]*?\[\/TTS\]/g).catch(() => {
+          });
         }
-      } catch (err) {
-        log.error(
-          { err, sessionId: ctx.sessionId, fileName: attachment.fileName },
-          "[discord-media] Failed to send attachment"
-        );
-      }
-    },
-    onSystemMessage: async (ctx, content) => {
-      try {
-        await this.sendQueue.enqueue(
-          () => ctx.thread.send({ content: content.text }),
-          { type: "other" }
-        );
-      } catch {
       }
+    } catch (err) {
+      log.error(
+        { err, sessionId, fileName: attachment.fileName },
+        "[discord-media] Failed to send attachment"
+      );
     }
-  };
-  // ─── sendMessage ──────────────────────────────────────────────────────────
-  async sendMessage(sessionId, content) {
-    if (this.assistantInitializing && this.assistantSession && sessionId === this.assistantSession.id) {
-      return;
+  }
+  async handleSystem(sessionId, content) {
+    const { thread } = this.getSessionContext(sessionId);
+    try {
+      await this.sendQueue.enqueue(
+        () => thread.send({ content: content.text }),
+        { type: "other" }
+      );
+    } catch {
     }
-    const thread = await this.getThread(sessionId);
-    if (!thread) return;
-    await ensureUnarchived(thread);
-    const isAssistant = this.assistantSession != null && sessionId === this.assistantSession.id;
-    const ctx = { sessionId, thread, isAssistant };
-    await dispatchMessage(this.messageHandlers, ctx, content, this.verbosity);
   }
   // ─── sendPermissionRequest ────────────────────────────────────────────────
   async sendPermissionRequest(sessionId, request) {
@@ -2236,4 +2391,4 @@ ${notification.deepLink}`;
 export {
   DiscordAdapter
 };
-//# sourceMappingURL=discord-OMC52Y54.js.map
+//# sourceMappingURL=adapter-77ZCVABT.js.map