@openacp/cli 0.6.9 → 2026.326.2

package/dist/{discord-7IVQKB2H.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,116 +17,69 @@ 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,
-  STATUS_ICONS,
-  dispatchMessage,
-  evaluateNoise,
+  SendQueue,
+  ToolCallTracker
+} from "./chunk-5ZOFBTOR.js";
+import {
+  BaseRenderer,
+  MessagingAdapter,
   extractContentText,
   formatTokens,
   formatToolSummary,
   formatToolTitle,
   progressBar,
+  resolveToolIcon,
   splitMessage,
   stripCodeFences,
   truncateContent
-} from "./chunk-JUYDFUSN.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
-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/plugins/discord/adapter.ts
+import {
+  Client,
+  GatewayIntentBits,
+  MessageFlags
+} from "discord.js";
 
-// src/adapters/discord/formatting.ts
+// src/plugins/discord/formatting.ts
 function formatViewerLinks(links, filePath) {
   if (!links) return "";
   const fileName = filePath ? filePath.split("/").pop() || filePath : "";
@@ -152,27 +91,47 @@ function formatViewerLinks(links, filePath) {
 [View diff${fileName ? ` \u2014 ${fileName}` : ""}](${links.diff})`;
   return text;
 }
-function formatToolCall(tool, verbosity = "medium") {
-  const si = STATUS_ICONS[tool.status || ""] || "\u{1F527}";
-  const name = tool.name || "Tool";
-  const label = verbosity === "low" ? formatToolTitle(name, tool.rawInput) : formatToolSummary(name, tool.rawInput);
-  let text = `${si} **${label}**`;
-  text += formatViewerLinks(tool.viewerLinks, tool.viewerFilePath);
-  if (verbosity === "high" || verbosity === "medium" && !tool.viewerLinks) {
-    const details = stripCodeFences(extractContentText(tool.content));
-    if (details) {
+function formatHighDetails(rawInput, content, maxLen) {
+  let text = "";
+  if (rawInput) {
+    const inputStr = typeof rawInput === "string" ? rawInput : JSON.stringify(rawInput, null, 2);
+    if (inputStr && inputStr !== "{}") {
       text += `
+**Input:**
 \`\`\`
-${truncateContent(details, 500)}
+${truncateContent(inputStr, maxLen)}
 \`\`\``;
     }
   }
+  const details = stripCodeFences(extractContentText(content));
+  if (details) {
+    text += `
+**Output:**
+\`\`\`
+${truncateContent(details, maxLen)}
+\`\`\``;
+  }
+  return text;
+}
+function formatToolCall(tool, verbosity = "medium") {
+  const si = resolveToolIcon(tool);
+  const name = tool.name || "Tool";
+  const label = verbosity === "low" ? formatToolTitle(name, tool.rawInput, tool.displayTitle) : formatToolSummary(name, tool.rawInput, tool.displaySummary);
+  let text = `${si} **${label}**`;
+  text += formatViewerLinks(tool.viewerLinks, tool.viewerFilePath);
+  if (verbosity === "high") {
+    text += formatHighDetails(tool.rawInput, tool.content, 500);
+  }
   return text;
 }
 function formatToolUpdate(update, verbosity = "medium") {
   return formatToolCall(update, verbosity);
 }
