agentcord 0.1.6 → 0.1.8

package/dist/{bot-RT4CJNKG.js → bot-MUOL7CRV.js}

@@ -53,7 +53,11 @@ import {
   Routes
 } from "discord.js";
 function getCommandDefinitions() {
-  const claude = new SlashCommandBuilder().setName("claude").setDescription("Manage Claude Code sessions").addSubcommand((sub) => sub.setName("new").setDescription("Create a new Claude Code session").addStringOption((opt) => opt.setName("name").setDescription("Session name").setRequired(true)).addStringOption((opt) => opt.setName("directory").setDescription("Working directory (default: configured default)"))).addSubcommand((sub) => sub.setName("resume").setDescription("Resume an existing Claude Code session from terminal").addStringOption((opt) => opt.setName("session-id").setDescription("Claude Code session UUID").setRequired(true).setAutocomplete(true)).addStringOption((opt) => opt.setName("name").setDescription("Name for the Discord channel").setRequired(true)).addStringOption((opt) => opt.setName("directory").setDescription("Working directory (default: configured default)"))).addSubcommand((sub) => sub.setName("list").setDescription("List active sessions")).addSubcommand((sub) => sub.setName("end").setDescription("End the session in this channel")).addSubcommand((sub) => sub.setName("continue").setDescription("Continue the last conversation")).addSubcommand((sub) => sub.setName("stop").setDescription("Stop current generation")).addSubcommand((sub) => sub.setName("output").setDescription("Show recent conversation output").addIntegerOption((opt) => opt.setName("lines").setDescription("Number of lines (default 50)").setMinValue(1).setMaxValue(500))).addSubcommand((sub) => sub.setName("attach").setDescription("Show tmux attach command for terminal access")).addSubcommand((sub) => sub.setName("sync").setDescription("Reconnect orphaned tmux sessions")).addSubcommand((sub) => sub.setName("model").setDescription("Change the model for this session").addStringOption((opt) => opt.setName("model").setDescription("Model name (e.g. claude-sonnet-4-5-20250929)").setRequired(true))).addSubcommand((sub) => sub.setName("verbose").setDescription("Toggle showing tool calls and results in this session"));
+  const claude = new SlashCommandBuilder().setName("claude").setDescription("Manage Claude Code sessions").addSubcommand((sub) => sub.setName("new").setDescription("Create a new Claude Code session").addStringOption((opt) => opt.setName("name").setDescription("Session name").setRequired(true)).addStringOption((opt) => opt.setName("directory").setDescription("Working directory (default: configured default)"))).addSubcommand((sub) => sub.setName("resume").setDescription("Resume an existing Claude Code session from terminal").addStringOption((opt) => opt.setName("session-id").setDescription("Claude Code session UUID").setRequired(true).setAutocomplete(true)).addStringOption((opt) => opt.setName("name").setDescription("Name for the Discord channel").setRequired(true)).addStringOption((opt) => opt.setName("directory").setDescription("Working directory (default: configured default)"))).addSubcommand((sub) => sub.setName("list").setDescription("List active sessions")).addSubcommand((sub) => sub.setName("end").setDescription("End the session in this channel")).addSubcommand((sub) => sub.setName("continue").setDescription("Continue the last conversation")).addSubcommand((sub) => sub.setName("stop").setDescription("Stop current generation")).addSubcommand((sub) => sub.setName("output").setDescription("Show recent conversation output").addIntegerOption((opt) => opt.setName("lines").setDescription("Number of lines (default 50)").setMinValue(1).setMaxValue(500))).addSubcommand((sub) => sub.setName("attach").setDescription("Show tmux attach command for terminal access")).addSubcommand((sub) => sub.setName("sync").setDescription("Reconnect orphaned tmux sessions")).addSubcommand((sub) => sub.setName("model").setDescription("Change the model for this session").addStringOption((opt) => opt.setName("model").setDescription("Model name (e.g. claude-sonnet-4-5-20250929)").setRequired(true))).addSubcommand((sub) => sub.setName("verbose").setDescription("Toggle showing tool calls and results in this session")).addSubcommand((sub) => sub.setName("mode").setDescription("Set session mode (auto/plan/normal)").addStringOption((opt) => opt.setName("mode").setDescription("Session mode").setRequired(true).addChoices(
+    { name: "Auto \u2014 full autonomy", value: "auto" },
+    { name: "Plan \u2014 plan before executing", value: "plan" },
+    { name: "Normal \u2014 ask before destructive ops", value: "normal" }
+  )));
   const shell = new SlashCommandBuilder().setName("shell").setDescription("Run shell commands in the session directory").addSubcommand((sub) => sub.setName("run").setDescription("Execute a shell command").addStringOption((opt) => opt.setName("command").setDescription("Command to run").setRequired(true))).addSubcommand((sub) => sub.setName("processes").setDescription("List running processes")).addSubcommand((sub) => sub.setName("kill").setDescription("Kill a running process").addIntegerOption((opt) => opt.setName("pid").setDescription("Process ID to kill").setRequired(true)));
   const agent = new SlashCommandBuilder().setName("agent").setDescription("Manage agent personas").addSubcommand((sub) => sub.setName("use").setDescription("Switch to an agent persona").addStringOption((opt) => opt.setName("persona").setDescription("Agent persona name").setRequired(true).addChoices(
     { name: "Code Reviewer", value: "code-reviewer" },
@@ -65,11 +69,33 @@ function getCommandDefinitions() {
     { name: "General", value: "general" }
   ))).addSubcommand((sub) => sub.setName("list").setDescription("List available agent personas")).addSubcommand((sub) => sub.setName("clear").setDescription("Clear agent persona"));
   const project = new SlashCommandBuilder().setName("project").setDescription("Configure project settings").addSubcommand((sub) => sub.setName("personality").setDescription("Set a custom personality for this project").addStringOption((opt) => opt.setName("prompt").setDescription("System prompt for the project").setRequired(true))).addSubcommand((sub) => sub.setName("personality-show").setDescription("Show the current project personality")).addSubcommand((sub) => sub.setName("personality-clear").setDescription("Clear the project personality")).addSubcommand((sub) => sub.setName("skill-add").setDescription("Add a skill (prompt template) to this project").addStringOption((opt) => opt.setName("name").setDescription("Skill name").setRequired(true)).addStringOption((opt) => opt.setName("prompt").setDescription("Prompt template (use {input} for placeholder)").setRequired(true))).addSubcommand((sub) => sub.setName("skill-remove").setDescription("Remove a skill").addStringOption((opt) => opt.setName("name").setDescription("Skill name").setRequired(true))).addSubcommand((sub) => sub.setName("skill-list").setDescription("List all skills for this project")).addSubcommand((sub) => sub.setName("skill-run").setDescription("Execute a skill").addStringOption((opt) => opt.setName("name").setDescription("Skill name").setRequired(true)).addStringOption((opt) => opt.setName("input").setDescription("Input to pass to the skill template"))).addSubcommand((sub) => sub.setName("mcp-add").setDescription("Add an MCP server to this project").addStringOption((opt) => opt.setName("name").setDescription("Server name").setRequired(true)).addStringOption((opt) => opt.setName("command").setDescription("Command to run (e.g. npx my-mcp-server)").setRequired(true)).addStringOption((opt) => opt.setName("args").setDescription("Arguments (comma-separated)"))).addSubcommand((sub) => sub.setName("mcp-remove").setDescription("Remove an MCP server").addStringOption((opt) => opt.setName("name").setDescription("Server name").setRequired(true))).addSubcommand((sub) => sub.setName("mcp-list").setDescription("List configured MCP servers")).addSubcommand((sub) => sub.setName("info").setDescription("Show project configuration"));
+  const plugin = new SlashCommandBuilder().setName("plugin").setDescription("Manage Claude Code plugins").addSubcommand((sub) => sub.setName("browse").setDescription("Browse available plugins from marketplaces").addStringOption((opt) => opt.setName("search").setDescription("Filter by name or keyword"))).addSubcommand((sub) => sub.setName("install").setDescription("Install a plugin").addStringOption((opt) => opt.setName("plugin").setDescription("Plugin name (e.g. feature-dev@claude-plugins-official)").setRequired(true).setAutocomplete(true)).addStringOption((opt) => opt.setName("scope").setDescription("Installation scope (default: user)").addChoices(
+    { name: "User \u2014 available everywhere", value: "user" },
+    { name: "Project \u2014 this project only", value: "project" },
+    { name: "Local \u2014 this directory only", value: "local" }
+  ))).addSubcommand((sub) => sub.setName("remove").setDescription("Uninstall a plugin").addStringOption((opt) => opt.setName("plugin").setDescription("Plugin ID").setRequired(true).setAutocomplete(true)).addStringOption((opt) => opt.setName("scope").setDescription("Scope to uninstall from (default: user)").addChoices(
+    { name: "User", value: "user" },
+    { name: "Project", value: "project" },
+    { name: "Local", value: "local" }
+  ))).addSubcommand((sub) => sub.setName("list").setDescription("List installed plugins")).addSubcommand((sub) => sub.setName("info").setDescription("Show detailed info for a plugin").addStringOption((opt) => opt.setName("plugin").setDescription("Plugin name or ID").setRequired(true).setAutocomplete(true))).addSubcommand((sub) => sub.setName("enable").setDescription("Enable a disabled plugin").addStringOption((opt) => opt.setName("plugin").setDescription("Plugin ID").setRequired(true).setAutocomplete(true)).addStringOption((opt) => opt.setName("scope").setDescription("Scope (default: user)").addChoices(
+    { name: "User", value: "user" },
+    { name: "Project", value: "project" },
+    { name: "Local", value: "local" }
+  ))).addSubcommand((sub) => sub.setName("disable").setDescription("Disable a plugin").addStringOption((opt) => opt.setName("plugin").setDescription("Plugin ID").setRequired(true).setAutocomplete(true)).addStringOption((opt) => opt.setName("scope").setDescription("Scope (default: user)").addChoices(
+    { name: "User", value: "user" },
+    { name: "Project", value: "project" },
+    { name: "Local", value: "local" }
+  ))).addSubcommand((sub) => sub.setName("update").setDescription("Update a plugin to latest version").addStringOption((opt) => opt.setName("plugin").setDescription("Plugin ID").setRequired(true).setAutocomplete(true)).addStringOption((opt) => opt.setName("scope").setDescription("Scope (default: user)").addChoices(
+    { name: "User", value: "user" },
+    { name: "Project", value: "project" },
+    { name: "Local", value: "local" }
+  ))).addSubcommand((sub) => sub.setName("marketplace-add").setDescription("Add a plugin marketplace").addStringOption((opt) => opt.setName("source").setDescription("GitHub repo (owner/repo) or git URL").setRequired(true))).addSubcommand((sub) => sub.setName("marketplace-remove").setDescription("Remove a marketplace").addStringOption((opt) => opt.setName("name").setDescription("Marketplace name").setRequired(true).setAutocomplete(true))).addSubcommand((sub) => sub.setName("marketplace-list").setDescription("List registered marketplaces")).addSubcommand((sub) => sub.setName("marketplace-update").setDescription("Update marketplace catalogs").addStringOption((opt) => opt.setName("name").setDescription("Specific marketplace (or all if omitted)").setAutocomplete(true)));
   return [
     claude.toJSON(),
     shell.toJSON(),
     agent.toJSON(),
-    project.toJSON()
+    project.toJSON(),
+    plugin.toJSON()
   ];
 }
 async function registerCommands() {
@@ -100,8 +126,8 @@ import {
   ChannelType
 } from "discord.js";
 import { readdirSync, statSync, createReadStream } from "fs";
-import { join as join3, basename } from "path";
-import { homedir as homedir2 } from "os";
+import { join as join4, basename } from "path";
+import { homedir as homedir3 } from "os";
 import { createInterface } from "readline";
 
 // src/session-manager.ts
@@ -241,6 +267,9 @@ async function saveProjects() {
 function getProject(name) {
   return projects[name];
 }
+function getProjectByCategoryId(categoryId) {
+  return Object.values(projects).find((p) => p.categoryId === categoryId);
+}
 function getOrCreateProject(name, directory, categoryId) {
   if (!projects[name]) {
     projects[name] = {
@@ -427,14 +456,19 @@ function detectNumberedOptions(text) {
   const options = [];
   const optionRegex = /^\s*(\d+)[.)]\s+(.+)$/;
   let firstOptionLine = -1;
+  let lastOptionLine = -1;
   for (let i = 0; i < lines.length; i++) {
     const match = lines[i].match(optionRegex);
     if (match) {
       if (firstOptionLine === -1) firstOptionLine = i;
+      lastOptionLine = i;
       options.push(match[2].trim());
     }
   }
   if (options.length < 2 || options.length > 6) return null;
+  if (options.some((o) => o.length > 80)) return null;
+  const linesAfter = lines.slice(lastOptionLine + 1).filter((l) => l.trim()).length;
+  if (linesAfter > 3) return null;
   const preamble = lines.slice(0, firstOptionLine).join(" ").toLowerCase();
   const hasQuestion = /\?\s*$/.test(preamble.trim()) || /\b(which|choose|select|pick|prefer|would you like|how would you|what approach|option)\b/.test(preamble);
   return hasQuestion ? options : null;
@@ -446,6 +480,11 @@ function detectYesNoPrompt(text) {
 
 // src/session-manager.ts
 var SESSION_PREFIX = "claude-";
+var MODE_PROMPTS = {
+  auto: "",
+  plan: "You MUST use EnterPlanMode at the start of every task. Present your plan for user approval before making any code changes. Do not write or edit files until the user approves the plan.",
+  normal: "Before performing destructive or significant operations (deleting files, running dangerous commands, making large refactors, writing to many files), use AskUserQuestion to confirm with the user first. Ask for explicit approval before proceeding with changes."
+};
 var sessionStore = new Store("sessions.json");
 var sessions = /* @__PURE__ */ new Map();
 var channelToSession = /* @__PURE__ */ new Map();
@@ -473,6 +512,7 @@ async function loadSessions() {
     sessions.set(s.id, {
       ...s,
       verbose: s.verbose ?? false,
+      mode: s.mode ?? "auto",
       isGenerating: false
     });
     channelToSession.set(s.channelId, s.id);
@@ -499,6 +539,7 @@ async function saveSessions() {
       model: s.model,
       agentPersona: s.agentPersona,
       verbose: s.verbose || void 0,
+      mode: s.mode !== "auto" ? s.mode : void 0,
       createdAt: s.createdAt,
       lastActivity: s.lastActivity,
       messageCount: s.messageCount,
@@ -532,6 +573,7 @@ async function createSession(name, directory, channelId, projectName, claudeSess
     tmuxName,
     claudeSessionId,
     verbose: false,
+    mode: "auto",
     isGenerating: false,
     createdAt: Date.now(),
     lastActivity: Date.now(),
@@ -601,6 +643,13 @@ function setVerbose(sessionId, verbose) {
     saveSessions();
   }
 }
+function setMode(sessionId, mode) {
+  const session = sessions.get(sessionId);
+  if (session) {
+    session.mode = mode;
+    saveSessions();
+  }
+}
 function setAgentPersona(sessionId, persona) {
   const session = sessions.get(sessionId);
   if (session) {
@@ -616,6 +665,8 @@ function buildSystemPrompt(session) {
     const agent = getAgent(session.agentPersona);
     if (agent?.systemPrompt) parts.push(agent.systemPrompt);
   }
+  const modePrompt = MODE_PROMPTS[session.mode];
+  if (modePrompt) parts.push(modePrompt);
   if (parts.length > 0) {
     return { type: "preset", preset: "claude_code", append: parts.join("\n\n") };
   }
@@ -630,9 +681,23 @@ async function* sendPrompt(sessionId, prompt) {
   session.isGenerating = true;
   session.lastActivity = Date.now();
   const systemPrompt = buildSystemPrompt(session);
+  let queryPrompt;
+  if (typeof prompt === "string") {
+    queryPrompt = prompt;
+  } else {
+    const userMessage = {
+      type: "user",
+      message: { role: "user", content: prompt },
+      parent_tool_use_id: null,
+      session_id: ""
+    };
+    queryPrompt = (async function* () {
+      yield userMessage;
+    })();
+  }
   try {
     const stream = query({
-      prompt,
+      prompt: queryPrompt,
       options: {
         cwd: session.directory,
         resume: session.claudeSessionId,
@@ -756,16 +821,158 @@ async function listTmuxSessions() {
   }
 }
 
+// src/plugin-manager.ts
+import { execFile as execFile2 } from "child_process";
+import { readFile as readFile3 } from "fs/promises";
+import { join as join3 } from "path";
+import { homedir as homedir2 } from "os";
+var PLUGINS_DIR = join3(homedir2(), ".claude", "plugins");
+var MARKETPLACES_DIR = join3(PLUGINS_DIR, "marketplaces");
+function runClaude(args, cwd) {
+  return new Promise((resolve2) => {
+    execFile2("claude", args, {
+      cwd: cwd || process.cwd(),
+      timeout: 12e4,
+      env: { ...process.env }
+    }, (error, stdout, stderr) => {
+      resolve2({
+        stdout: stdout || "",
+        stderr: stderr || "",
+        code: error ? error.code ?? 1 : 0
+      });
+    });
+  });
+}
+var CACHE_TTL_MS = 3e4;
+var installedCache = null;
+var availableCache = null;
+var marketplaceCache = null;
+function invalidateCache() {
+  installedCache = null;
+  availableCache = null;
+  marketplaceCache = null;
+}
+async function listInstalled() {
+  if (installedCache && Date.now() - installedCache.ts < CACHE_TTL_MS) {
+    return installedCache.data;
+  }
+  const result = await runClaude(["plugin", "list", "--json"]);
+  if (result.code !== 0) throw new Error(`Failed to list plugins: ${result.stderr}`);
+  const data = JSON.parse(result.stdout);
+  installedCache = { data, ts: Date.now() };
+  return data;
+}
+async function listAvailable() {
+  if (availableCache && Date.now() - availableCache.ts < CACHE_TTL_MS) {
+    return availableCache.data;
+  }
+  const result = await runClaude(["plugin", "list", "--available", "--json"]);
+  if (result.code !== 0) throw new Error(`Failed to list available plugins: ${result.stderr}`);
+  const data = JSON.parse(result.stdout);
+  availableCache = { data, ts: Date.now() };
+  return data;
+}
+async function installPlugin(pluginId, scope, cwd) {
+  const result = await runClaude(["plugin", "install", pluginId, "-s", scope], cwd);
+  invalidateCache();
+  if (result.code !== 0) throw new Error(result.stderr || result.stdout || "Install failed");
+  return result.stdout.trim() || "Plugin installed successfully.";
+}
+async function uninstallPlugin(pluginId, scope, cwd) {
+  const result = await runClaude(["plugin", "uninstall", pluginId, "-s", scope], cwd);
+  invalidateCache();
+  if (result.code !== 0) throw new Error(result.stderr || result.stdout || "Uninstall failed");
+  return result.stdout.trim() || "Plugin uninstalled successfully.";
+}
+async function enablePlugin(pluginId, scope, cwd) {
+  const result = await runClaude(["plugin", "enable", pluginId, "-s", scope], cwd);
+  invalidateCache();
+  if (result.code !== 0) throw new Error(result.stderr || result.stdout || "Enable failed");
+  return result.stdout.trim() || "Plugin enabled.";
+}
+async function disablePlugin(pluginId, scope, cwd) {
+  const result = await runClaude(["plugin", "disable", pluginId, "-s", scope], cwd);
+  invalidateCache();
+  if (result.code !== 0) throw new Error(result.stderr || result.stdout || "Disable failed");
+  return result.stdout.trim() || "Plugin disabled.";
+}
+async function updatePlugin(pluginId, scope, cwd) {
+  const result = await runClaude(["plugin", "update", pluginId, "-s", scope], cwd);
+  invalidateCache();
+  if (result.code !== 0) throw new Error(result.stderr || result.stdout || "Update failed");
+  return result.stdout.trim() || "Plugin updated.";
+}
+async function listMarketplaces() {
+  if (marketplaceCache && Date.now() - marketplaceCache.ts < CACHE_TTL_MS) {
+    return marketplaceCache.data;
+  }
+  const result = await runClaude(["plugin", "marketplace", "list", "--json"]);
+  if (result.code !== 0) throw new Error(`Failed to list marketplaces: ${result.stderr}`);
+  const data = JSON.parse(result.stdout);
+  marketplaceCache = { data, ts: Date.now() };
+  return data;
+}
+async function addMarketplace(source) {
+  const result = await runClaude(["plugin", "marketplace", "add", source]);
+  invalidateCache();
+  if (result.code !== 0) throw new Error(result.stderr || result.stdout || "Add marketplace failed");
+  return result.stdout.trim() || "Marketplace added.";
+}
+async function removeMarketplace(name) {
+  const result = await runClaude(["plugin", "marketplace", "remove", name]);
+  invalidateCache();
+  if (result.code !== 0) throw new Error(result.stderr || result.stdout || "Remove marketplace failed");
+  return result.stdout.trim() || "Marketplace removed.";
+}
+async function updateMarketplaces(name) {
+  const args = ["plugin", "marketplace", "update"];
+  if (name) args.push(name);
+  const result = await runClaude(args);
+  invalidateCache();
+  if (result.code !== 0) throw new Error(result.stderr || result.stdout || "Update marketplace failed");
+  return result.stdout.trim() || "Marketplace(s) updated.";
+}
+async function getPluginDetail(pluginName, marketplaceName) {
+  try {
+    const marketplacePath = join3(MARKETPLACES_DIR, marketplaceName, ".claude-plugin", "marketplace.json");
+    const raw = await readFile3(marketplacePath, "utf-8");
+    const catalog = JSON.parse(raw);
+    return catalog.plugins.find((p) => p.name === pluginName) || null;
+  } catch {
+    return null;
+  }
+}
+
 // src/output-handler.ts
 import {
+  AttachmentBuilder,
   EmbedBuilder,
   ActionRowBuilder,
   ButtonBuilder,
   ButtonStyle,
   StringSelectMenuBuilder
 } from "discord.js";
+import { existsSync as existsSync4 } from "fs";
 var expandableStore = /* @__PURE__ */ new Map();
 var expandCounter = 0;
+var pendingAnswersStore = /* @__PURE__ */ new Map();
+var questionCountStore = /* @__PURE__ */ new Map();
+function setPendingAnswer(sessionId, questionIndex, answer) {
+  if (!pendingAnswersStore.has(sessionId)) {
+    pendingAnswersStore.set(sessionId, /* @__PURE__ */ new Map());
+  }
+  pendingAnswersStore.get(sessionId).set(questionIndex, answer);
+}
+function getPendingAnswers(sessionId) {
+  return pendingAnswersStore.get(sessionId);
+}
+function clearPendingAnswers(sessionId) {
+  pendingAnswersStore.delete(sessionId);
+  questionCountStore.delete(sessionId);
+}
+function getQuestionCount(sessionId) {
+  return questionCountStore.get(sessionId) || 0;
+}
 setInterval(() => {
   const now = Date.now();
   const TTL = 10 * 60 * 1e3;
@@ -806,6 +1013,20 @@ function makeOptionButtons(sessionId, options) {
   }
   return rows;
 }
+function makeModeButtons(sessionId, currentMode) {
+  const modes = [
+    { id: "auto", label: "\u26A1 Auto" },
+    { id: "plan", label: "\u{1F4CB} Plan" },
+    { id: "normal", label: "\u{1F6E1}\uFE0F Normal" }
+  ];
+  const row = new ActionRowBuilder();
+  for (const m of modes) {
+    row.addComponents(
+      new ButtonBuilder().setCustomId(`mode:${sessionId}:${m.id}`).setLabel(m.label).setStyle(m.id === currentMode ? ButtonStyle.Primary : ButtonStyle.Secondary).setDisabled(m.id === currentMode)
+    );
+  }
+  return row;
+}
 function makeYesNoButtons(sessionId) {
   return new ActionRowBuilder().addComponents(
     new ButtonBuilder().setCustomId(`confirm:${sessionId}:yes`).setLabel("Yes").setStyle(ButtonStyle.Success),
@@ -931,6 +1152,20 @@ var MessageStreamer = class {
     }
   }
 };
+var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".gif", ".webp", ".svg", ".bmp"]);
+function extractImagePath(toolName, toolInput) {
+  try {
+    const data = JSON.parse(toolInput);
+    if (toolName === "Write" || toolName === "Read") {
+      const filePath = data.file_path;
+      if (filePath && IMAGE_EXTENSIONS.has(filePath.slice(filePath.lastIndexOf(".")).toLowerCase())) {
+        return filePath;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
 var USER_FACING_TOOLS = /* @__PURE__ */ new Set([
   "AskUserQuestion",
   "EnterPlanMode",
@@ -957,21 +1192,29 @@ function renderAskUserQuestion(toolInput, sessionId) {
     const data = JSON.parse(toolInput);
     const questions = data.questions;
     if (!questions?.length) return null;
+    const isMulti = questions.length > 1;
+    if (isMulti) {
+      clearPendingAnswers(sessionId);
+      questionCountStore.set(sessionId, questions.length);
+    }
     const embeds = [];
     const components = [];
-    for (const q of questions) {
+    const btnPrefix = isMulti ? "pick" : "answer";
+    const selectPrefix = isMulti ? "pick-select" : "answer-select";
+    for (let qi = 0; qi < questions.length; qi++) {
+      const q = questions[qi];
       const embed = new EmbedBuilder().setColor(15965202).setTitle(q.header || "Question").setDescription(q.question);
       if (q.options?.length) {
         if (q.options.length <= 4) {
           const row = new ActionRowBuilder();
           for (let i = 0; i < q.options.length; i++) {
             row.addComponents(
-              new ButtonBuilder().setCustomId(`answer:${sessionId}:${q.options[i].label}`).setLabel(q.options[i].label.slice(0, 80)).setStyle(i === 0 ? ButtonStyle.Primary : ButtonStyle.Secondary)
+              new ButtonBuilder().setCustomId(`${btnPrefix}:${sessionId}:${qi}:${q.options[i].label}`).setLabel(q.options[i].label.slice(0, 80)).setStyle(i === 0 ? ButtonStyle.Primary : ButtonStyle.Secondary)
             );
           }
           components.push(row);
         } else {
-          const menu = new StringSelectMenuBuilder().setCustomId(`answer-select:${sessionId}`).setPlaceholder("Select an option...");
+          const menu = new StringSelectMenuBuilder().setCustomId(`${selectPrefix}:${sessionId}:${qi}`).setPlaceholder("Select an option...");
           for (const opt of q.options) {
             menu.addOptions({
               label: opt.label.slice(0, 100),
@@ -986,6 +1229,13 @@ function renderAskUserQuestion(toolInput, sessionId) {
       }
       embeds.push(embed);
     }
+    if (isMulti) {
+      components.push(
+        new ActionRowBuilder().addComponents(
+          new ButtonBuilder().setCustomId(`submit-answers:${sessionId}`).setLabel("Submit Answers").setStyle(ButtonStyle.Success)
+        )
+      );
+    }
     return { embeds, components };
   } catch {
     return null;
@@ -1021,11 +1271,12 @@ function renderTaskListEmbed(resultText) {
   }
   return new EmbedBuilder().setColor(10181046).setTitle("\u{1F4CB} Task Board").setDescription(truncate(formatted, 4e3));
 }
-async function handleOutputStream(stream, channel, sessionId, verbose = false) {
+async function handleOutputStream(stream, channel, sessionId, verbose = false, mode = "auto") {
   const streamer = new MessageStreamer(channel, sessionId);
   let currentToolName = null;
   let currentToolInput = "";
   let lastFinishedToolName = null;
+  let pendingImagePath = null;
   channel.sendTyping().catch(() => {
   });
   const typingInterval = setInterval(() => {
@@ -1087,6 +1338,7 @@ ${displayInput}
                 await channel.send({ embeds: [embed], components });
               }
             }
+            pendingImagePath = extractImagePath(currentToolName, currentToolInput);
             lastFinishedToolName = currentToolName;
             currentToolName = null;
             currentToolInput = "";
@@ -1094,6 +1346,17 @@ ${displayInput}
         }
       }
       if (message.type === "user") {
+        if (pendingImagePath && existsSync4(pendingImagePath)) {
+          try {
+            await streamer.finalize();
+            const attachment = new AttachmentBuilder(pendingImagePath);
+            await channel.send({ files: [attachment] });
+          } catch {
+          }
+          pendingImagePath = null;
+        } else {
+          pendingImagePath = null;
+        }
         const showResult = verbose || lastFinishedToolName !== null && TASK_TOOLS.has(lastFinishedToolName);
         if (!showResult) continue;
         await streamer.finalize();
@@ -1151,7 +1414,8 @@ ${displayResult}
         const embed = new EmbedBuilder().setColor(isSuccess ? 3066993 : 15158332).setTitle(isSuccess ? "Completed" : "Error").addFields(
           { name: "Cost", value: `$${cost}`, inline: true },
           { name: "Duration", value: duration, inline: true },
-          { name: "Turns", value: `${turns}`, inline: true }
+          { name: "Turns", value: `${turns}`, inline: true },
+          { name: "Mode", value: { auto: "\u26A1 Auto", plan: "\u{1F4CB} Plan", normal: "\u{1F6E1}\uFE0F Normal" }[mode] || "\u26A1 Auto", inline: true }
         );
         if (result.session_id) {
           embed.setFooter({ text: `Session: ${result.session_id}` });
@@ -1167,6 +1431,7 @@ ${displayResult}
         } else if (detectYesNoPrompt(checkText)) {
           components.push(makeYesNoButtons(sessionId));
         }
+        components.push(makeModeButtons(sessionId, mode));
         components.push(makeCompletionButtons(sessionId));
         await channel.send({ embeds: [embed], components });
       }
@@ -1337,13 +1602,23 @@ async function handleClaude(interaction) {
       return handleClaudeModel(interaction);
     case "verbose":
       return handleClaudeVerbose(interaction);
+    case "mode":
+      return handleClaudeMode(interaction);
     default:
       await interaction.reply({ content: `Unknown subcommand: ${sub}`, ephemeral: true });
   }
 }
 async function handleClaudeNew(interaction) {
   const name = interaction.options.getString("name", true);
-  const directory = interaction.options.getString("directory") || config.defaultDirectory;
+  let directory = interaction.options.getString("directory");
+  if (!directory) {
+    const parentId = interaction.channel?.parentId;
+    if (parentId) {
+      const project = getProjectByCategoryId(parentId);
+      if (project) directory = project.directory;
+    }
+    directory = directory || config.defaultDirectory;
+  }
   await interaction.deferReply();
   let channel;
   try {
@@ -1385,7 +1660,7 @@ async function handleClaudeNew(interaction) {
   }
 }
 function discoverLocalSessions() {
-  const claudeDir = join3(homedir2(), ".claude", "projects");
+  const claudeDir = join4(homedir3(), ".claude", "projects");
   const results = [];
   let projectDirs;
   try {
@@ -1394,7 +1669,7 @@ function discoverLocalSessions() {
     return [];
   }
   for (const projDir of projectDirs) {
-    const projPath = join3(claudeDir, projDir);
+    const projPath = join4(claudeDir, projDir);
     let files;
     try {
       files = readdirSync(projPath);
@@ -1408,7 +1683,7 @@ function discoverLocalSessions() {
       const sessionId = file.replace(".jsonl", "");
       if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(sessionId)) continue;
       try {
-        const mtime = statSync(join3(projPath, file)).mtimeMs;
+        const mtime = statSync(join4(projPath, file)).mtimeMs;
         results.push({ id: sessionId, project, mtime, firstMessage: "" });
       } catch {
         continue;
@@ -1419,7 +1694,7 @@ function discoverLocalSessions() {
   return results;
 }
 async function getFirstUserMessage(sessionId) {
-  const claudeDir = join3(homedir2(), ".claude", "projects");
+  const claudeDir = join4(homedir3(), ".claude", "projects");
   let projectDirs;
   try {
     projectDirs = readdirSync(claudeDir);
@@ -1427,7 +1702,7 @@ async function getFirstUserMessage(sessionId) {
     return "";
   }
   for (const projDir of projectDirs) {
-    const filePath = join3(claudeDir, projDir, `${sessionId}.jsonl`);
+    const filePath = join4(claudeDir, projDir, `${sessionId}.jsonl`);
     try {
       statSync(filePath);
     } catch {
@@ -1560,7 +1835,8 @@ async function handleClaudeList(interaction) {
   for (const [project, projectSessions] of grouped) {
     const lines = projectSessions.map((s) => {
       const status = s.isGenerating ? "\u{1F7E2} generating" : "\u26AA idle";
-      return `**${s.id}** \u2014 ${status} | ${formatUptime(s.createdAt)} uptime | ${s.messageCount} msgs | $${s.totalCost.toFixed(4)} | ${formatLastActivity(s.lastActivity)}`;
+      const modeEmoji = { auto: "\u26A1", plan: "\u{1F4CB}", normal: "\u{1F6E1}\uFE0F" }[s.mode] || "\u26A1";
+      return `**${s.id}** \u2014 ${status} ${modeEmoji} ${s.mode} | ${formatUptime(s.createdAt)} uptime | ${s.messageCount} msgs | $${s.totalCost.toFixed(4)} | ${formatLastActivity(s.lastActivity)}`;
     });
     embed.addFields({ name: `\u{1F4C1} ${project}`, value: lines.join("\n") });
   }
@@ -1596,7 +1872,7 @@ async function handleClaudeContinue(interaction) {
     const channel = interaction.channel;
     const stream = continueSession(session.id);
     await interaction.editReply("Continuing...");
-    await handleOutputStream(stream, channel, session.id, session.verbose);
+    await handleOutputStream(stream, channel, session.id, session.verbose, session.mode);
   } catch (err) {
     await interaction.editReply(`Error: ${err.message}`);
   }
@@ -1697,6 +1973,24 @@ async function handleClaudeVerbose(interaction) {
     ephemeral: true
   });
 }
+var MODE_LABELS = {
+  auto: "\u26A1 Auto \u2014 full autonomy, no confirmations",
+  plan: "\u{1F4CB} Plan \u2014 always plans before executing changes",
+  normal: "\u{1F6E1}\uFE0F Normal \u2014 asks before destructive operations"
+};
+async function handleClaudeMode(interaction) {
+  const session = getSessionByChannel(interaction.channelId);
+  if (!session) {
+    await interaction.reply({ content: "No session in this channel.", ephemeral: true });
+    return;
+  }
+  const mode = interaction.options.getString("mode", true);
+  setMode(session.id, mode);
+  await interaction.reply({
+    content: `Mode set to **${MODE_LABELS[mode]}**`,
+    ephemeral: true
+  });
+}
 async function handleShell(interaction) {
   if (!isUserAllowed(interaction.user.id, config.allowedUsers, config.allowAllUsers)) {
     await interaction.reply({ content: "You are not authorized.", ephemeral: true });
@@ -1860,7 +2154,7 @@ ${list}`, ephemeral: true });
         const channel = interaction.channel;
         await interaction.editReply(`Running skill **${name}**...`);
         const stream = sendPrompt(session.id, expanded);
-        await handleOutputStream(stream, channel, session.id, session.verbose);
+        await handleOutputStream(stream, channel, session.id, session.verbose, session.mode);
       } catch (err) {
         await interaction.editReply(`Error: ${err.message}`);
       }
@@ -1928,9 +2222,377 @@ ${list}`, ephemeral: true });
     }
   }
 }
+async function handlePlugin(interaction) {
+  if (!isUserAllowed(interaction.user.id, config.allowedUsers, config.allowAllUsers)) {
+    await interaction.reply({ content: "You are not authorized.", ephemeral: true });
+    return;
+  }
+  const sub = interaction.options.getSubcommand();
+  switch (sub) {
+    case "browse":
+      return handlePluginBrowse(interaction);
+    case "install":
+      return handlePluginInstall(interaction);
+    case "remove":
+      return handlePluginRemove(interaction);
+    case "list":
+      return handlePluginList(interaction);
+    case "info":
+      return handlePluginInfo(interaction);
+    case "enable":
+      return handlePluginEnable(interaction);
+    case "disable":
+      return handlePluginDisable(interaction);
+    case "update":
+      return handlePluginUpdate(interaction);
+    case "marketplace-add":
+      return handleMarketplaceAdd(interaction);
+    case "marketplace-remove":
+      return handleMarketplaceRemove(interaction);
+    case "marketplace-list":
+      return handleMarketplaceList(interaction);
+    case "marketplace-update":
+      return handleMarketplaceUpdate(interaction);
+    default:
+      await interaction.reply({ content: `Unknown subcommand: ${sub}`, ephemeral: true });
+  }
+}
+function resolveScopeAndCwd(interaction) {
+  const scope = interaction.options.getString("scope") || "user";
+  if (scope === "user") return { scope };
+  const session = getSessionByChannel(interaction.channelId);
+  if (!session) {
+    return { scope, error: `Scope \`${scope}\` requires an active session. Run this from a session channel, or use \`user\` scope.` };
+  }
+  return { scope, cwd: session.directory };
+}
+async function handlePluginBrowse(interaction) {
+  await interaction.deferReply({ ephemeral: true });
+  try {
+    const search = interaction.options.getString("search")?.toLowerCase();
+    const { installed, available } = await listAvailable();
+    const installedIds = new Set(installed.map((p) => p.id));
+    let filtered = available;
+    if (search) {
+      filtered = available.filter((p) => p.name.toLowerCase().includes(search) || p.description.toLowerCase().includes(search) || p.marketplaceName.toLowerCase().includes(search));
+    }
+    filtered.sort((a, b) => (b.installCount ?? 0) - (a.installCount ?? 0));
+    if (filtered.length === 0) {
+      await interaction.editReply("No plugins found matching your search.");
+      return;
+    }
+    const shown = filtered.slice(0, 15);
+    const embed = new EmbedBuilder2().setColor(8141549).setTitle("Available Plugins").setDescription(`Showing ${shown.length} of ${filtered.length} plugins. Use \`/plugin install\` to install.`);
+    for (const p of shown) {
+      const status = installedIds.has(p.pluginId) ? " \u2705" : "";
+      const count = p.installCount ? ` | ${p.installCount.toLocaleString()} installs` : "";
+      embed.addFields({
+        name: `${p.name}${status}`,
+        value: `${truncate(p.description, 150)}
+*${p.marketplaceName}*${count}`
+      });
+    }
+    await interaction.editReply({ embeds: [embed] });
+  } catch (err) {
+    await interaction.editReply(`Error: ${err.message}`);
+  }
+}
+async function handlePluginInstall(interaction) {
+  const pluginId = interaction.options.getString("plugin", true);
+  const { scope, cwd, error } = resolveScopeAndCwd(interaction);
+  if (error) {
+    await interaction.reply({ content: error, ephemeral: true });
+    return;
+  }
+  await interaction.deferReply({ ephemeral: true });
+  try {
+    const result = await installPlugin(pluginId, scope, cwd);
+    const embed = new EmbedBuilder2().setColor(3066993).setTitle("Plugin Installed").setDescription(`**${pluginId}** installed with \`${scope}\` scope.`).addFields({ name: "Output", value: truncate(result, 1e3) || "Done." });
+    await interaction.editReply({ embeds: [embed] });
+    log(`Plugin "${pluginId}" installed (scope=${scope}) by ${interaction.user.tag}`);
+  } catch (err) {
+    await interaction.editReply(`Failed to install: ${err.message}`);
+  }
+}
+async function handlePluginRemove(interaction) {
+  const pluginId = interaction.options.getString("plugin", true);
+  const { scope, cwd, error } = resolveScopeAndCwd(interaction);
+  if (error) {
+    await interaction.reply({ content: error, ephemeral: true });
+    return;
+  }
+  await interaction.deferReply({ ephemeral: true });
+  try {
+    const result = await uninstallPlugin(pluginId, scope, cwd);
+    await interaction.editReply(`Plugin **${pluginId}** removed.
+${truncate(result, 500)}`);
+    log(`Plugin "${pluginId}" removed (scope=${scope}) by ${interaction.user.tag}`);
+  } catch (err) {
+    await interaction.editReply(`Failed to remove: ${err.message}`);
+  }
+}
+async function handlePluginList(interaction) {
+  await interaction.deferReply({ ephemeral: true });
+  try {
+    const plugins = await listInstalled();
+    if (plugins.length === 0) {
+      await interaction.editReply("No plugins installed.");
+      return;
+    }
+    const embed = new EmbedBuilder2().setColor(3447003).setTitle(`Installed Plugins (${plugins.length})`);
+    for (const p of plugins) {
+      const icon = p.enabled ? "\u2705" : "\u274C";
+      const scopeLabel = p.scope.charAt(0).toUpperCase() + p.scope.slice(1);
+      const project = p.projectPath ? `
+Project: \`${p.projectPath}\`` : "";
+      embed.addFields({
+        name: `${icon} ${p.id}`,
+        value: `v${p.version} | ${scopeLabel} scope${project}`
+      });
+    }
+    await interaction.editReply({ embeds: [embed] });
+  } catch (err) {
+    await interaction.editReply(`Error: ${err.message}`);
+  }
+}
+async function handlePluginInfo(interaction) {
+  const pluginId = interaction.options.getString("plugin", true);
+  await interaction.deferReply({ ephemeral: true });
+  try {
+    const parts = pluginId.split("@");
+    const pluginName = parts[0];
+    const marketplaceName = parts[1];
+    const installed = await listInstalled();
+    const installedEntry = installed.find((p) => p.id === pluginId);
+    let detail = null;
+    if (marketplaceName) {
+      detail = await getPluginDetail(pluginName, marketplaceName);
+    }
+    const embed = new EmbedBuilder2().setColor(15965202).setTitle(`Plugin: ${pluginName}`);
+    if (detail) {
+      embed.setDescription(detail.description);
+      if (detail.author) {
+        embed.addFields({ name: "Author", value: detail.author.name, inline: true });
+      }
+      if (detail.category) {
+        embed.addFields({ name: "Category", value: detail.category, inline: true });
+      }
+      if (detail.version) {
+        embed.addFields({ name: "Version", value: detail.version, inline: true });
+      }
+      if (detail.tags?.length) {
+        embed.addFields({ name: "Tags", value: detail.tags.join(", "), inline: false });
+      }
+      if (detail.homepage) {
+        embed.addFields({ name: "Homepage", value: detail.homepage, inline: false });
+      }
+      if (detail.lspServers) {
+        embed.addFields({ name: "LSP Servers", value: Object.keys(detail.lspServers).join(", "), inline: true });
+      }
+      if (detail.mcpServers) {
+        embed.addFields({ name: "MCP Servers", value: Object.keys(detail.mcpServers).join(", "), inline: true });
+      }
+    }
+    if (installedEntry) {
+      const icon = installedEntry.enabled ? "\u2705 Enabled" : "\u274C Disabled";
+      embed.addFields(
+        { name: "Status", value: `${icon} | v${installedEntry.version}`, inline: true },
+        { name: "Scope", value: installedEntry.scope, inline: true },
+        { name: "Installed", value: new Date(installedEntry.installedAt).toLocaleDateString(), inline: true }
+      );
+    } else {
+      embed.addFields({ name: "Status", value: "Not installed", inline: true });
+    }
+    if (marketplaceName) {
+      embed.setFooter({ text: `Marketplace: ${marketplaceName}` });
+    }
+    await interaction.editReply({ embeds: [embed] });
+  } catch (err) {
+    await interaction.editReply(`Error: ${err.message}`);
+  }
+}
+async function handlePluginEnable(interaction) {
+  const pluginId = interaction.options.getString("plugin", true);
+  const { scope, cwd, error } = resolveScopeAndCwd(interaction);
+  if (error) {
+    await interaction.reply({ content: error, ephemeral: true });
+    return;
+  }
+  await interaction.deferReply({ ephemeral: true });
+  try {
+    await enablePlugin(pluginId, scope, cwd);
+    await interaction.editReply(`Plugin **${pluginId}** enabled (\`${scope}\` scope).`);
+    log(`Plugin "${pluginId}" enabled (scope=${scope}) by ${interaction.user.tag}`);
+  } catch (err) {
+    await interaction.editReply(`Failed to enable: ${err.message}`);
+  }
+}
+async function handlePluginDisable(interaction) {
+  const pluginId = interaction.options.getString("plugin", true);
+  const { scope, cwd, error } = resolveScopeAndCwd(interaction);
+  if (error) {
+    await interaction.reply({ content: error, ephemeral: true });
+    return;
+  }
+  await interaction.deferReply({ ephemeral: true });
+  try {
+    await disablePlugin(pluginId, scope, cwd);
+    await interaction.editReply(`Plugin **${pluginId}** disabled (\`${scope}\` scope).`);
+    log(`Plugin "${pluginId}" disabled (scope=${scope}) by ${interaction.user.tag}`);
+  } catch (err) {
+    await interaction.editReply(`Failed to disable: ${err.message}`);
+  }
+}
+async function handlePluginUpdate(interaction) {
+  const pluginId = interaction.options.getString("plugin", true);
+  const { scope, cwd, error } = resolveScopeAndCwd(interaction);
+  if (error) {
+    await interaction.reply({ content: error, ephemeral: true });
+    return;
+  }
+  await interaction.deferReply({ ephemeral: true });
+  try {
+    const result = await updatePlugin(pluginId, scope, cwd);
+    await interaction.editReply(`Plugin **${pluginId}** updated.
+${truncate(result, 500)}`);
+    log(`Plugin "${pluginId}" updated (scope=${scope}) by ${interaction.user.tag}`);
+  } catch (err) {
+    await interaction.editReply(`Failed to update: ${err.message}`);
+  }
+}
+async function handleMarketplaceAdd(interaction) {
+  const source = interaction.options.getString("source", true);
+  await interaction.deferReply({ ephemeral: true });
+  try {
+    const result = await addMarketplace(source);
+    await interaction.editReply(`Marketplace added from \`${source}\`.
+${truncate(result, 500)}`);
+    log(`Marketplace "${source}" added by ${interaction.user.tag}`);
+  } catch (err) {
+    await interaction.editReply(`Failed to add marketplace: ${err.message}`);
+  }
+}
+async function handleMarketplaceRemove(interaction) {
+  const name = interaction.options.getString("name", true);
+  await interaction.deferReply({ ephemeral: true });
+  try {
+    const result = await removeMarketplace(name);
+    await interaction.editReply(`Marketplace **${name}** removed.
+${truncate(result, 500)}`);
+    log(`Marketplace "${name}" removed by ${interaction.user.tag}`);
+  } catch (err) {
+    await interaction.editReply(`Failed to remove marketplace: ${err.message}`);
+  }
+}
+async function handleMarketplaceList(interaction) {
+  await interaction.deferReply({ ephemeral: true });
+  try {
+    const marketplaces = await listMarketplaces();
+    if (marketplaces.length === 0) {
+      await interaction.editReply("No marketplaces registered.");
+      return;
+    }
+    const embed = new EmbedBuilder2().setColor(10181046).setTitle(`Marketplaces (${marketplaces.length})`);
+    for (const m of marketplaces) {
+      const source = m.repo || m.url || m.source;
+      embed.addFields({
+        name: m.name,
+        value: `Source: \`${source}\`
+Path: \`${m.installLocation}\``
+      });
+    }
+    await interaction.editReply({ embeds: [embed] });
+  } catch (err) {
+    await interaction.editReply(`Error: ${err.message}`);
+  }
+}
+async function handleMarketplaceUpdate(interaction) {
+  const name = interaction.options.getString("name") || void 0;
+  await interaction.deferReply({ ephemeral: true });
+  try {
+    const result = await updateMarketplaces(name);
+    await interaction.editReply(`Marketplace${name ? ` **${name}**` : "s"} updated.
+${truncate(result, 500)}`);
+    log(`Marketplace${name ? ` "${name}"` : "s"} updated by ${interaction.user.tag}`);
+  } catch (err) {
+    await interaction.editReply(`Failed to update: ${err.message}`);
+  }
+}
+async function handlePluginAutocomplete(interaction) {
+  const sub = interaction.options.getSubcommand();
+  const focused = interaction.options.getFocused().toLowerCase();
+  try {
+    if (sub === "install" || sub === "info" && !focused.includes("@")) {
+      const { available } = await listAvailable();
+      const filtered = focused ? available.filter((p) => p.name.toLowerCase().includes(focused) || p.pluginId.toLowerCase().includes(focused) || p.description.toLowerCase().includes(focused)) : available;
+      filtered.sort((a, b) => (b.installCount ?? 0) - (a.installCount ?? 0));
+      const choices = filtered.slice(0, 25).map((p) => ({
+        name: `${p.name} (${p.marketplaceName})`.slice(0, 100),
+        value: p.pluginId
+      }));
+      await interaction.respond(choices);
+    } else if (["remove", "enable", "disable", "update", "info"].includes(sub)) {
+      const installed = await listInstalled();
+      const filtered = focused ? installed.filter((p) => p.id.toLowerCase().includes(focused)) : installed;
+      const choices = filtered.slice(0, 25).map((p) => ({
+        name: `${p.id} (v${p.version}, ${p.scope})`.slice(0, 100),
+        value: p.id
+      }));
+      await interaction.respond(choices);
+    } else if (sub === "marketplace-remove" || sub === "marketplace-update") {
+      const marketplaces = await listMarketplaces();
+      const filtered = focused ? marketplaces.filter((m) => m.name.toLowerCase().includes(focused)) : marketplaces;
+      const choices = filtered.slice(0, 25).map((m) => ({
+        name: m.name,
+        value: m.name
+      }));
+      await interaction.respond(choices);
+    } else {
+      await interaction.respond([]);
+    }
+  } catch {
+    await interaction.respond([]);
+  }
+}
 
 // src/message-handler.ts
+import sharp from "sharp";
+var SUPPORTED_IMAGE_TYPES = /* @__PURE__ */ new Set([
+  "image/jpeg",
+  "image/png",
+  "image/gif",
+  "image/webp"
+]);
+var MAX_IMAGE_SIZE = 20 * 1024 * 1024;
+var MAX_BASE64_BYTES = 5 * 1024 * 1024;
 var userLastMessage = /* @__PURE__ */ new Map();
+async function resizeImageToFit(buf, mediaType) {
+  if (buf.length <= MAX_BASE64_BYTES) return buf;
+  const isJpeg = mediaType === "image/jpeg";
+  const format = isJpeg ? "jpeg" : "webp";
+  let img = sharp(buf);
+  const meta = await img.metadata();
+  const width = meta.width || 1;
+  const height = meta.height || 1;
+  let scale = 1;
+  for (let i = 0; i < 5; i++) {
+    scale *= 0.7;
+    const resized = await sharp(buf).resize(Math.round(width * scale), Math.round(height * scale), { fit: "inside" })[format]({ quality: 80 }).toBuffer();
+    if (resized.length <= MAX_BASE64_BYTES) return resized;
+  }
+  return sharp(buf).resize(Math.round(width * scale * 0.5), Math.round(height * scale * 0.5), { fit: "inside" }).jpeg({ quality: 60 }).toBuffer();
+}
+async function fetchImageAsBase64(url, mediaType) {
+  const res = await fetch(url);
+  if (!res.ok) throw new Error(`Failed to download image: ${res.status}`);
+  let buf = Buffer.from(await res.arrayBuffer());
+  if (buf.length > MAX_BASE64_BYTES) {
+    buf = await resizeImageToFit(buf, mediaType);
+    const newType = mediaType === "image/jpeg" ? "image/jpeg" : "image/webp";
+    return { data: buf.toString("base64"), mediaType: newType };
+  }
+  return { data: buf.toString("base64"), mediaType };
+}
 async function handleMessage(message) {
   if (message.author.bot) return;
   const session = getSessionByChannel(message.channelId);
@@ -1959,12 +2621,42 @@ async function handleMessage(message) {
       return;
     }
   }
-  const content = message.content.trim();
-  if (!content) return;
+  const text = message.content.trim();
+  const imageAttachments = message.attachments.filter(
+    (a) => a.contentType && SUPPORTED_IMAGE_TYPES.has(a.contentType) && a.size <= MAX_IMAGE_SIZE
+  );
+  if (!text && imageAttachments.size === 0) return;
   try {
     const channel = message.channel;
-    const stream = sendPrompt(session.id, content);
-    await handleOutputStream(stream, channel, session.id, session.verbose);
+    let prompt;
+    if (imageAttachments.size === 0) {
+      prompt = text;
+    } else {
+      const blocks = [];
+      const imageResults = await Promise.allSettled(
+        imageAttachments.map((a) => fetchImageAsBase64(a.url, a.contentType))
+      );
+      for (const result of imageResults) {
+        if (result.status === "fulfilled") {
+          blocks.push({
+            type: "image",
+            source: {
+              type: "base64",
+              media_type: result.value.mediaType,
+              data: result.value.data
+            }
+          });
+        }
+      }
+      if (text) {
+        blocks.push({ type: "text", text });
+      } else if (blocks.length > 0) {
+        blocks.push({ type: "text", text: "What is in this image?" });
+      }
+      prompt = blocks;
+    }
+    const stream = sendPrompt(session.id, prompt);
+    await handleOutputStream(stream, channel, session.id, session.verbose, session.mode);
   } catch (err) {
     await message.reply({
       content: `Error: ${err.message}`,
@@ -1974,6 +2666,12 @@ async function handleMessage(message) {
 }
 
 // src/button-handler.ts
+import {
+  ActionRowBuilder as ActionRowBuilder2,
+  ButtonBuilder as ButtonBuilder2,
+  ButtonStyle as ButtonStyle2,
+  StringSelectMenuBuilder as StringSelectMenuBuilder2
+} from "discord.js";
 async function handleButton(interaction) {
   if (!isUserAllowed(interaction.user.id, config.allowedUsers, config.allowAllUsers)) {
     await interaction.reply({ content: "Not authorized.", ephemeral: true });
@@ -2005,7 +2703,7 @@ async function handleButton(interaction) {
       const channel = interaction.channel;
       const stream = continueSession(sessionId);
       await interaction.editReply("Continuing...");
-      await handleOutputStream(stream, channel, sessionId, session.verbose);
+      await handleOutputStream(stream, channel, sessionId, session.verbose, session.mode);
     } catch (err) {
       await interaction.editReply(`Error: ${err.message}`);
     }
@@ -2039,7 +2737,79 @@ ${display}
       const channel = interaction.channel;
       const stream = sendPrompt(sessionId, optionText);
       await interaction.editReply(`Selected option ${optionIndex + 1}`);
-      await handleOutputStream(stream, channel, sessionId, session.verbose);
+      await handleOutputStream(stream, channel, sessionId, session.verbose, session.mode);
+    } catch (err) {
+      await interaction.editReply(`Error: ${err.message}`);
+    }
+    return;
+  }
+  if (customId.startsWith("pick:")) {
+    const parts = customId.split(":");
+    const sessionId = parts[1];
+    const questionIndex = parseInt(parts[2], 10);
+    const answer = parts.slice(3).join(":");
+    const session = getSession(sessionId);
+    if (!session) {
+      await interaction.reply({ content: "Session not found.", ephemeral: true });
+      return;
+    }
+    setPendingAnswer(sessionId, questionIndex, answer);
+    const totalQuestions = getQuestionCount(sessionId);
+    const pending = getPendingAnswers(sessionId);
+    const answeredCount = pending?.size || 0;
+    try {
+      const original = interaction.message;
+      const updatedComponents = original.components.map((row) => {
+        const firstComponent = row.components?.[0];
+        if (!firstComponent?.customId?.startsWith("pick:")) return row;
+        const rowQi = parseInt(firstComponent.customId.split(":")[2], 10);
+        if (rowQi !== questionIndex) return row;
+        const newRow = new ActionRowBuilder2();
+        for (const btn of row.components) {
+          const btnAnswer = btn.customId.split(":").slice(3).join(":");
+          const isSelected = btnAnswer === answer;
+          newRow.addComponents(
+            new ButtonBuilder2().setCustomId(btn.customId).setLabel(btn.label).setStyle(isSelected ? ButtonStyle2.Success : ButtonStyle2.Secondary)
+          );
+        }
+        return newRow;
+      });
+      await original.edit({ components: updatedComponents });
+    } catch {
+    }
+    await interaction.reply({
+      content: `Selected for Q${questionIndex + 1}: **${truncate(answer, 100)}** (${answeredCount}/${totalQuestions} answered)`,
+      ephemeral: true
+    });
+    return;
+  }
+  if (customId.startsWith("submit-answers:")) {
+    const sessionId = customId.slice(15);
+    const session = getSession(sessionId);
+    if (!session) {
+      await interaction.reply({ content: "Session not found.", ephemeral: true });
+      return;
+    }
+    const totalQuestions = getQuestionCount(sessionId);
+    const pending = getPendingAnswers(sessionId);
+    if (!pending || pending.size === 0) {
+      await interaction.reply({ content: "No answers selected yet. Pick an answer for each question first.", ephemeral: true });
+      return;
+    }
+    const answerLines = [];
+    for (let i = 0; i < totalQuestions; i++) {
+      const ans = pending.get(i);
+      answerLines.push(`Q${i + 1}: ${ans || "(no answer)"}`);
+    }
+    const combined = answerLines.join("\n");
+    clearPendingAnswers(sessionId);
+    await interaction.deferReply();
+    try {
+      const channel = interaction.channel;
+      const stream = sendPrompt(sessionId, combined);
+      await interaction.editReply(`Submitted answers:
+${combined}`);
+      await handleOutputStream(stream, channel, sessionId, session.verbose, session.mode);
     } catch (err) {
       await interaction.editReply(`Error: ${err.message}`);
     }
@@ -2048,7 +2818,8 @@ ${display}
   if (customId.startsWith("answer:")) {
     const parts = customId.split(":");
     const sessionId = parts[1];
-    const answer = parts.slice(2).join(":");
+    const hasQuestionIndex = /^\d+$/.test(parts[2]);
+    const answer = hasQuestionIndex ? parts.slice(3).join(":") : parts.slice(2).join(":");
     const session = getSession(sessionId);
     if (!session) {
       await interaction.reply({ content: "Session not found.", ephemeral: true });
@@ -2059,7 +2830,7 @@ ${display}
       const channel = interaction.channel;
       const stream = sendPrompt(sessionId, answer);
       await interaction.editReply(`Answered: **${truncate(answer, 100)}**`);
-      await handleOutputStream(stream, channel, sessionId, session.verbose);
+      await handleOutputStream(stream, channel, sessionId, session.verbose, session.mode);
     } catch (err) {
       await interaction.editReply(`Error: ${err.message}`);
     }
@@ -2079,12 +2850,45 @@ ${display}
       const channel = interaction.channel;
       const stream = sendPrompt(sessionId, answer);
       await interaction.editReply(`Answered: ${answer}`);
-      await handleOutputStream(stream, channel, sessionId, session.verbose);
+      await handleOutputStream(stream, channel, sessionId, session.verbose, session.mode);
     } catch (err) {
       await interaction.editReply(`Error: ${err.message}`);
     }
     return;
   }
+  if (customId.startsWith("mode:")) {
+    const parts = customId.split(":");
+    const sessionId = parts[1];
+    const newMode = parts[2];
+    const session = getSession(sessionId);
+    if (!session) {
+      await interaction.reply({ content: "Session not found.", ephemeral: true });
+      return;
+    }
+    setMode(sessionId, newMode);
+    const labels = {
+      auto: "\u26A1 Auto \u2014 full autonomy",
+      plan: "\u{1F4CB} Plan \u2014 plans before changes",
+      normal: "\u{1F6E1}\uFE0F Normal \u2014 asks before destructive ops"
+    };
+    await interaction.reply({
+      content: `Mode switched to **${labels[newMode]}**`,
+      ephemeral: true
+    });
+    try {
+      const original = interaction.message;
+      const updatedComponents = original.components.map((row) => {
+        const first = row.components?.[0];
+        if (first?.customId?.startsWith("mode:")) {
+          return makeModeButtons(sessionId, newMode);
+        }
+        return row;
+      });
+      await original.edit({ components: updatedComponents });
+    } catch {
+    }
+    return;
+  }
   await interaction.reply({ content: "Unknown button.", ephemeral: true });
 }
 async function handleSelectMenu(interaction) {
@@ -2093,8 +2897,48 @@ async function handleSelectMenu(interaction) {
     return;
   }
   const customId = interaction.customId;
+  if (customId.startsWith("pick-select:")) {
+    const parts = customId.split(":");
+    const sessionId = parts[1];
+    const questionIndex = parseInt(parts[2], 10);
+    const selected = interaction.values[0];
+    const session = getSession(sessionId);
+    if (!session) {
+      await interaction.reply({ content: "Session not found.", ephemeral: true });
+      return;
+    }
+    setPendingAnswer(sessionId, questionIndex, selected);
+    const totalQuestions = getQuestionCount(sessionId);
+    const pending = getPendingAnswers(sessionId);
+    const answeredCount = pending?.size || 0;
+    try {
+      const original = interaction.message;
+      const updatedComponents = original.components.map((row) => {
+        const comp = row.components?.[0];
+        if (comp?.customId !== customId) return row;
+        const menu = new StringSelectMenuBuilder2().setCustomId(customId).setPlaceholder(`Selected: ${selected.slice(0, 80)}`);
+        for (const opt of comp.options) {
+          menu.addOptions({
+            label: opt.label,
+            description: opt.description || void 0,
+            value: opt.value,
+            default: opt.value === selected
+          });
+        }
+        return new ActionRowBuilder2().addComponents(menu);
+      });
+      await original.edit({ components: updatedComponents });
+    } catch {
+    }
+    await interaction.reply({
+      content: `Selected for Q${questionIndex + 1}: **${truncate(selected, 100)}** (${answeredCount}/${totalQuestions} answered)`,
+      ephemeral: true
+    });
+    return;
+  }
   if (customId.startsWith("answer-select:")) {
-    const sessionId = customId.slice(14);
+    const afterPrefix = customId.slice(14);
+    const sessionId = afterPrefix.includes(":") ? afterPrefix.split(":")[0] : afterPrefix;
     const selected = interaction.values[0];
     const session = getSession(sessionId);
     if (!session) {
@@ -2106,7 +2950,7 @@ async function handleSelectMenu(interaction) {
       const channel = interaction.channel;
       const stream = sendPrompt(sessionId, selected);
       await interaction.editReply(`Answered: **${truncate(selected, 100)}**`);
-      await handleOutputStream(stream, channel, sessionId, session.verbose);
+      await handleOutputStream(stream, channel, sessionId, session.verbose, session.mode);
     } catch (err) {
       await interaction.editReply(`Error: ${err.message}`);
     }
@@ -2125,7 +2969,7 @@ async function handleSelectMenu(interaction) {
       const channel = interaction.channel;
       const stream = sendPrompt(sessionId, selected);
       await interaction.editReply(`Selected: ${truncate(selected, 100)}`);
-      await handleOutputStream(stream, channel, sessionId, session.verbose);
+      await handleOutputStream(stream, channel, sessionId, session.verbose, session.mode);
     } catch (err) {
       await interaction.editReply(`Error: ${err.message}`);
     }
@@ -2210,12 +3054,17 @@ async function startBot() {
             return await handleAgent(interaction);
           case "project":
             return await handleProject(interaction);
+          case "plugin":
+            return await handlePlugin(interaction);
         }
       }
       if (interaction.isAutocomplete()) {
         if (interaction.commandName === "claude") {
           return await handleClaudeAutocomplete(interaction);
         }
+        if (interaction.commandName === "plugin") {
+          return await handlePluginAutocomplete(interaction);
+        }
       }
       if (interaction.isButton()) {
         return await handleButton(interaction);

package/dist/cli.js

@@ -18,7 +18,7 @@ switch (command) {
       console.log("Run \x1B[36magentcord setup\x1B[0m to configure.\n");
       process.exit(1);
     }
-    const { startBot } = await import("./bot-RT4CJNKG.js");
+    const { startBot } = await import("./bot-MUOL7CRV.js");
     console.log("agentcord starting...");
     await startBot();
     break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentcord",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "type": "module",
   "description": "Discord bot for managing AI coding agent sessions (Claude Code, Codex, and more)",
   "bin": {
@@ -50,7 +50,8 @@
     "@anthropic-ai/claude-agent-sdk": "^0.2.36",
     "@clack/prompts": "^1.0.0",
     "discord.js": "^14.16.3",
-    "dotenv": "^17.2.4"
+    "dotenv": "^17.2.4",
+    "sharp": "^0.34.5"
   },
   "devDependencies": {
     "@types/node": "^22.10.0",