@openacp/cli 0.6.10 → 2026.41.2

package/dist/discord-OMC52Y54.js

@@ -1,2239 +0,0 @@
-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";
-import {
-  handleCancel,
-  handleCleanupButton,
-  handleHandoff,
-  handleSessions,
-  handleStatus
-} from "./chunk-4CTX774K.js";
-import {
-  buildDeepLink,
-  createSessionThread,
-  deleteSessionThread,
-  ensureForums,
-  ensureUnarchived,
-  renameSessionThread
-} from "./chunk-BNLGTZ34.js";
-import {
-  handleAgentButton,
-  handleAgents,
-  handleInstall
-} from "./chunk-J4SJTKIK.js";
-import {
-  handleSettings,
-  handleSettingsButton
-} from "./chunk-O7CPGUAI.js";
-import {
-  handleDoctor,
-  handleDoctorButton
-} from "./chunk-2HMQOC7N.js";
-import {
-  PRODUCT_GUIDE,
-  dispatchMessage,
-  evaluateNoise,
-  extractContentText,
-  formatTokens,
-  formatToolSummary,
-  formatToolTitle,
-  progressBar,
-  resolveToolIcon,
-  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";
-import {
-  log
-} from "./chunk-GAK6PIBW.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/adapters/discord/formatting.ts
-function formatViewerLinks(links, filePath) {
-  if (!links) return "";
-  const fileName = filePath ? filePath.split("/").pop() || filePath : "";
-  let text = "\n";
-  if (links.file) text += `
-[View ${fileName || "file"}](${links.file})`;
-  if (links.diff)
-    text += `
-[View diff${fileName ? ` \u2014 ${fileName}` : ""}](${links.diff})`;
-  return text;
-}
-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(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, 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}",
-    completed: "\u2705"
-  };
-  const lines = entries.map(
-    (e, i) => `${statusIcon[e.status] || "\u2B1C"} ${i + 1}. ${e.content}`
-  );
-  return `**Plan:**
-${lines.join("\n")}`;
-}
-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}";
-  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 {
-  constructor(sendQueue) {
-    this.sendQueue = sendQueue;
-  }
-  sessions = /* @__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 content = formatToolCall(tool, verbosity);
-    try {
-      const msg = await this.sendQueue.enqueue(() => thread.send({ content }), {
-        type: "other"
-      });
-      if (msg) state.message = msg;
-    } catch (err) {
-      log.warn(
-        { err, toolId: tool.id },
-        "[ToolCallTracker] 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 isTerminal = update.status === "completed" || update.status === "failed";
-    if (!isTerminal) return;
-    await toolState.ready;
-    if (!toolState.message) return;
-    log.debug(
-      {
-        toolId: update.id,
-        status: update.status,
-        hasViewerLinks: !!toolState.viewerLinks,
-        name: toolState.name,
-        msgId: toolState.message.id
-      },
-      "[ToolCallTracker] Tool completed, preparing edit"
-    );
-    const merged = {
-      ...update,
-      name: toolState.name,
-      kind: toolState.kind,
-      rawInput: toolState.rawInput,
-      viewerLinks: toolState.viewerLinks,
-      viewerFilePath: toolState.viewerFilePath
-    };
-    const content = formatToolUpdate(merged, verbosity);
-    try {
-      await this.sendQueue.enqueue(() => toolState.message.edit({ content }), {
-        type: "other"
-      });
-    } catch (err) {
-      log.warn(
-        {
-          err,
-          msgId: toolState.message.id,
-          contentLen: content.length,
-          hasViewerLinks: !!merged.viewerLinks
-        },
-        "[ToolCallTracker] Tool update edit failed"
-      );
-    }
-  }
-  cleanup(sessionId) {
-    this.sessions.delete(sessionId);
-  }
-};
-
-// src/adapters/discord/streaming.ts
-var FLUSH_INTERVAL = 5e3;
-var MAX_DISPLAY_LENGTH = 1900;
-var MessageDraft = class {
-  constructor(thread, sendQueue, sessionId) {
-    this.thread = thread;
-    this.sendQueue = sendQueue;
-    this.sessionId = sessionId;
-  }
-  buffer = "";
-  message;
-  flushTimer;
-  flushPromise = Promise.resolve();
-  lastSentBuffer = "";
-  displayTruncated = false;
-  firstFlushPending = false;
-  append(text) {
-    if (!text) return;
-    this.buffer += text;
-    this.scheduleFlush();
-  }
-  getBuffer() {
-    return this.buffer;
-  }
-  scheduleFlush() {
-    if (this.flushTimer) return;
-    this.flushTimer = setTimeout(() => {
-      this.flushTimer = void 0;
-      this.flushPromise = this.flushPromise.then(() => this.flush()).catch(() => {
-      });
-    }, FLUSH_INTERVAL);
-  }
-  async flush() {
-    if (!this.buffer) return;
-    if (this.firstFlushPending) return;
-    const snapshot = this.buffer;
-    let content = snapshot;
-    let truncated = false;
-    if (content.length > MAX_DISPLAY_LENGTH) {
-      content = snapshot.slice(0, MAX_DISPLAY_LENGTH) + "\u2026";
-      truncated = true;
-    }
-    if (!content) return;
-    if (!this.message) {
-      this.firstFlushPending = true;
-      try {
-        const result = await this.sendQueue.enqueue(
-          () => this.thread.send({ content }),
-          { type: "other" }
-        );
-        if (result) {
-          this.message = result;
-          if (!truncated) {
-            this.lastSentBuffer = snapshot;
-            this.displayTruncated = false;
-          } else {
-            this.displayTruncated = true;
-          }
-        }
-      } catch {
-      } finally {
-        this.firstFlushPending = false;
-      }
-    } else {
-      if (!truncated && snapshot === this.lastSentBuffer) return;
-      try {
-        const result = await this.sendQueue.enqueue(
-          () => this.message.edit({ content }),
-          { type: "text", key: this.sessionId }
-        );
-        if (result !== void 0) {
-          if (!truncated) {
-            this.lastSentBuffer = snapshot;
-            this.displayTruncated = false;
-          } else {
-            this.displayTruncated = true;
-          }
-        }
-      } catch {
-      }
-    }
-  }
-  async stripPattern(pattern) {
-    if (!this.message || !this.buffer) return;
-    const stripped = this.buffer.replace(pattern, "").trim();
-    if (stripped === this.buffer.trim()) return;
-    this.buffer = stripped;
-    this.lastSentBuffer = stripped;
-    if (!stripped) return;
-    try {
-      await this.sendQueue.enqueue(
-        () => this.message.edit({ content: stripped }),
-        { type: "other" }
-      );
-    } catch {
-    }
-  }
-  async finalize() {
-    if (this.flushTimer) {
-      clearTimeout(this.flushTimer);
-      this.flushTimer = void 0;
-    }
-    await this.flushPromise;
-    if (!this.buffer) return;
-    if (this.message && this.buffer === this.lastSentBuffer && !this.displayTruncated) {
-      return;
-    }
-    if (this.buffer.length <= MAX_DISPLAY_LENGTH) {
-      const content = this.buffer;
-      try {
-        if (this.message) {
-          await this.sendQueue.enqueue(
-            () => this.message.edit({ content }),
-            { type: "other" }
-          );
-        } else {
-          await this.sendQueue.enqueue(
-            () => this.thread.send({ content }),
-            { type: "other" }
-          );
-        }
-        return;
-      } catch {
-      }
-    }
-    const chunks = splitMessage2(this.buffer, MAX_DISPLAY_LENGTH);
-    for (let i = 0; i < chunks.length; i++) {
-      const content = chunks[i];
-      try {
-        if (i === 0 && this.message) {
-          await this.sendQueue.enqueue(
-            () => this.message.edit({ content }),
-            { type: "other" }
-          );
-        } else {
-          const msg = await this.sendQueue.enqueue(
-            () => this.thread.send({ content }),
-            { type: "other" }
-          );
-          if (msg) {
-            this.message = msg;
-          }
-        }
-      } catch {
-      }
-    }
-  }
-};
-
-// src/adapters/discord/draft-manager.ts
-var DraftManager = class {
-  constructor(sendQueue) {
-    this.sendQueue = sendQueue;
-  }
-  drafts = /* @__PURE__ */ new Map();
-  textBuffers = /* @__PURE__ */ new Map();
-  getOrCreate(sessionId, thread) {
-    let draft = this.drafts.get(sessionId);
-    if (!draft) {
-      draft = new MessageDraft(thread, this.sendQueue, sessionId);
-      this.drafts.set(sessionId, draft);
-    }
-    return draft;
-  }
-  hasDraft(sessionId) {
-    return this.drafts.has(sessionId);
-  }
-  getDraft(sessionId) {
-    return this.drafts.get(sessionId);
-  }
-  appendText(sessionId, text) {
-    this.textBuffers.set(sessionId, (this.textBuffers.get(sessionId) ?? "") + text);
-  }
-  /**
-   * Finalize the current draft.
-   * If isAssistant is true, detects action patterns in the accumulated text and sends
-   * action buttons as a follow-up message.
-   */
-  async finalize(sessionId, thread, isAssistant) {
-    const draft = this.drafts.get(sessionId);
-    if (!draft) return;
-    this.drafts.delete(sessionId);
-    await draft.finalize();
-    if (isAssistant && thread) {
-      const fullText = this.textBuffers.get(sessionId);
-      this.textBuffers.delete(sessionId);
-      if (fullText) {
-        const detected = detectAction(fullText);
-        if (detected) {
-          const actionId = storeAction(detected);
-          const components = [buildActionKeyboard(actionId, detected)];
-          try {
-            await this.sendQueue.enqueue(
-              () => thread.send({ components }),
-              { type: "other" }
-            );
-          } catch {
-          }
-        }
-      }
-    } else {
-      this.textBuffers.delete(sessionId);
-    }
-  }
-  cleanup(sessionId) {
-    this.drafts.delete(sessionId);
-    this.textBuffers.delete(sessionId);
-  }
-};
-
-// src/adapters/discord/activity.ts
-import { EmbedBuilder } from "discord.js";
-var TYPING_REFRESH_MS = 8e3;
-var ThinkingIndicator = class {
-  constructor(channel) {
-    this.channel = channel;
-  }
-  dismissed = false;
-  refreshTimer;
-  async show() {
-    if (this.dismissed) return;
-    try {
-      await this.channel.sendTyping();
-      this.startRefreshTimer();
-    } catch (err) {
-      log.warn({ err }, "[ThinkingIndicator] sendTyping() failed");
-    }
-  }
-  dismiss() {
-    this.dismissed = true;
-    this.stopRefreshTimer();
-  }
-  reset() {
-    this.dismissed = false;
-  }
-  startRefreshTimer() {
-    this.stopRefreshTimer();
-    this.refreshTimer = setInterval(() => {
-      if (this.dismissed) {
-        this.stopRefreshTimer();
-        return;
-      }
-      this.channel.sendTyping().catch(() => {
-      });
-    }, TYPING_REFRESH_MS);
-  }
-  stopRefreshTimer() {
-    if (this.refreshTimer) {
-      clearInterval(this.refreshTimer);
-      this.refreshTimer = void 0;
-    }
-  }
-};
-var UsageMessage = class {
-  constructor(thread, sendQueue) {
-    this.thread = thread;
-    this.sendQueue = sendQueue;
-  }
-  message;
-  async send(usage, verbosity = "medium") {
-    const text = formatUsage(usage, verbosity);
-    const embed = new EmbedBuilder().setDescription(text);
-    try {
-      if (this.message) {
-        await this.sendQueue.enqueue(
-          () => this.message.edit({ embeds: [embed] }),
-          { type: "other" }
-        );
-      } else {
-        const result = await this.sendQueue.enqueue(
-          () => this.thread.send({ embeds: [embed] }),
-          { type: "other" }
-        );
-        if (result) this.message = result;
-      }
-    } catch (err) {
-      log.warn({ err }, "[UsageMessage] send() failed");
-    }
-  }
-  async delete() {
-    if (!this.message) return;
-    const msg = this.message;
-    this.message = void 0;
-    try {
-      await this.sendQueue.enqueue(() => msg.delete(), { type: "other" });
-    } catch (err) {
-      log.warn({ err }, "[UsageMessage] delete() failed");
-    }
-  }
-};
-var PLAN_DEBOUNCE_MS = 3500;
-var PlanCard = class {
-  constructor(thread, sendQueue) {
-    this.thread = thread;
-    this.sendQueue = sendQueue;
-  }
-  message;
-  flushPromise = Promise.resolve();
-  latestEntries;
-  lastSentText;
-  flushTimer;
-  verbosity = "medium";
-  setVerbosity(v) {
-    this.verbosity = v;
-  }
-  update(entries) {
-    this.latestEntries = entries;
-    if (this.flushTimer) clearTimeout(this.flushTimer);
-    this.flushTimer = setTimeout(() => {
-      this.flushTimer = void 0;
-      this.flushPromise = this.flushPromise.then(() => this._flush()).catch(() => {
-      });
-    }, PLAN_DEBOUNCE_MS);
-  }
-  async finalize() {
-    if (!this.latestEntries) return;
-    if (this.flushTimer) {
-      clearTimeout(this.flushTimer);
-      this.flushTimer = void 0;
-    }
-    await this.flushPromise;
-    this.flushPromise = this.flushPromise.then(() => this._flush()).catch(() => {
-    });
-    await this.flushPromise;
-  }
-  destroy() {
-    if (this.flushTimer) {
-      clearTimeout(this.flushTimer);
-      this.flushTimer = void 0;
-    }
-  }
-  async _flush() {
-    if (!this.latestEntries) return;
-    const text = formatPlan(this.latestEntries, this.verbosity);
-    if (this.message && text === this.lastSentText) return;
-    this.lastSentText = text;
-    const embed = new EmbedBuilder().setDescription(text);
-    try {
-      if (this.message) {
-        await this.sendQueue.enqueue(
-          () => this.message.edit({ embeds: [embed] }),
-          { type: "other" }
-        );
-      } else {
-        const result = await this.sendQueue.enqueue(
-          () => this.thread.send({ embeds: [embed] }),
-          { type: "other" }
-        );
-        if (result) this.message = result;
-      }
-    } catch (err) {
-      log.warn({ err }, "[PlanCard] flush failed");
-    }
-  }
-};
-var ActivityTracker = class {
-  constructor(thread, sendQueue) {
-    this.thread = thread;
-    this.sendQueue = sendQueue;
-    this.thinking = new ThinkingIndicator(thread);
-    this.planCard = new PlanCard(thread, sendQueue);
-    this.usage = new UsageMessage(thread, sendQueue);
-  }
-  isFirstEvent = true;
-  hasPlanCard = false;
-  thinking;
-  planCard;
-  usage;
-  async onNewPrompt() {
-    this.isFirstEvent = true;
-    this.hasPlanCard = false;
-    this.thinking.dismiss();
-    this.thinking.reset();
-  }
-  async onThought() {
-    await this._firstEventGuard();
-    await this.thinking.show();
-  }
-  async onTextStart() {
-    await this._firstEventGuard();
-    this.thinking.dismiss();
-  }
-  async onToolCall() {
-    await this._firstEventGuard();
-    this.thinking.dismiss();
-    this.thinking.reset();
-  }
-  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, verbosity = "medium") {
-    await this.usage.send(usage, verbosity);
-  }
-  async cleanup() {
-    this.thinking.dismiss();
-    this.planCard.destroy();
-    if (this.hasPlanCard) {
-      await this.planCard.finalize();
-    }
-  }
-  async _firstEventGuard() {
-    if (!this.isFirstEvent) return;
-    this.isFirstEvent = false;
-    await this.usage.delete();
-  }
-};
-
-// src/adapters/discord/skill-command-manager.ts
-var DISCORD_MSG_LIMIT = 1900;
-function buildSkillContent(commands) {
-  const sorted = [...commands].sort((a, b) => a.name.localeCompare(b.name));
-  const header = "**Available Skills**\n";
-  const lines = sorted.map((c) => `\`/${c.name}\``);
-  let content = header;
-  for (const line of lines) {
-    const candidate = content + "\n" + line;
-    if (candidate.length > DISCORD_MSG_LIMIT) break;
-    content = candidate;
-  }
-  return content;
-}
-var SkillCommandManager = class {
-  constructor(sendQueue, sessionManager) {
-    this.sendQueue = sendQueue;
-    this.sessionManager = sessionManager;
-  }
-  messages = /* @__PURE__ */ new Map();
-  async send(sessionId, thread, commands) {
-    if (!this.messages.has(sessionId)) {
-      const record = this.sessionManager.getSessionRecord(sessionId);
-      const platform = record?.platform;
-      if (platform?.skillMsgId) {
-        try {
-          const msg = await thread.messages.fetch(platform.skillMsgId);
-          if (msg) this.messages.set(sessionId, msg);
-        } catch {
-        }
-      }
-    }
-    if (commands.length === 0) {
-      await this.cleanup(sessionId);
-      return;
-    }
-    const content = buildSkillContent(commands);
-    const existingMsg = this.messages.get(sessionId);
-    if (existingMsg) {
-      try {
-        await existingMsg.edit({ content });
-        return;
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : "";
-        if (msg.includes("Unknown Message") || msg.includes("10008")) {
-          this.messages.delete(sessionId);
-        } else {
-          return;
-        }
-      }
-    }
-    try {
-      const msg = await this.sendQueue.enqueue(
-        () => thread.send({ content }),
-        { type: "other" }
-      );
-      if (!msg) return;
-      this.messages.set(sessionId, msg);
-      const record = this.sessionManager.getSessionRecord(sessionId);
-      if (record) {
-        await this.sessionManager.patchRecord(sessionId, {
-          platform: { ...record.platform, skillMsgId: msg.id }
-        });
-      }
-      try {
-        await msg.pin();
-      } catch (err) {
-        log.warn({ err, sessionId }, "[SkillCommandManager] Failed to pin skill message");
-      }
-    } catch (err) {
-      log.error({ err, sessionId }, "[SkillCommandManager] Failed to send skill commands");
-    }
-  }
-  async cleanup(sessionId) {
-    const msg = this.messages.get(sessionId);
-    this.messages.delete(sessionId);
-    if (msg) {
-      try {
-        await msg.edit({ content: "*Session ended*" });
-        await msg.unpin();
-      } catch {
-      }
-    }
-    const record = this.sessionManager.getSessionRecord(sessionId);
-    if (record) {
-      const platform = record.platform;
-      if (platform && typeof platform === "object" && "threadId" in platform) {
-        const { skillMsgId: _removed, ...rest } = platform;
-        await this.sessionManager.patchRecord(sessionId, { platform: rest });
-      }
-    }
-  }
-};
-
-// src/adapters/discord/permissions.ts
-import { ActionRowBuilder, ButtonBuilder, ButtonStyle } from "discord.js";
-import { nanoid } from "nanoid";
-var PermissionHandler = class {
-  constructor(guildId, getSession, sendNotification) {
-    this.guildId = guildId;
-    this.getSession = getSession;
-    this.sendNotification = sendNotification;
-  }
-  pending = /* @__PURE__ */ new Map();
-  async sendPermissionRequest(session, request, thread) {
-    const callbackKey = nanoid(8);
-    this.pending.set(callbackKey, {
-      sessionId: session.id,
-      requestId: request.id,
-      options: request.options.map((o) => ({ id: o.id, isAllow: o.isAllow })),
-      guildId: this.guildId,
-      channelId: thread.id
-    });
-    const row = new ActionRowBuilder();
-    for (const option of request.options) {
-      const emoji = option.isAllow ? "\u2705" : "\u274C";
-      row.addComponents(
-        new ButtonBuilder().setCustomId(`p:${callbackKey}:${option.id}`).setLabel(`${emoji} ${option.label}`).setStyle(option.isAllow ? ButtonStyle.Success : ButtonStyle.Danger)
-      );
-    }
-    let messageId;
-    try {
-      const msg = await thread.send({
-        content: `\u{1F510} **Permission request:**
-
-${request.description}`,
-        components: [row]
-      });
-      messageId = msg.id;
-      const pendingEntry = this.pending.get(callbackKey);
-      if (pendingEntry) pendingEntry.messageId = messageId;
-    } catch (err) {
-      log.warn({ err, sessionId: session.id }, "[PermissionHandler] Failed to send permission request");
-      return;
-    }
-    const deepLink = buildDeepLink(this.guildId, thread.id, messageId);
-    void this.sendNotification({
-      sessionId: session.id,
-      sessionName: session.name,
-      type: "permission",
-      summary: request.description,
-      deepLink
-    });
-  }
-  async handleButtonInteraction(interaction) {
-    const data = interaction.customId;
-    if (!data.startsWith("p:")) return false;
-    const parts = data.split(":");
-    if (parts.length < 3) return false;
-    const [, callbackKey, optionId] = parts;
-    const pending = this.pending.get(callbackKey);
-    if (!pending) {
-      try {
-        await interaction.reply({ content: "\u274C Permission request expired", ephemeral: true });
-      } catch {
-      }
-      return true;
-    }
-    const session = this.getSession(pending.sessionId);
-    const option = pending.options.find((o) => o.id === optionId);
-    const isAllow = option?.isAllow ?? false;
-    log.info(
-      { requestId: pending.requestId, optionId, isAllow },
-      "[PermissionHandler] Permission responded"
-    );
-    if (session?.permissionGate.requestId === pending.requestId) {
-      session.permissionGate.resolve(optionId);
-    }
-    this.pending.delete(callbackKey);
-    try {
-      await interaction.reply({ content: "\u2705 Responded", ephemeral: true });
-    } catch {
-    }
-    try {
-      await interaction.message.edit({ components: [] });
-    } catch {
-    }
-    return true;
-  }
-};
-
-// src/adapters/discord/commands/index.ts
-import { SlashCommandBuilder } from "discord.js";
-
-// src/adapters/discord/commands/menu.ts
-import {
-  ActionRowBuilder as ActionRowBuilder2,
-  ButtonBuilder as ButtonBuilder2,
-  ButtonStyle as ButtonStyle2
-} from "discord.js";
-function buildMenuKeyboard() {
-  const row1 = new ActionRowBuilder2().addComponents(
-    new ButtonBuilder2().setCustomId("m:new").setLabel("\u{1F195} New Session").setStyle(ButtonStyle2.Primary),
-    new ButtonBuilder2().setCustomId("m:sessions").setLabel("\u{1F4CB} Sessions").setStyle(ButtonStyle2.Secondary),
-    new ButtonBuilder2().setCustomId("m:status").setLabel("\u{1F4CA} Status").setStyle(ButtonStyle2.Secondary)
-  );
-  const row2 = new ActionRowBuilder2().addComponents(
-    new ButtonBuilder2().setCustomId("m:agents").setLabel("\u{1F916} Agents").setStyle(ButtonStyle2.Secondary),
-    new ButtonBuilder2().setCustomId("m:settings").setLabel("\u2699\uFE0F Settings").setStyle(ButtonStyle2.Secondary),
-    new ButtonBuilder2().setCustomId("m:integrate").setLabel("\u{1F517} Integrate").setStyle(ButtonStyle2.Secondary)
-  );
-  const row3 = new ActionRowBuilder2().addComponents(
-    new ButtonBuilder2().setCustomId("m:tts").setLabel("\u{1F50A} TTS").setStyle(ButtonStyle2.Secondary),
-    new ButtonBuilder2().setCustomId("m:restart").setLabel("\u{1F504} Restart").setStyle(ButtonStyle2.Secondary),
-    new ButtonBuilder2().setCustomId("m:update").setLabel("\u2B06\uFE0F Update").setStyle(ButtonStyle2.Secondary),
-    new ButtonBuilder2().setCustomId("m:help").setLabel("\u2753 Help").setStyle(ButtonStyle2.Secondary),
-    new ButtonBuilder2().setCustomId("m:doctor").setLabel("\u{1FA7A} Doctor").setStyle(ButtonStyle2.Secondary)
-  );
-  return [row1, row2, row3];
-}
-async function handleMenu(interaction, _adapter) {
-  await interaction.reply({
-    content: "**OpenACP Menu**\nChoose an action:",
-    components: buildMenuKeyboard(),
-    ephemeral: true
-  });
-}
-async function handleHelp(interaction, _adapter) {
-  await interaction.reply({
-    content: `\u{1F4D6} **OpenACP Help**
-
-\u{1F680} **Getting Started**
-Use \u{1F195} New Session or \`/new\` to start coding with AI.
-Each session gets its own forum thread \u2014 chat there to work with the agent.
-
-\u{1F4A1} **Common Commands**
-\`/new [agent] [workspace]\` \u2014 Create new session
-\`/newchat\` \u2014 New chat, same agent & workspace
-\`/cancel\` \u2014 Cancel current session
-\`/status\` \u2014 Show session or system status
-\`/sessions\` \u2014 List all sessions
-\`/agents\` \u2014 Browse & install agents
-\`/install <name>\` \u2014 Install an agent
-
-\u2699\uFE0F **System**
-\`/restart\` \u2014 Restart OpenACP
-\`/update\` \u2014 Update to latest version
-\`/integrate\` \u2014 Manage agent integrations
-\`/settings\` \u2014 View configuration
-\`/menu\` \u2014 Show action menu
-
-\u{1F512} **Session Options**
-\`/dangerous\` \u2014 Toggle dangerous mode (auto-approve permissions)
-\`/tts\` \u2014 Toggle Text to Speech (on/off/next message)
-\`/handoff\` \u2014 Continue session in your terminal
-\`/clear\` \u2014 Clear assistant session history
-
-\u{1FA7A} **Diagnostics**
-\`/doctor\` \u2014 Run system diagnostics`,
-    ephemeral: true
-  });
-}
-async function handleClear(interaction, adapter) {
-  await interaction.deferReply({ ephemeral: true });
-  if (!adapter.getAssistantSessionId()) {
-    await interaction.editReply("\u26A0\uFE0F Assistant is not available.");
-    return;
-  }
-  try {
-    await adapter.respawnAssistant();
-    await interaction.editReply("\u2705 Assistant history cleared.");
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    await interaction.editReply(`\u274C Failed to clear: \`${message}\``);
-  }
-}
-async function handleMenuButton(interaction, adapter) {
-  const { customId } = interaction;
-  try {
-    await interaction.deferUpdate();
-  } catch {
-  }
-  try {
-    switch (customId) {
-      case "m:new": {
-        const { handleNew: handleNew2 } = await import("./new-session-FEO4J4VU.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");
-        await showSessionsList(interaction, adapter);
-        break;
-      }
-      case "m:status": {
-        await showGlobalStatus(interaction, adapter);
-        break;
-      }
-      case "m:agents": {
-        const { showAgentsList } = await import("./agents-QO7DKARJ.js");
-        await showAgentsList(interaction, adapter);
-        break;
-      }
-      case "m:settings": {
-        const { showSettingsInfo } = await import("./settings-RQPAM4KC.js");
-        await showSettingsInfo(interaction, adapter);
-        break;
-      }
-      case "m:integrate": {
-        await interaction.followUp({ content: "Use `/integrate` to manage integrations.", ephemeral: true });
-        break;
-      }
-      case "m:restart": {
-        const { handleRestart: handleRestart2 } = await import("./admin-6SYB6XCZ.js");
-        if (!adapter.core.requestRestart) {
-          await interaction.followUp({ content: "\u26A0\uFE0F Restart not available.", ephemeral: true });
-        } else {
-          await interaction.followUp({ content: "\u{1F504} Restarting OpenACP...", ephemeral: true });
-          await new Promise((r) => setTimeout(r, 500));
-          await adapter.core.requestRestart();
-        }
-        break;
-      }
-      case "m:update": {
-        await interaction.followUp({ content: "\u26A0\uFE0F Update not implemented yet. Run `npm install -g @openacp/cli@latest` in your terminal.", ephemeral: true });
-        break;
-      }
-      case "m:help": {
-        await interaction.followUp({ content: "Use `/help` for command reference.", ephemeral: true });
-        break;
-      }
-      case "m:doctor": {
-        const { runDoctorInline } = await import("./doctor-OLYBO3V3.js");
-        await runDoctorInline(interaction, adapter);
-        break;
-      }
-      case "m:tts": {
-        const channelId = interaction.channelId;
-        const session = adapter.core.sessionManager.getSessionByThread("discord", channelId);
-        if (!session) {
-          await interaction.followUp({ content: "\u26A0\uFE0F No active session in this channel. Use `/tts` inside a session thread.", ephemeral: true });
-        } else {
-          const newMode = session.voiceMode === "on" ? "off" : "on";
-          session.setVoiceMode(newMode);
-          const msg = newMode === "on" ? "\u{1F50A} Text to Speech enabled for this session." : "\u{1F507} Text to Speech disabled.";
-          await interaction.followUp({ content: msg, ephemeral: true });
-        }
-        break;
-      }
-      default:
-        log.warn({ customId }, "[discord-menu] Unhandled menu button");
-    }
-  } catch (err) {
-    log.error({ err, customId }, "[discord-menu] Menu button handler failed");
-    try {
-      await interaction.followUp({ content: `\u274C Action failed: ${err instanceof Error ? err.message : String(err)}`, ephemeral: true });
-    } catch {
-    }
-  }
-}
-async function showGlobalStatus(interaction, adapter) {
-  const sessions = adapter.core.sessionManager.listSessions("discord");
-  const active = sessions.filter((s) => s.status === "active" || s.status === "initializing");
-  await interaction.followUp({
-    content: `**OpenACP Status**
-Active sessions: ${active.length}
-Total sessions: ${sessions.length}`,
-    ephemeral: true
-  });
-}
-async function showSessionsList(interaction, adapter) {
-  const allRecords = adapter.core.sessionManager.listRecords();
-  if (allRecords.length === 0) {
-    await interaction.followUp({ content: "No sessions found.", ephemeral: true });
-    return;
-  }
-  const STATUS_EMOJI = {
-    active: "\u{1F7E2}",
-    initializing: "\u{1F7E1}",
-    finished: "\u2705",
-    error: "\u274C",
-    cancelled: "\u26D4"
-  };
-  const STATUS_ORDER = {
-    active: 0,
-    initializing: 1,
-    error: 2,
-    finished: 3,
-    cancelled: 4
-  };
-  allRecords.sort(
-    (a, b) => (STATUS_ORDER[a.status] ?? 5) - (STATUS_ORDER[b.status] ?? 5)
-  );
-  const lines = allRecords.slice(0, 20).map((r) => {
-    const emoji = STATUS_EMOJI[r.status] || "\u26AA";
-    const name = r.name?.trim() || `${r.agentName} session`;
-    return `${emoji} **${name}** \`[${r.status}]\``;
-  });
-  const truncated = allRecords.length > 20 ? `
-
-*...and ${allRecords.length - 20} more*` : "";
-  await interaction.followUp({
-    content: `**Sessions: ${allRecords.length}**
-
-${lines.join("\n")}${truncated}`,
-    ephemeral: true
-  });
-}
-
-// src/adapters/discord/commands/integrate.ts
-async function handleIntegrate(interaction, _adapter) {
-  await interaction.deferReply({ ephemeral: true });
-  await interaction.editReply(
-    "\u{1F517} **Integrations**\n\nIntegration management via Discord is not yet implemented.\n\nUse the CLI: `openacp integrate`"
-  );
-}
-async function handleIntegrateButton(interaction, _adapter) {
-  log.debug({ customId: interaction.customId }, "[discord-integrate] Button stub called");
-  try {
-    await interaction.reply({
-      content: "\u{1F517} Integration management via Discord is not yet implemented. Use the CLI: `openacp integrate`",
-      ephemeral: true
-    });
-  } catch {
-  }
-}
-
-// src/adapters/discord/commands/router.ts
-async function handleSlashCommand(interaction, adapter) {
-  const { commandName } = interaction;
-  try {
-    switch (commandName) {
-      case "new":
-        await handleNew(interaction, adapter);
-        break;
-      case "newchat":
-        await handleNewChat(interaction, adapter);
-        break;
-      case "cancel":
-        await handleCancel(interaction, adapter);
-        break;
-      case "status":
-        await handleStatus(interaction, adapter);
-        break;
-      case "sessions":
-        await handleSessions(interaction, adapter);
-        break;
-      case "agents":
-        await handleAgents(interaction, adapter);
-        break;
-      case "install":
-        await handleInstall(interaction, adapter);
-        break;
-      case "menu":
-        await handleMenu(interaction, adapter);
-        break;
-      case "help":
-        await handleHelp(interaction, adapter);
-        break;
-      case "dangerous":
-        await handleDangerous(interaction, adapter);
-        break;
-      case "restart":
-        await handleRestart(interaction, adapter);
-        break;
-      case "update":
-        await handleUpdate(interaction, adapter);
-        break;
-      case "integrate":
-        await handleIntegrate(interaction, adapter);
-        break;
-      case "settings":
-        await handleSettings(interaction, adapter);
-        break;
-      case "doctor":
-        await handleDoctor(interaction, adapter);
-        break;
-      case "handoff":
-        await handleHandoff(interaction, adapter);
-        break;
-      case "clear":
-        await handleClear(interaction, adapter);
-        break;
-      case "tts":
-        await handleTTS(interaction, adapter);
-        break;
-      case "verbosity":
-        await handleVerbosity(interaction, adapter);
-        break;
-      default:
-        log.warn({ commandName }, "[discord-router] Unknown slash command");
-        if (!interaction.replied && !interaction.deferred) {
-          await interaction.reply({
-            content: `Unknown command: /${commandName}`,
-            ephemeral: true
-          });
-        }
-    }
-  } catch (err) {
-    log.error(
-      { err, commandName },
-      "[discord-router] Slash command handler failed"
-    );
-    try {
-      const errMsg = `\u274C Command failed: ${err instanceof Error ? err.message : String(err)}`;
-      if (interaction.deferred) {
-        await interaction.editReply(errMsg);
-      } else if (!interaction.replied) {
-        await interaction.reply({ content: errMsg, ephemeral: true });
-      }
-    } catch {
-    }
-  }
-}
-async function setupButtonCallbacks(interaction, adapter) {
-  const { customId } = interaction;
-  try {
-    if (customId.startsWith("a:dismiss:")) {
-      try {
-        await interaction.update({ components: [] });
-      } catch {
-      }
-      return;
-    }
-    if (customId.startsWith("a:")) {
-      const { getAction, removeAction } = await import("./action-detect-P7ZE4NEM.js");
-      const actionId = customId.slice(2);
-      const action = getAction(actionId);
-      if (!action) {
-        await interaction.reply({
-          content: "\u274C Action expired.",
-          ephemeral: true
-        });
-        return;
-      }
-      removeAction(actionId);
-      if (action.type === "new_session") {
-        await executeNewSession(
-          interaction,
-          adapter,
-          action.agent,
-          action.workspace
-        );
-      } else if (action.type === "cancel_session") {
-        await executeCancelSession(interaction, adapter);
-      }
-      return;
-    }
-    if (customId.startsWith("d:")) {
-      await handleDangerousButton(interaction, adapter);
-      return;
-    }
-    if (customId.startsWith("v:")) {
-      await handleTTSButton(interaction, adapter);
-      return;
-    }
-    if (customId.startsWith("m:new:")) {
-      await handleNewSessionButton(interaction, adapter);
-      return;
-    }
-    if (customId === "m:cleanup" || customId.startsWith("m:cleanup:")) {
-      await handleCleanupButton(interaction, adapter);
-      return;
-    }
-    if (customId === "m:doctor" || customId.startsWith("m:doctor:")) {
-      await handleDoctorButton(interaction, adapter);
-      return;
-    }
-    if (customId.startsWith("ag:")) {
-      await handleAgentButton(interaction, adapter);
-      return;
-    }
-    if (customId.startsWith("na:")) {
-      const agentKey = customId.slice(3);
-      try {
-        await interaction.deferReply({ ephemeral: true });
-      } catch {
-      }
-      await executeNewSession(interaction, adapter, agentKey, void 0);
-      return;
-    }
-    if (customId.startsWith("s:")) {
-      await handleSettingsButton(interaction, adapter);
-      return;
-    }
-    if (customId.startsWith("i:")) {
-      await handleIntegrateButton(interaction, adapter);
-      return;
-    }
-    if (customId.startsWith("m:")) {
-      await handleMenuButton(interaction, adapter);
-      return;
-    }
-    log.warn({ customId }, "[discord-router] Unhandled button interaction");
-  } catch (err) {
-    log.error({ err, customId }, "[discord-router] Button callback failed");
-    try {
-      const errMsg = `\u274C Action failed: ${err instanceof Error ? err.message : String(err)}`;
-      if (!interaction.replied && !interaction.deferred) {
-        await interaction.reply({ content: errMsg, ephemeral: true });
-      } else {
-        await interaction.followUp({ content: errMsg, ephemeral: true });
-      }
-    } catch {
-    }
-  }
-}
-async function executeNewSession(interaction, adapter, agentName, workspace) {
-  const { executeNewSession: doExecute } = await import("./new-session-FEO4J4VU.js");
-  await doExecute(interaction, adapter, agentName, workspace);
-}
-async function executeCancelSession(interaction, adapter) {
-  const { executeCancelSession: doCancel } = await import("./session-IUSI7P5S.js");
-  await doCancel(interaction, adapter);
-}
-
-// src/adapters/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)
-  ).addStringOption(
-    (o) => o.setName("workspace").setDescription("Workspace directory").setRequired(false)
-  ),
-  new SlashCommandBuilder().setName("newchat").setDescription(
-    "New chat in current thread, inheriting agent and workspace"
-  ),
-  new SlashCommandBuilder().setName("cancel").setDescription("Cancel the current session"),
-  new SlashCommandBuilder().setName("status").setDescription("Show session or global status"),
-  new SlashCommandBuilder().setName("sessions").setDescription("List all sessions"),
-  new SlashCommandBuilder().setName("agents").setDescription("List available agents"),
-  new SlashCommandBuilder().setName("install").setDescription("Install an agent by name").addStringOption(
-    (o) => o.setName("name").setDescription("Agent name to install").setRequired(true)
-  ),
-  new SlashCommandBuilder().setName("menu").setDescription("Show the action menu"),
-  new SlashCommandBuilder().setName("help").setDescription("Show help"),
-  new SlashCommandBuilder().setName("dangerous").setDescription("Toggle dangerous mode for the current session"),
-  new SlashCommandBuilder().setName("restart").setDescription("Restart OpenACP"),
-  new SlashCommandBuilder().setName("update").setDescription("Update to the latest version"),
-  new SlashCommandBuilder().setName("integrate").setDescription("Manage agent integrations"),
-  new SlashCommandBuilder().setName("settings").setDescription("Show configuration settings"),
-  new SlashCommandBuilder().setName("doctor").setDescription("Run system diagnostics"),
-  new SlashCommandBuilder().setName("handoff").setDescription("Generate a terminal resume command for this session"),
-  new SlashCommandBuilder().setName("clear").setDescription("Reset the assistant session"),
-  new SlashCommandBuilder().setName("tts").setDescription("Toggle Text to Speech for the current session").addStringOption(
-    (o) => o.setName("mode").setDescription(
-      "on = persistent, off = disable, empty = next message only"
-    ).setRequired(false).addChoices({ name: "on", value: "on" }, { name: "off", value: "off" })
-  ),
-  new SlashCommandBuilder().setName("verbosity").setDescription("Set display verbosity level").addStringOption(
-    (o) => o.setName("level").setDescription("Verbosity level").setRequired(true).addChoices(
-      { name: "low \u2014 minimal, title only", value: "low" },
-      { name: "medium \u2014 balanced (default)", value: "medium" },
-      { name: "high \u2014 full detail with content", value: "high" }
-    )
-  )
-];
-async function registerSlashCommands(guild) {
-  await guild.commands.set(SLASH_COMMANDS.map((cmd) => cmd.toJSON()));
-}
-
-// src/adapters/discord/assistant.ts
-async function spawnAssistant(core, threadId) {
-  const config = core.configManager.get();
-  log.info({ agent: config.defaultAgent, threadId }, "[discord-assistant] Creating assistant session...");
-  const session = await core.createSession({
-    channelId: "discord",
-    agentName: config.defaultAgent,
-    workingDirectory: core.configManager.resolveWorkspace(),
-    initialName: "Assistant"
-    // Prevent auto-naming from triggering after system prompt
-  });
-  session.threadId = threadId;
-  log.info({ sessionId: session.id, threadId }, "[discord-assistant] Assistant agent spawned");
-  const systemPrompt = buildAssistantSystemPrompt(core);
-  const ready = session.enqueuePrompt(systemPrompt).then(() => {
-    log.info({ sessionId: session.id }, "[discord-assistant] System prompt completed");
-  }).catch((err) => {
-    log.warn({ err }, "[discord-assistant] System prompt failed");
-  });
-  return { session, ready };
-}
-function buildWelcomeMessage(core) {
-  const allRecords = core.sessionManager.listRecords();
-  const activeCount = allRecords.filter(
-    (r) => r.status === "active" || r.status === "initializing"
-  ).length;
-  const errorCount = allRecords.filter((r) => r.status === "error").length;
-  const totalCount = allRecords.length;
-  const installedEntries = core.agentCatalog.getInstalledEntries();
-  const agents = Object.keys(installedEntries);
-  const config = core.configManager.get();
-  const defaultAgent = config.defaultAgent;
-  const agentList = agents.map((a) => `${a}${a === defaultAgent ? " (default)" : ""}`).join(", ");
-  if (totalCount === 0) {
-    return `\u{1F44B} **OpenACP is ready!**
-
-No sessions yet. Use \`/new\` to start, or ask me anything!
-
-Agents: ${agentList}`;
-  }
-  if (errorCount > 0) {
-    return `\u{1F44B} **OpenACP is ready!**
-
-\u{1F4CA} ${activeCount} active, ${errorCount} errors / ${totalCount} total
-\u26A0\uFE0F ${errorCount} session${errorCount > 1 ? "s have" : " has"} errors \u2014 ask me to check.
-
-Agents: ${agentList}`;
-  }
-  return `\u{1F44B} **OpenACP is ready!**
-
-\u{1F4CA} ${activeCount} active / ${totalCount} total
-Agents: ${agentList}`;
-}
-function buildAssistantSystemPrompt(core) {
-  const config = core.configManager.get();
-  const allRecords = core.sessionManager.listRecords();
-  const activeCount = allRecords.filter(
-    (r) => r.status === "active" || r.status === "initializing"
-  ).length;
-  const statusCounts = /* @__PURE__ */ new Map();
-  for (const r of allRecords) {
-    statusCounts.set(r.status, (statusCounts.get(r.status) ?? 0) + 1);
-  }
-  const topicBreakdown = Array.from(statusCounts.entries()).map(([status, count]) => `${status}: ${count}`).join(", ") || "none";
-  const installedEntries = core.agentCatalog.getInstalledEntries();
-  const installedAgents = Object.keys(installedEntries);
-  const agentNames = installedAgents.length ? installedAgents.join(", ") : Object.keys(config.agents).join(", ");
-  const availableItems = core.agentCatalog.getAvailable();
-  const availableAgentCount = availableItems.filter((i) => !i.installed).length;
-  return `You are the OpenACP Assistant \u2014 a helpful guide for managing AI coding sessions on Discord.
-
-## Current State
-- Active sessions: ${activeCount} / ${allRecords.length} total
-- Sessions by status: ${topicBreakdown}
-- Installed agents: ${agentNames}
-- Available in ACP Registry: ${availableAgentCount} more agents (use \`/agents\` to browse)
-- Default agent: ${config.defaultAgent}
-- Workspace base directory: ${config.workspace.baseDir}
-- Platform: Discord
-
-## Discord Context
-- Each session gets its own forum thread in the OpenACP sessions channel
-- Users interact with sessions by chatting in those threads
-- Slash commands: /new, /cancel, /status, /sessions, /agents, /install, /menu, /help, /dangerous, /restart, /update, /integrate, /settings, /doctor, /handoff, /clear
-
-## Action Playbook
-
-### Create Session
-- The workspace is the project directory where the agent will work (read, write, execute code). It should be a specific project folder like \`~/code/my-project\` or \`${config.workspace.baseDir}/my-app\`.
-- Ask which agent to use (if multiple are installed). Installed: ${agentNames}
-- Ask which project directory to use as workspace. Suggest \`${config.workspace.baseDir}\` as the base.
-- Create via: \`openacp api new <agent> <workspace>\`
-
-### Browse & Install Agents
-- Guide users to \`/agents\` command to see all available agents
-- For CLI users: \`openacp agents install <name>\`
-- Some agents need login/setup after install \u2014 guide users to \`openacp agents info <name>\`
-- To run agent CLI for login: \`openacp agents run <name> -- <args>\`
-
-### Check Status / List Sessions
-- Run \`openacp api status\` for active sessions overview
-- Run \`openacp api topics\` for full list with statuses
-
-### Cancel Session
-- Run \`openacp api status\` to see what's active
-- If 1 active session \u2192 ask user to confirm \u2192 \`openacp api cancel <id>\`
-- If multiple \u2192 list them, ask user which one to cancel
-
-### Troubleshoot
-- Run \`openacp api health\` + \`openacp api status\` to diagnose
-- Small issue (stuck session) \u2192 suggest cancel + create new
-- Big issue (system-level) \u2192 suggest restart, ask for confirmation first
-
-### Cleanup Old Sessions
-- Run \`openacp api topics --status finished,error\` to see what can be cleaned
-- Report the count, ask user to confirm
-- Execute: \`openacp api cleanup --status <statuses>\`
-
-### Configuration
-- View: \`openacp config\`
-- Update: \`openacp config set <key> <value>\`
-
-### Restart / Update
-- Always ask for confirmation \u2014 these are disruptive actions
-
-### Toggle Dangerous Mode
-- Run \`openacp api dangerous <id> on|off\`
-- Explain: dangerous mode auto-approves all permission requests
-
-## CLI Commands Reference
-\`\`\`bash
-# Session management
-openacp api status                       # List active sessions
-openacp api session <id>                 # Session detail
-openacp api new <agent> <workspace>      # Create new session
-openacp api send <id> "prompt text"      # Send prompt to session
-openacp api cancel <id>                  # Cancel session
-openacp api dangerous <id> on|off        # Toggle dangerous mode
-
-# Topic management
-openacp api topics                       # List all topics
-openacp api cleanup                      # Cleanup finished topics
-
-# Agent management
-openacp agents                           # List installed + available agents
-openacp agents install <name>            # Install agent from ACP Registry
-openacp agents uninstall <name>          # Remove agent
-openacp agents info <name>               # Show details & setup guide
-openacp agents run <name> -- <args>      # Run agent CLI (for login, etc.)
-
-# System
-openacp api health                       # System health
-openacp config                           # Edit config (interactive)
-openacp config set <key> <value>         # Update config value
-openacp api restart                      # Restart daemon
-\`\`\`
-
-## Guidelines
-- NEVER show \`openacp api ...\` commands to users. These are internal tools for YOU to run silently.
-- Run \`openacp api ...\` commands yourself for everything you can. Only guide users to Discord slash commands/buttons when needed.
-- When creating sessions: guide user through agent + workspace choice conversationally, then run the command yourself.
-- Destructive actions (cancel active session, restart, cleanup) \u2192 always ask user to confirm first.
-- Respond in the same language the user uses.
-- Format responses for Discord: use **bold**, \`code\`, keep it concise.
-- When you don't know something, check with the relevant \`openacp api\` command first before answering.
-
-## Product Reference
-${PRODUCT_GUIDE}`;
-}
-
-// src/adapters/discord/media.ts
-var MAX_DOWNLOAD_SIZE = 100 * 1024 * 1024;
-var DISCORD_UPLOAD_LIMIT = 25 * 1024 * 1024;
-function isAttachmentTooLarge(size) {
-  return size > DISCORD_UPLOAD_LIMIT;
-}
-function buildFallbackText(attachments) {
-  return attachments.map((att) => {
-    const label = att.type === "image" ? "Photo" : att.type === "audio" ? "Audio" : "File";
-    return `[${label}: ${att.fileName}]`;
-  }).join(" ");
-}
-async function downloadDiscordAttachment(url, fileName) {
-  try {
-    const response = await fetch(url);
-    if (!response.ok) {
-      log.warn({ url, status: response.status, fileName }, "[discord-media] Download failed");
-      return null;
-    }
-    const buffer = Buffer.from(await response.arrayBuffer());
-    if (buffer.length > MAX_DOWNLOAD_SIZE) {
-      log.warn({ fileName, size: buffer.length }, "[discord-media] File exceeds download size cap");
-      return null;
-    }
-    return buffer;
-  } catch (err) {
-    log.error({ err, url, fileName }, "[discord-media] Download error");
-    return null;
-  }
-}
-
-// src/adapters/discord/adapter.ts
-var DiscordAdapter = class extends ChannelAdapter {
-  client;
-  discordConfig;
-  sendQueue;
-  toolTracker;
-  draftManager;
-  skillManager;
-  permissionHandler;
-  sessionTrackers = /* @__PURE__ */ new Map();
-  get verbosity() {
-    return this.discordConfig.displayVerbosity ?? "medium";
-  }
-  guild;
-  forumChannel;
-  notificationChannel;
-  assistantSession = null;
-  assistantInitializing = false;
-  fileService;
-  constructor(core, config) {
-    super(core, config);
-    this.discordConfig = config;
-    this.client = new Client({
-      intents: [
-        GatewayIntentBits.Guilds,
-        GatewayIntentBits.GuildMessages,
-        GatewayIntentBits.MessageContent
-      ]
-    });
-    this.sendQueue = new DiscordSendQueue();
-    this.toolTracker = new ToolCallTracker(this.sendQueue);
-    this.draftManager = new DraftManager(this.sendQueue);
-    this.fileService = core.fileService;
-    this.client.rest.on("rateLimited", (info) => {
-      log.warn(
-        { route: info.route, timeToReset: info.timeToReset },
-        "[DiscordAdapter] Rate limited"
-      );
-      this.sendQueue.onRateLimited();
-    });
-  }
-  // ─── start ────────────────────────────────────────────────────────────────
-  start() {
-    return new Promise((resolve, reject) => {
-      this.client.once("ready", async () => {
-        try {
-          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 { forumChannel, notificationChannel } = await ensureForums(
-            guild,
-            {
-              forumChannelId: this.discordConfig.forumChannelId,
-              notificationChannelId: this.discordConfig.notificationChannelId
-            },
-            saveConfig
-          );
-          this.forumChannel = forumChannel;
-          this.notificationChannel = notificationChannel;
-          this.skillManager = new SkillCommandManager(
-            this.sendQueue,
-            this.core.sessionManager
-          );
-          this.permissionHandler = new PermissionHandler(
-            guild.id,
-            (sessionId) => this.core.sessionManager.getSession(sessionId),
-            (notification) => this.sendNotification(notification)
-          );
-          await registerSlashCommands(guild);
-          this.setupInteractionHandler();
-          this.setupMessageHandler();
-          const welcomeMsg = buildWelcomeMessage(this.core);
-          try {
-            await this.notificationChannel.send(welcomeMsg);
-          } catch (err) {
-            log.warn(
-              { err },
-              "[DiscordAdapter] Failed to send welcome message"
-            );
-          }
-          await this.setupAssistant();
-          log.info("[DiscordAdapter] Initialization complete");
-          resolve();
-        } catch (err) {
-          log.error({ err }, "[DiscordAdapter] Initialization failed");
-          reject(err);
-        }
-      });
-      this.client.login(this.discordConfig.botToken).catch(reject);
-    });
-  }
-  // ─── stop ─────────────────────────────────────────────────────────────────
-  async stop() {
-    if (this.assistantSession) {
-      try {
-        await this.assistantSession.destroy();
-      } catch (err) {
-        log.warn(
-          { err },
-          "[DiscordAdapter] Failed to destroy assistant session"
-        );
-      }
-      this.assistantSession = null;
-    }
-    this.client.destroy();
-    log.info("[DiscordAdapter] Stopped");
-  }
-  // ─── Interaction handler ──────────────────────────────────────────────────
-  setupInteractionHandler() {
-    this.client.on("interactionCreate", async (interaction) => {
-      try {
-        if (interaction.isChatInputCommand()) {
-          await handleSlashCommand(interaction, this);
-          return;
-        }
-        if (interaction.isButton()) {
-          const handled = await this.permissionHandler.handleButtonInteraction(interaction);
-          if (!handled) {
-            await setupButtonCallbacks(interaction, this);
-          }
-        }
-      } catch (err) {
-        log.error({ err }, "[DiscordAdapter] interactionCreate handler error");
-      }
-    });
-  }
-  // ─── Message handler ──────────────────────────────────────────────────────
-  setupMessageHandler() {
-    this.client.on("messageCreate", async (message) => {
-      try {
-        if (message.author.bot) return;
-        if (!message.guild) return;
-        if (message.guild.id !== this.guild.id) return;
-        if (!message.channel.isThread()) return;
-        const threadId = message.channel.id;
-        const userId = message.author.id;
-        let text = message.content;
-        log.debug(
-          {
-            threadId,
-            userId,
-            text: text.slice(0, 50),
-            attachmentCount: message.attachments.size
-          },
-          "[DiscordAdapter] messageCreate received"
-        );
-        if (!text && message.attachments.size === 0) return;
-        const sessionId = this.core.sessionManager.getSessionByThread("discord", threadId)?.id ?? "unknown";
-        if (message.attachments.size > 0) {
-          log.info(
-            {
-              sessionId,
-              attachments: message.attachments.map((a) => ({
-                name: a.name,
-                size: a.size,
-                contentType: a.contentType,
-                url: a.url?.slice(0, 80)
-              }))
-            },
-            "[discord-media] Processing incoming attachments"
-          );
-        }
-        const attachments = await this.processIncomingAttachments(
-          message,
-          sessionId
-        );
-        if (!text && attachments.length > 0) {
-          text = buildFallbackText(attachments);
-        }
-        if (!text && attachments.length === 0 && message.attachments.size > 0) {
-          try {
-            await message.reply("Failed to process attachment(s)");
-          } catch {
-          }
-          return;
-        }
-        if (this.discordConfig.assistantThreadId && threadId === this.discordConfig.assistantThreadId) {
-          if (this.assistantSession && text) {
-            await this.assistantSession.enqueuePrompt(
-              text,
-              attachments.length > 0 ? attachments : void 0
-            );
-          }
-          return;
-        }
-        await this.core.handleMessage({
-          channelId: "discord",
-          threadId,
-          userId,
-          text,
-          ...attachments.length > 0 ? { attachments } : {}
-        });
-      } catch (err) {
-        log.error({ err }, "[DiscordAdapter] messageCreate handler error");
-      }
-    });
-  }
-  // ─── Assistant ────────────────────────────────────────────────────────────
-  async setupAssistant() {
-    let threadId = this.discordConfig.assistantThreadId;
-    if (threadId) {
-      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"
-          );
-        } else {
-          log.warn(
-            { threadId },
-            "[DiscordAdapter] Assistant thread not found, recreating..."
-          );
-          threadId = null;
-        }
-      } catch {
-        log.warn(
-          { threadId },
-          "[DiscordAdapter] Assistant thread inaccessible, recreating..."
-        );
-        threadId = null;
-      }
-    }
-    if (!threadId) {
-      const thread = await createSessionThread(this.forumChannel, "Assistant");
-      threadId = thread.id;
-      await this.core.configManager.save({
-        channels: { discord: { assistantThreadId: thread.id } }
-      });
-      log.info({ threadId }, "[DiscordAdapter] Created assistant thread");
-    }
-    this.assistantInitializing = true;
-    try {
-      const { session, ready } = await spawnAssistant(this.core, threadId);
-      this.assistantSession = session;
-      ready.finally(() => {
-        this.assistantInitializing = false;
-      });
-    } catch (err) {
-      this.assistantInitializing = false;
-      log.error({ err }, "[DiscordAdapter] Failed to spawn assistant");
-    }
-  }
-  async respawnAssistant() {
-    if (this.assistantSession) {
-      try {
-        await this.assistantSession.destroy();
-      } catch {
-      }
-      this.assistantSession = null;
-    }
-    await this.setupAssistant();
-  }
-  // ─── Incoming media ──────────────────────────────────────────────────
-  async processIncomingAttachments(message, sessionId) {
-    if (message.attachments.size === 0) return [];
-    const isVoiceMessage = message.flags.has(MessageFlags.IsVoiceMessage);
-    const results = await Promise.allSettled(
-      message.attachments.map(async (discordAtt) => {
-        const buffer = await downloadDiscordAttachment(
-          discordAtt.url,
-          discordAtt.name ?? "attachment"
-        );
-        if (!buffer) return null;
-        let data = buffer;
-        let fileName = discordAtt.name ?? "attachment";
-        let mimeType = discordAtt.contentType ?? "application/octet-stream";
-        if (isVoiceMessage && mimeType.includes("ogg")) {
-          try {
-            data = await this.fileService.convertOggToWav(buffer);
-            fileName = "voice.wav";
-            mimeType = "audio/wav";
-          } catch (err) {
-            log.warn(
-              { err },
-              "[discord-media] OGG\u2192WAV conversion failed, saving original"
-            );
-          }
-        }
-        return this.fileService.saveFile(sessionId, fileName, data, mimeType);
-      })
-    );
-    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"
-      );
-    }
-    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 ───────────────────────────────────────────────
-  async getThread(sessionId) {
-    const session = this.core.sessionManager.getSession(sessionId);
-    const threadId = session?.threadId;
-    if (!threadId) {
-      log.warn({ sessionId }, "[DiscordAdapter] No threadId for session");
-      return null;
-    }
-    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"
-      );
-      return null;
-    } catch (err) {
-      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)
-      );
-    }
-    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
-      );
-    },
-    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
-      );
-      const meta = content.metadata ?? {};
-      const tracker = this.getOrCreateTracker(ctx.sessionId, ctx.thread);
-      await tracker.sendUsage(
-        {
-          tokensUsed: meta.tokensUsed,
-          contextSize: meta.contextSize,
-          cost: meta.cost
-        },
-        this.verbosity
-      );
-      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}` }),
-          { 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(() => {
-            });
-          }
-        }
-      } 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 {
-      }
-    }
-  };
-  // ─── 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);
-    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"
-      );
-      return;
-    }
-    const thread = await this.getThread(sessionId);
-    if (!thread) return;
-    await this.permissionHandler.sendPermissionRequest(
-      session,
-      request,
-      thread
-    );
-  }
-  // ─── sendNotification ─────────────────────────────────────────────────────
-  async sendNotification(notification) {
-    if (!this.notificationChannel) return;
-    const typeIcon = {
-      completed: "\u2705",
-      error: "\u274C",
-      permission: "\u{1F510}",
-      input_required: "\u{1F4AC}"
-    };
-    const icon = typeIcon[notification.type] ?? "\u2139\uFE0F";
-    const name = notification.sessionName ? ` **${notification.sessionName}**` : "";
-    let text = `${icon}${name}: ${notification.summary}`;
-    if (notification.deepLink) {
-      text += `
-${notification.deepLink}`;
-    }
-    try {
-      await this.sendQueue.enqueue(
-        () => this.notificationChannel.send({ content: text }),
-        { type: "other" }
-      );
-    } catch (err) {
-      log.warn({ err }, "[DiscordAdapter] Failed to send notification");
-    }
-  }
-  // ─── createSessionThread ─────────────────────────────────────────────────
-  async createSessionThread(sessionId, name) {
-    const thread = await createSessionThread(this.forumChannel, name);
-    const session = this.core.sessionManager.getSession(sessionId);
-    if (session) {
-      session.threadId = thread.id;
-    }
-    const record = this.core.sessionManager.getSessionRecord(sessionId);
-    if (record) {
-      await this.core.sessionManager.patchRecord(sessionId, {
-        platform: { ...record.platform, threadId: thread.id }
-      });
-    }
-    return thread.id;
-  }
-  // ─── renameSessionThread ──────────────────────────────────────────────────
-  async renameSessionThread(sessionId, newName) {
-    const session = this.core.sessionManager.getSession(sessionId);
-    const threadId = session?.threadId;
-    if (!threadId) return;
-    await renameSessionThread(this.guild, threadId, newName);
-  }
-  // ─── deleteSessionThread ──────────────────────────────────────────────────
-  async deleteSessionThread(sessionId) {
-    const session = this.core.sessionManager.getSession(sessionId);
-    const threadId = session?.threadId;
-    if (!threadId) return;
-    await deleteSessionThread(this.guild, threadId);
-  }
-  // ─── sendSkillCommands ────────────────────────────────────────────────────
-  async sendSkillCommands(sessionId, commands) {
-    const thread = await this.getThread(sessionId);
-    if (!thread) return;
-    await this.skillManager.send(sessionId, thread, commands);
-  }
-  // ─── cleanupSkillCommands ─────────────────────────────────────────────────
-  async cleanupSkillCommands(sessionId) {
-    await this.skillManager.cleanup(sessionId);
-  }
-  // ─── Public helpers (for slash commands) ─────────────────────────────────
-  getForumChannel() {
-    return this.forumChannel;
-  }
-  getGuild() {
-    return this.guild;
-  }
-  getGuildId() {
-    return this.guild.id;
-  }
-  getAssistantSessionId() {
-    return this.assistantSession?.id ?? null;
-  }
-  getAssistantThreadId() {
-    return this.discordConfig.assistantThreadId;
-  }
-};
-export {
-  DiscordAdapter
-};
-//# sourceMappingURL=discord-OMC52Y54.js.map