-function formatPlan(entries) {
+function formatPlan(entries, verbosity = "medium") {
+  if (verbosity === "medium") {
+    const done = entries.filter((e) => e.status === "completed").length;
+    return `\u{1F4CB} **Plan:** ${done}/${entries.length} steps completed`;
+  }
   const statusIcon = {
     pending: "\u23F3",
     in_progress: "\u{1F504}",
@@ -184,112 +143,186 @@ function formatPlan(entries) {
   return `**Plan:**
 ${lines.join("\n")}`;
 }
-function formatUsage(usage) {
-  const { tokensUsed, contextSize } = usage;
+function formatUsage(usage, verbosity = "medium") {
+  const { tokensUsed, contextSize, cost } = usage;
   if (tokensUsed == null) return "\u{1F4CA} Usage data unavailable";
+  if (verbosity === "medium") {
+    const costStr = cost != null ? ` \xB7 $${cost.toFixed(2)}` : "";
+    return `\u{1F4CA} ${formatTokens(tokensUsed)} tokens${costStr}`;
+  }
   if (contextSize == null) return `\u{1F4CA} ${formatTokens(tokensUsed)} tokens`;
   const ratio = tokensUsed / contextSize;
   const pct = Math.round(ratio * 100);
   const bar = progressBar(ratio);
   const emoji = pct >= 85 ? "\u26A0\uFE0F" : "\u{1F4CA}";
-  return `${emoji} ${formatTokens(tokensUsed)} / ${formatTokens(contextSize)} tokens
+  let text = `${emoji} ${formatTokens(tokensUsed)} / ${formatTokens(contextSize)} tokens
 ${bar} ${pct}%`;
+  if (cost != null) text += `
+\u{1F4B0} $${cost.toFixed(2)}`;
+  return text;
 }
 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 {
@@ -438,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;
   }
@@ -499,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 {
@@ -548,8 +581,8 @@ var UsageMessage = class {
     this.sendQueue = sendQueue;
   }
   message;
-  async send(usage) {
-    const text = formatUsage(usage);
+  async send(usage, verbosity = "medium") {
+    const text = formatUsage(usage, verbosity);
     const embed = new EmbedBuilder().setDescription(text);
     try {
       if (this.message) {
@@ -573,10 +606,7 @@ var UsageMessage = class {
     const msg = this.message;
     this.message = void 0;
     try {
-      await this.sendQueue.enqueue(
-        () => msg.delete(),
-        { type: "other" }
-      );
+      await this.sendQueue.enqueue(() => msg.delete(), { type: "other" });
     } catch (err) {
       log.warn({ err }, "[UsageMessage] delete() failed");
     }
@@ -593,6 +623,10 @@ var PlanCard = class {
   latestEntries;
   lastSentText;
   flushTimer;
+  verbosity = "medium";
+  setVerbosity(v) {
+    this.verbosity = v;
+  }
   update(entries) {
     this.latestEntries = entries;
     if (this.flushTimer) clearTimeout(this.flushTimer);
@@ -621,7 +655,7 @@ var PlanCard = class {
   }
   async _flush() {
     if (!this.latestEntries) return;
-    const text = formatPlan(this.latestEntries);
+    const text = formatPlan(this.latestEntries, this.verbosity);
     if (this.message && text === this.lastSentText) return;
     this.lastSentText = text;
     const embed = new EmbedBuilder().setDescription(text);
@@ -675,14 +709,15 @@ var ActivityTracker = class {
     this.thinking.dismiss();
     this.thinking.reset();
   }
-  async onPlan(entries) {
+  async onPlan(entries, verbosity) {
     await this._firstEventGuard();
     this.thinking.dismiss();
     this.hasPlanCard = true;
+    if (verbosity) this.planCard.setVerbosity(verbosity);
     this.planCard.update(entries);
   }
-  async sendUsage(usage) {
-    await this.usage.send(usage);
+  async sendUsage(usage, verbosity = "medium") {
+    await this.usage.send(usage, verbosity);
   }
   async cleanup() {
     this.thinking.dismiss();
@@ -698,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));
@@ -792,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 {
@@ -879,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,
@@ -973,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;
       }
@@ -987,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;
       }
@@ -1001,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 {
@@ -1020,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;
       }
@@ -1097,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(
@@ -1115,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 {
@@ -1213,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) {
@@ -1296,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)
@@ -1348,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...");
@@ -1518,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) {
@@ -1549,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;
@@ -1559,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: [
@@ -1578,12 +1627,15 @@ 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({ route: info.route, timeToReset: info.timeToReset }, "[DiscordAdapter] Rate limited");
+      log.warn(
+        { route: info.route, timeToReset: info.timeToReset },
+        "[DiscordAdapter] Rate limited"
+      );
       this.sendQueue.onRateLimited();
     });
   }
@@ -1592,13 +1644,18 @@ var DiscordAdapter = class extends ChannelAdapter {
     return new Promise((resolve, reject) => {
       this.client.once("ready", async () => {
         try {
-          log.info({ guildId: this.discordConfig.guildId }, "[DiscordAdapter] Client ready, initializing...");
+          log.info(
+            { guildId: this.discordConfig.guildId },
+            "[DiscordAdapter] Client ready, initializing..."
+          );
           const guild = this.client.guilds.cache.get(this.discordConfig.guildId) ?? await this.client.guilds.fetch(this.discordConfig.guildId).catch(() => null);
           if (!guild) {
             throw new Error(`Guild not found: ${this.discordConfig.guildId}`);
           }
           this.guild = guild;
-          const saveConfig = (updates) => this.core.configManager.save(updates);
+          const saveConfig = (updates) => this.core.configManager.save(
+            updates
+          );
           const { forumChannel, notificationChannel } = await ensureForums(
             guild,
             {
@@ -1609,7 +1666,10 @@ var DiscordAdapter = class extends ChannelAdapter {
           );
           this.forumChannel = forumChannel;
           this.notificationChannel = notificationChannel;
-          this.skillManager = new SkillCommandManager(this.sendQueue, this.core.sessionManager);
+          this.skillManager = new SkillCommandManager(
+            this.sendQueue,
+            this.core.sessionManager
+          );
           this.permissionHandler = new PermissionHandler(
             guild.id,
             (sessionId) => this.core.sessionManager.getSession(sessionId),
@@ -1622,7 +1682,10 @@ var DiscordAdapter = class extends ChannelAdapter {
           try {
             await this.notificationChannel.send(welcomeMsg);
           } catch (err) {
-            log.warn({ err }, "[DiscordAdapter] Failed to send welcome message");
+            log.warn(
+              { err },
+              "[DiscordAdapter] Failed to send welcome message"
+            );
           }
           await this.setupAssistant();
           log.info("[DiscordAdapter] Initialization complete");
@@ -1641,7 +1704,10 @@ var DiscordAdapter = class extends ChannelAdapter {
       try {
         await this.assistantSession.destroy();
       } catch (err) {
-        log.warn({ err }, "[DiscordAdapter] Failed to destroy assistant session");
+        log.warn(
+          { err },
+          "[DiscordAdapter] Failed to destroy assistant session"
+        );
       }
       this.assistantSession = null;
     }
@@ -1649,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);
@@ -1667,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) => {
@@ -1679,7 +1868,12 @@ var DiscordAdapter = class extends ChannelAdapter {
         const userId = message.author.id;
         let text = message.content;
         log.debug(
-          { threadId, userId, text: text.slice(0, 50), attachmentCount: message.attachments.size },
+          {
+            threadId,
+            userId,
+            text: text.slice(0, 50),
+            attachmentCount: message.attachments.size
+          },
           "[DiscordAdapter] messageCreate received"
         );
         if (!text && message.attachments.size === 0) return;
@@ -1698,7 +1892,10 @@ var DiscordAdapter = class extends ChannelAdapter {
             "[discord-media] Processing incoming attachments"
           );
         }
-        const attachments = await this.processIncomingAttachments(message, sessionId);
+        const attachments = await this.processIncomingAttachments(
+          message,
+          sessionId
+        );
         if (!text && attachments.length > 0) {
           text = buildFallbackText(attachments);
         }
@@ -1711,7 +1908,10 @@ var DiscordAdapter = class extends ChannelAdapter {
         }
         if (this.discordConfig.assistantThreadId && threadId === this.discordConfig.assistantThreadId) {
           if (this.assistantSession && text) {
-            await this.assistantSession.enqueuePrompt(text, attachments.length > 0 ? attachments : void 0);
+            await this.assistantSession.enqueuePrompt(
+              text,
+              attachments.length > 0 ? attachments : void 0
+            );
           }
           return;
         }
@@ -1734,14 +1934,25 @@ var DiscordAdapter = class extends ChannelAdapter {
       try {
         const existing = this.guild.channels.cache.get(threadId) ?? await this.guild.channels.fetch(threadId);
         if (existing && existing.isThread()) {
-          await ensureUnarchived(existing);
-          log.info({ threadId }, "[DiscordAdapter] Reusing existing assistant thread");
+          await ensureUnarchived(
+            existing
+          );
+          log.info(
+            { threadId },
+            "[DiscordAdapter] Reusing existing assistant thread"
+          );
         } else {
-          log.warn({ threadId }, "[DiscordAdapter] Assistant thread not found, recreating...");
+          log.warn(
+            { threadId },
+            "[DiscordAdapter] Assistant thread not found, recreating..."
+          );
           threadId = null;
         }
       } catch {
-        log.warn({ threadId }, "[DiscordAdapter] Assistant thread inaccessible, recreating...");
+        log.warn(
+          { threadId },
+          "[DiscordAdapter] Assistant thread inaccessible, recreating..."
+        );
         threadId = null;
       }
     }
@@ -1795,7 +2006,10 @@ var DiscordAdapter = class extends ChannelAdapter {
             fileName = "voice.wav";
             mimeType = "audio/wav";
           } catch (err) {
-            log.warn({ err }, "[discord-media] OGG\u2192WAV conversion failed, saving original");
+            log.warn(
+              { err },
+              "[discord-media] OGG\u2192WAV conversion failed, saving original"
+            );
           }
         }
         return this.fileService.saveFile(sessionId, fileName, data, mimeType);
@@ -1803,10 +2017,18 @@ var DiscordAdapter = class extends ChannelAdapter {
     );
     const rejected = results.filter((r) => r.status === "rejected");
     if (rejected.length > 0) {
-      log.warn({ rejected: rejected.map((r) => r.reason) }, "[discord-media] Some attachments failed");
+      log.warn(
+        { rejected: rejected.map((r) => r.reason) },
+        "[discord-media] Some attachments failed"
+      );
     }
-    const saved = results.filter((r) => r.status === "fulfilled").map((r) => r.value).filter((att) => att !== null);
-    log.info({ count: saved.length, files: saved.map((a) => a.fileName) }, "[discord-media] Attachments processed");
+    const saved = results.filter(
+      (r) => r.status === "fulfilled"
+    ).map((r) => r.value).filter((att) => att !== null);
+    log.info(
+      { count: saved.length, files: saved.map((a) => a.fileName) },
+      "[discord-media] Attachments processed"
+    );
     return saved;
   }
   // ─── Helper: resolve thread ───────────────────────────────────────────────
@@ -1820,181 +2042,270 @@ var DiscordAdapter = class extends ChannelAdapter {
     try {
       const channel = this.guild.channels.cache.get(threadId) ?? await this.guild.channels.fetch(threadId);
       if (channel && channel.isThread()) return channel;
-      log.warn({ sessionId, threadId }, "[DiscordAdapter] Channel is not a thread");
+      log.warn(
+        { sessionId, threadId },
+        "[DiscordAdapter] Channel is not a thread"
+      );
       return null;
     } catch (err) {
-      log.warn({ err, sessionId, threadId }, "[DiscordAdapter] Failed to fetch thread");
+      log.warn(
+        { err, sessionId, threadId },
+        "[DiscordAdapter] Failed to fetch thread"
+      );
       return null;
     }
   }
   // ─── Helper: get or create activity tracker ──────────────────────────────
   getOrCreateTracker(sessionId, thread) {
     if (!this.sessionTrackers.has(sessionId)) {
-      this.sessionTrackers.set(sessionId, new ActivityTracker(thread, this.sendQueue));
+      this.sessionTrackers.set(
+        sessionId,
+        new ActivityTracker(thread, this.sendQueue)
+      );
     }
     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, {
+  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
-      }, this.verbosity);
-    },
-    onToolUpdate: async (ctx, content) => {
-      const meta = content.metadata ?? {};
-      await this.toolTracker.updateCall(ctx.sessionId, {
+        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
-      }, this.verbosity);
-    },
-    onPlan: async (ctx, content) => {
-      const entries = content.metadata?.entries ?? [];
-      const tracker = this.getOrCreateTracker(ctx.sessionId, ctx.thread);
-      await tracker.onPlan(entries);
-    },
-    onUsage: async (ctx, content) => {
-      await this.draftManager.finalize(ctx.sessionId, ctx.thread, ctx.isAssistant);
-      const meta = content.metadata ?? {};
-      const tracker = this.getOrCreateTracker(ctx.sessionId, ctx.thread);
-      await tracker.sendUsage({
+        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
+        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
       });
-      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);
+    } 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" }
+      );
+    } 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" }
+      );
+    } 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(
+        {
+          sessionId,
+          fileName: attachment.fileName,
+          size: attachment.size
+        },
+        "[discord-media] File too large (>25MB)"
+      );
       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);
-      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(() => {
-            });
-          }
+      return;
+    }
+    try {
+      await this.sendQueue.enqueue(
+        () => thread.send({
+          files: [
+            { attachment: attachment.filePath, name: attachment.fileName }
+          ]
+        }),
+        { type: "other" }
+      );
+      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) {
     const session = this.core.sessionManager.getSession(sessionId);
     if (!session) {
-      log.warn({ sessionId }, "[DiscordAdapter] sendPermissionRequest: session not found");
+      log.warn(
+        { sessionId },
+        "[DiscordAdapter] sendPermissionRequest: session not found"
+      );
       return;
     }
     const thread = await this.getThread(sessionId);
     if (!thread) return;
-    await this.permissionHandler.sendPermissionRequest(session, request, thread);
+    await this.permissionHandler.sendPermissionRequest(
+      session,
+      request,
+      thread
+    );
   }
   // ─── sendNotification ─────────────────────────────────────────────────────
   async sendNotification(notification) {
@@ -2080,4 +2391,4 @@ ${notification.deepLink}`;
 export {
   DiscordAdapter
 };
-//# sourceMappingURL=discord-7IVQKB2H.js.map
+//# sourceMappingURL=adapter-77ZCVABT.js.map