@openacp/cli 0.5.3 → 0.6.1

package/dist/discord-2DKRH45T.js

@@ -0,0 +1,2044 @@
+import {
+  handleCancel,
+  handleCleanupButton,
+  handleHandoff,
+  handleSessions,
+  handleStatus
+} from "./chunk-T22OLSET.js";
+import {
+  handleAgentButton,
+  handleAgents,
+  handleInstall
+} from "./chunk-H7ZMPBZC.js";
+import {
+  handleSettings,
+  handleSettingsButton
+} from "./chunk-THBR6OXH.js";
+import {
+  handleDoctor,
+  handleDoctorButton
+} from "./chunk-GINCOFNW.js";
+import {
+  buildActionKeyboard,
+  detectAction,
+  storeAction
+} from "./chunk-I7WC6E5S.js";
+import {
+  handleNew,
+  handleNewChat,
+  handleNewSessionButton
+} from "./chunk-AKIU4JBF.js";
+import {
+  buildDeepLink,
+  createSessionThread,
+  deleteSessionThread,
+  ensureForums,
+  ensureUnarchived,
+  renameSessionThread
+} from "./chunk-SM3G6UAX.js";
+import {
+  handleDangerous,
+  handleDangerousButton,
+  handleRestart,
+  handleUpdate
+} from "./chunk-7G5QKLLF.js";
+import {
+  ChannelAdapter,
+  PRODUCT_GUIDE
+} from "./chunk-LGQYTK55.js";
+import "./chunk-ZCHNAM3B.js";
+import "./chunk-4LFDEW22.js";
+import {
+  log
+} from "./chunk-ESOPMQAY.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
+var STATUS_ICON = {
+  running: "\u{1F504}",
+  completed: "\u2705",
+  failed: "\u274C",
+  pending: "\u23F3",
+  in_progress: "\u{1F504}"
+};
+var KIND_ICON = {
+  read: "\u{1F4D6}",
+  write: "\u270F\uFE0F",
+  command: "\u26A1",
+  search: "\u{1F50D}"
+};
+function extractContentText(content, depth = 0) {
+  if (!content || depth > 5) return "";
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((c) => extractContentText(c, depth + 1)).filter(Boolean).join("\n");
+  }
+  if (typeof content === "object" && content !== null) {
+    const c = content;
+    if (c.type === "text" && typeof c.text === "string") return c.text;
+    if (typeof c.text === "string") return c.text;
+    if (typeof c.content === "string") return c.content;
+    if (c.content && typeof c.content === "object") return extractContentText(c.content, depth + 1);
+    if (c.input) return extractContentText(c.input, depth + 1);
+    if (c.output) return extractContentText(c.output, depth + 1);
+    const keys = Object.keys(c).filter((k) => k !== "type");
+    if (keys.length === 0) return "";
+    return JSON.stringify(c, null, 2);
+  }
+  return String(content);
+}
+function truncateContent(text, maxLen = 500) {
+  if (text.length <= maxLen) return text;
+  return text.slice(0, maxLen) + "\n\u2026 (truncated)";
+}
+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 formatToolCall(tool) {
+  const si = STATUS_ICON[tool.status || ""] || "\u{1F527}";
+  const ki = KIND_ICON[tool.kind || ""] || "\u{1F6E0}\uFE0F";
+  let text = `${si} ${ki} **${tool.name || "Tool"}**`;
+  text += formatViewerLinks(tool.viewerLinks, tool.viewerFilePath);
+  if (!tool.viewerLinks) {
+    const details = extractContentText(tool.content);
+    if (details) {
+      text += `
+\`\`\`
+${truncateContent(details)}
+\`\`\``;
+    }
+  }
+  return text;
+}
+function formatToolUpdate(update) {
+  return formatToolCall(update);
+}
+function formatPlan(entries) {
+  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 formatTokens(n) {
+  return n >= 1e3 ? `${Math.round(n / 1e3)}k` : String(n);
+}
+function progressBar(ratio) {
+  const filled = Math.round(Math.min(ratio, 1) * 10);
+  return "\u2593".repeat(filled) + "\u2591".repeat(10 - filled);
+}
+function formatUsage(usage) {
+  const { tokensUsed, contextSize } = usage;
+  if (tokensUsed == null) return "\u{1F4CA} Usage data unavailable";
+  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
+${bar} ${pct}%`;
+}
+function splitMessage(text, maxLength = 1800) {
+  if (text.length <= maxLength) return [text];
+  const chunks = [];
+  let remaining = text;
+  while (remaining.length > 0) {
+    if (remaining.length <= maxLength) {
+      chunks.push(remaining);
+      break;
+    }
+    const wouldLeaveSmall = remaining.length < maxLength * 1.3;
+    const searchLimit = wouldLeaveSmall ? Math.floor(remaining.length / 2) + 300 : maxLength;
+    let splitAt = remaining.lastIndexOf("\n\n", searchLimit);
+    if (splitAt === -1 || splitAt < searchLimit * 0.2) {
+      splitAt = remaining.lastIndexOf("\n", searchLimit);
+    }
+    if (splitAt === -1 || splitAt < searchLimit * 0.2) {
+      splitAt = searchLimit;
+    }
+    const candidate = remaining.slice(0, splitAt);
+    const fences = candidate.match(/```/g);
+    if (fences && fences.length % 2 !== 0) {
+      const closingFence = remaining.indexOf("```", splitAt);
+      if (closingFence !== -1) {
+        const afterFence = remaining.indexOf("\n", closingFence + 3);
+        splitAt = afterFence !== -1 ? afterFence + 1 : closingFence + 3;
+      }
+    }
+    chunks.push(remaining.slice(0, splitAt));
+    remaining = remaining.slice(splitAt).replace(/^\n+/, "");
+  }
+  return chunks;
+}
+
+// src/adapters/discord/tool-call-tracker.ts
+var ToolCallTracker = class {
+  constructor(sendQueue) {
+    this.sendQueue = sendQueue;
+  }
+  sessions = /* @__PURE__ */ new Map();
+  async trackNewCall(sessionId, thread, tool) {
+    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,
+      viewerLinks: tool.viewerLinks,
+      viewerFilePath: tool.viewerFilePath,
+      ready
+    };
+    this.sessions.get(sessionId).set(tool.id, state);
+    const content = formatToolCall(tool);
+    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) {
+    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,
+      viewerLinks: toolState.viewerLinks,
+      viewerFilePath: toolState.viewerFilePath
+    };
+    const content = formatToolUpdate(merged);
+    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 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 = splitMessage(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);
+  }
+  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) {
+    const text = formatUsage(usage);
+    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;
+  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);
+    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) {
+    await this._firstEventGuard();
+    this.thinking.dismiss();
+    this.hasPlanCard = true;
+    this.planCard.update(entries);
+  }
+  async sendUsage(usage) {
+    await this.usage.send(usage);
+  }
+  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;
+      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: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)
+\`/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.assistant) {
+    await interaction.editReply("\u26A0\uFE0F Assistant is not available.");
+    return;
+  }
+  try {
+    await adapter.assistant.respawn();
+    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-DRRP2J7E.js");
+        await interaction.followUp({ content: "Use `/new` to create a new session.", ephemeral: true });
+        break;
+      }
+      case "m:sessions": {
+        const { handleSessions: handleSessions2 } = await import("./session-FVFLBREJ.js");
+        await showSessionsList(interaction, adapter);
+        break;
+      }
+      case "m:status": {
+        await showGlobalStatus(interaction, adapter);
+        break;
+      }
+      case "m:agents": {
+        const { showAgentsList } = await import("./agents-55NX3DHM.js");
+        await showAgentsList(interaction, adapter);
+        break;
+      }
+      case "m:settings": {
+        const { showSettingsInfo } = await import("./settings-LPOLJ6SA.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-IKPS5PFC.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-CHCYUTV5.js");
+        await runDoctorInline(interaction, adapter);
+        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;
+      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-6M5GCGAU.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("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-DRRP2J7E.js");
+  await doExecute(interaction, adapter, agentName, workspace);
+}
+async function executeCancelSession(interaction, adapter) {
+  const { executeCancelSession: doCancel } = await import("./session-FVFLBREJ.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")
+];
+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();
+  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;
+    }
+  }
+  // ─── 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;
+    if (!this.sessionTrackers.has(sessionId)) {
+      this.sessionTrackers.set(sessionId, new ActivityTracker(thread, this.sendQueue));
+    }
+    const tracker = this.sessionTrackers.get(sessionId);
+    switch (content.type) {
+      case "thought": {
+        await tracker.onThought();
+        break;
+      }
+      case "text": {
+        await tracker.onTextStart();
+        const draft = this.draftManager.getOrCreate(sessionId, thread);
+        draft.append(content.text);
+        this.draftManager.appendText(sessionId, content.text);
+        break;
+      }
+      case "tool_call": {
+        await tracker.onToolCall();
+        await this.draftManager.finalize(sessionId, thread, isAssistant);
+        const meta = content.metadata ?? {};
+        await this.toolTracker.trackNewCall(sessionId, thread, {
+          id: String(meta.id ?? ""),
+          name: content.text || String(meta.name ?? "Tool"),
+          kind: meta.kind,
+          status: String(meta.status ?? "running"),
+          content: meta.content,
+          viewerLinks: meta.viewerLinks,
+          viewerFilePath: meta.viewerFilePath
+        });
+        break;
+      }
+      case "tool_update": {
+        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,
+          viewerLinks: meta.viewerLinks,
+          viewerFilePath: meta.viewerFilePath
+        });
+        break;
+      }
+      case "plan": {
+        const entries = content.metadata?.entries ?? [];
+        await tracker.onPlan(entries);
+        break;
+      }
+      case "usage": {
+        await this.draftManager.finalize(sessionId, thread, isAssistant);
+        const meta = content.metadata ?? {};
+        await tracker.sendUsage({
+          tokensUsed: meta.tokensUsed,
+          contextSize: meta.contextSize
+        });
+        try {
+          const deepLink = buildDeepLink(this.guild.id, thread.id);
+          await this.sendNotification({
+            sessionId,
+            type: "completed",
+            summary: content.text || "Session completed",
+            deepLink
+          });
+        } catch {
+        }
+        break;
+      }
+      case "session_end": {
+        await this.draftManager.finalize(sessionId, thread, isAssistant);
+        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 {
+        }
+        break;
+      }
+      case "error": {
+        await this.draftManager.finalize(sessionId, thread, isAssistant);
+        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 {
+        }
+        break;
+      }
+      case "attachment": {
+        if (!content.attachment) break;
+        const { attachment } = content;
+        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(
+              () => thread.send({ content: `\u26A0\uFE0F File too large to send (${Math.round(attachment.size / 1024 / 1024)}MB): ${attachment.fileName}` }),
+              { type: "other" }
+            );
+          } catch {
+          }
+          break;
+        }
+        try {
+          await this.sendQueue.enqueue(
+            () => thread.send({ files: [{ attachment: attachment.filePath, name: attachment.fileName }] }),
+            { type: "other" }
+          );
+        } catch (err) {
+          log.error({ err, sessionId, fileName: attachment.fileName }, "[discord-media] Failed to send attachment");
+        }
+        break;
+      }
+      case "system_message": {
+        try {
+          await this.sendQueue.enqueue(
+            () => thread.send({ content: content.text }),
+            { type: "other" }
+          );
+        } catch {
+        }
+        break;
+      }
+    }
+  }
+  // ─── sendPermissionRequest ────────────────────────────────────────────────
+  async sendPermissionRequest(sessionId, request) {
+    const session = this.core.sessionManager.getSession(sessionId);
+    if (!session) {
+      log.warn({ sessionId }, "[DiscordAdapter] sendPermissionRequest: session not found");
+      return;
+    }
+    const autoApprove = request.description.toLowerCase().includes("openacp") || session.dangerousMode;
+    if (autoApprove) {
+      const allowOption = request.options.find((o) => o.isAllow);
+      if (allowOption && session.permissionGate.requestId === request.id) {
+        session.permissionGate.resolve(allowOption.id);
+      }
+      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-2DKRH45T.js.map