agentcord 0.1.7 → 0.1.9

package/dist/{bot-G6464LRS.js → bot-MOK6APSV.js}

@@ -53,7 +53,13 @@ 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")).addSubcommand((sub) => sub.setName("mode").setDescription("Set session mode (auto/plan/normal)").addStringOption((opt) => opt.setName("mode").setDescription("Session mode").setRequired(true).addChoices(
+  const session = new SlashCommandBuilder().setName("session").setDescription("Manage AI coding sessions").addSubcommand((sub) => sub.setName("new").setDescription("Create a new coding session").addStringOption((opt) => opt.setName("name").setDescription("Session name").setRequired(true)).addStringOption((opt) => opt.setName("provider").setDescription("AI provider").addChoices(
+    { name: "Claude Code", value: "claude" },
+    { name: "OpenAI Codex", value: "codex" }
+  )).addStringOption((opt) => opt.setName("directory").setDescription("Working directory (default: configured default)"))).addSubcommand((sub) => sub.setName("resume").setDescription("Resume an existing session from terminal").addStringOption((opt) => opt.setName("session-id").setDescription("Provider session ID").setRequired(true).setAutocomplete(true)).addStringOption((opt) => opt.setName("name").setDescription("Name for the Discord channel").setRequired(true)).addStringOption((opt) => opt.setName("provider").setDescription("AI provider").addChoices(
+    { name: "Claude Code", value: "claude" },
+    { name: "OpenAI Codex", value: "codex" }
+  )).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, gpt-5.3-codex)").setRequired(true))).addSubcommand((sub) => sub.setName("id").setDescription("Show the provider session ID for this channel")).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" }
@@ -69,11 +75,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(),
+    session.toJSON(),
     shell.toJSON(),
     agent.toJSON(),
-    project.toJSON()
+    project.toJSON(),
+    plugin.toJSON()
   ];
 }
 async function registerCommands() {
@@ -100,18 +128,277 @@ async function registerCommands() {
 
 // src/command-handlers.ts
 import {
-  EmbedBuilder as EmbedBuilder2,
+  EmbedBuilder as EmbedBuilder3,
   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
 import { execFile } from "child_process";
 import { existsSync as existsSync3 } from "fs";
+
+// src/providers/index.ts
+import { execFileSync } from "child_process";
+
+// src/providers/claude-provider.ts
 import { query } from "@anthropic-ai/claude-agent-sdk";
+var TASK_TOOLS = /* @__PURE__ */ new Set(["TaskCreate", "TaskUpdate", "TaskList", "TaskGet"]);
+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;
+}
+function buildClaudeSystemPrompt(parts) {
+  if (parts.length > 0) {
+    return { type: "preset", preset: "claude_code", append: parts.join("\n\n") };
+  }
+  return { type: "preset", preset: "claude_code" };
+}
+var ClaudeProvider = class {
+  name = "claude";
+  supports(feature) {
+    return [
+      "tmux",
+      "resume_from_terminal",
+      "plugins",
+      "ask_user_question",
+      "mode_switching",
+      "continue"
+    ].includes(feature);
+  }
+  async *sendPrompt(prompt, options) {
+    const systemPrompt = buildClaudeSystemPrompt(options.systemPromptParts);
+    function buildQueryPrompt() {
+      if (typeof prompt === "string") return prompt;
+      const claudeBlocks = prompt.filter((b) => b.type !== "local_image");
+      const userMessage = {
+        type: "user",
+        message: { role: "user", content: claudeBlocks },
+        parent_tool_use_id: null,
+        session_id: ""
+      };
+      return (async function* () {
+        yield userMessage;
+      })();
+    }
+    let retried = false;
+    let resumeId = options.providerSessionId;
+    while (true) {
+      let failed = false;
+      const stream = query({
+        prompt: buildQueryPrompt(),
+        options: {
+          cwd: options.directory,
+          resume: resumeId,
+          abortController: options.abortController,
+          permissionMode: "bypassPermissions",
+          allowDangerouslySkipPermissions: true,
+          model: options.model,
+          systemPrompt,
+          includePartialMessages: true,
+          settingSources: ["user", "project", "local"]
+        }
+      });
+      yield* this.translateStream(stream, resumeId, retried, (f, r) => {
+        failed = f;
+        retried = r;
+      });
+      if (failed && !retried) {
+        retried = true;
+        resumeId = void 0;
+        yield { type: "session_init", providerSessionId: "" };
+        continue;
+      }
+      break;
+    }
+  }
+  async *continueSession(options) {
+    const systemPrompt = buildClaudeSystemPrompt(options.systemPromptParts);
+    let retried = false;
+    let resumeId = options.providerSessionId;
+    while (true) {
+      let failed = false;
+      const stream = query({
+        prompt: "",
+        options: {
+          cwd: options.directory,
+          ...resumeId ? { continue: true, resume: resumeId } : {},
+          abortController: options.abortController,
+          permissionMode: "bypassPermissions",
+          allowDangerouslySkipPermissions: true,
+          model: options.model,
+          systemPrompt,
+          includePartialMessages: true,
+          settingSources: ["user", "project", "local"]
+        }
+      });
+      yield* this.translateStream(stream, resumeId, retried, (f, r) => {
+        failed = f;
+        retried = r;
+      });
+      if (failed && !retried) {
+        retried = true;
+        resumeId = void 0;
+        yield { type: "session_init", providerSessionId: "" };
+        continue;
+      }
+      break;
+    }
+  }
+  async *translateStream(stream, resumeId, alreadyRetried, setRetry) {
+    let currentToolName = null;
+    let currentToolInput = "";
+    for await (const message of stream) {
+      if (message.type === "system" && "subtype" in message && message.subtype === "init") {
+        yield { type: "session_init", providerSessionId: message.session_id };
+      }
+      if (message.type === "stream_event") {
+        const event = message.event;
+        if (event?.type === "content_block_start") {
+          if (event.content_block?.type === "tool_use") {
+            currentToolName = event.content_block.name || "tool";
+            currentToolInput = "";
+          }
+        }
+        if (event?.type === "content_block_delta") {
+          if (event.delta?.type === "text_delta" && event.delta.text) {
+            yield { type: "text_delta", text: event.delta.text };
+          }
+          if (event.delta?.type === "input_json_delta" && event.delta.partial_json) {
+            currentToolInput += event.delta.partial_json;
+          }
+        }
+        if (event?.type === "content_block_stop") {
+          if (currentToolName) {
+            if (currentToolName === "AskUserQuestion") {
+              yield { type: "ask_user", questionsJson: currentToolInput };
+            } else if (TASK_TOOLS.has(currentToolName)) {
+              yield { type: "task", action: currentToolName, dataJson: currentToolInput };
+            } else {
+              yield { type: "tool_start", toolName: currentToolName, toolInput: currentToolInput };
+            }
+            const imagePath = extractImagePath(currentToolName, currentToolInput);
+            if (imagePath) {
+              yield { type: "image_file", filePath: imagePath };
+            }
+            currentToolName = null;
+            currentToolInput = "";
+          }
+        }
+      }
+      if (message.type === "user") {
+        const content = message.message?.content;
+        let resultText = "";
+        let toolName = "";
+        if (Array.isArray(content)) {
+          for (const block of content) {
+            if (block.type === "tool_result" && block.content) {
+              if (typeof block.content === "string") {
+                resultText += block.content;
+              } else if (Array.isArray(block.content)) {
+                for (const sub of block.content) {
+                  if (sub.type === "text") resultText += sub.text;
+                }
+              }
+            }
+          }
+        }
+        if (resultText) {
+          yield { type: "tool_result", toolName, result: resultText };
+        }
+      }
+      if (message.type === "result") {
+        const r = message;
+        if (r.subtype !== "success" && !alreadyRetried && resumeId) {
+          setRetry(true, false);
+          break;
+        }
+        yield {
+          type: "result",
+          success: r.subtype === "success",
+          costUsd: r.total_cost_usd ?? 0,
+          durationMs: r.duration_ms ?? 0,
+          numTurns: r.num_turns ?? 0,
+          errors: r.errors ?? []
+        };
+      }
+    }
+  }
+};
+
+// src/providers/index.ts
+var providers = /* @__PURE__ */ new Map();
+providers.set("claude", new ClaudeProvider());
+var codexLoaded = false;
+var PROVIDER_PACKAGES = {
+  codex: "@openai/codex-sdk"
+};
+function isPackageInstalled(pkg) {
+  try {
+    execFileSync("npm", ["ls", pkg, "--global", "--depth=0"], { stdio: "pipe" });
+    return true;
+  } catch {
+  }
+  try {
+    execFileSync("npm", ["ls", pkg, "--depth=0"], { stdio: "pipe" });
+    return true;
+  } catch {
+  }
+  return false;
+}
+function installPackageGlobally(pkg) {
+  console.log(`[providers] Auto-installing ${pkg} globally...`);
+  execFileSync("npm", ["install", "-g", pkg], { stdio: "inherit" });
+  console.log(`[providers] ${pkg} installed successfully.`);
+}
+async function loadCodexProvider() {
+  const pkg = PROVIDER_PACKAGES.codex;
+  try {
+    const { CodexProvider } = await import("./codex-provider-672ILQC2.js");
+    providers.set("codex", new CodexProvider());
+    codexLoaded = true;
+    return;
+  } catch {
+  }
+  if (!isPackageInstalled(pkg)) {
+    try {
+      installPackageGlobally(pkg);
+    } catch (err) {
+      throw new Error(
+        `Failed to auto-install ${pkg}: ${err.message}. Install manually: npm install -g ${pkg}`
+      );
+    }
+  }
+  try {
+    const { CodexProvider } = await import("./codex-provider-672ILQC2.js");
+    providers.set("codex", new CodexProvider());
+    codexLoaded = true;
+  } catch (err) {
+    throw new Error(
+      `${pkg} is installed but failed to load: ${err.message}`
+    );
+  }
+}
+async function ensureProvider(name) {
+  if (providers.has(name)) return providers.get(name);
+  if (name === "codex" && !codexLoaded) {
+    await loadCodexProvider();
+    return providers.get("codex");
+  }
+  throw new Error(`Unknown provider: ${name}`);
+}
 
 // src/persistence.ts
 import { readFile, writeFile, mkdir, rename } from "fs/promises";
@@ -245,6 +532,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] = {
@@ -431,14 +721,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;
@@ -449,7 +744,7 @@ function detectYesNoPrompt(text) {
 }
 
 // src/session-manager.ts
-var SESSION_PREFIX = "claude-";
+var SESSION_PREFIX = "agentcord-";
 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.",
@@ -478,21 +773,27 @@ async function loadSessions() {
   const data = await sessionStore.read();
   if (!data) return;
   for (const s of data) {
-    const exists = await tmuxSessionExists(s.tmuxName);
+    const provider = s.provider ?? "claude";
+    const providerSessionId = s.providerSessionId ?? s.claudeSessionId;
+    if (provider === "claude") {
+      const exists = await tmuxSessionExists(s.tmuxName);
+      if (!exists) {
+        try {
+          await tmux("new-session", "-d", "-s", s.tmuxName, "-c", s.directory);
+        } catch {
+          console.warn(`Could not recreate tmux session ${s.tmuxName}`);
+        }
+      }
+    }
     sessions.set(s.id, {
       ...s,
+      provider,
+      providerSessionId,
       verbose: s.verbose ?? false,
       mode: s.mode ?? "auto",
       isGenerating: false
     });
     channelToSession.set(s.channelId, s.id);
-    if (!exists) {
-      try {
-        await tmux("new-session", "-d", "-s", s.tmuxName, "-c", s.directory);
-      } catch {
-        console.warn(`Could not recreate tmux session ${s.tmuxName}`);
-      }
-    }
   }
   console.log(`Restored ${sessions.size} session(s)`);
 }
@@ -504,8 +805,9 @@ async function saveSessions() {
       channelId: s.channelId,
       directory: s.directory,
       projectName: s.projectName,
+      provider: s.provider,
       tmuxName: s.tmuxName,
-      claudeSessionId: s.claudeSessionId,
+      providerSessionId: s.providerSessionId,
       model: s.model,
       agentPersona: s.agentPersona,
       verbose: s.verbose || void 0,
@@ -518,7 +820,7 @@ async function saveSessions() {
   }
   await sessionStore.write(data);
 }
-async function createSession(name, directory, channelId, projectName, claudeSessionId) {
+async function createSession(name, directory, channelId, projectName, provider = "claude", providerSessionId) {
   const resolvedDir = resolvePath(directory);
   if (!isPathAllowed(resolvedDir, config.allowedPaths)) {
     throw new Error(`Directory not in allowed paths: ${resolvedDir}`);
@@ -526,22 +828,27 @@ async function createSession(name, directory, channelId, projectName, claudeSess
   if (!existsSync3(resolvedDir)) {
     throw new Error(`Directory does not exist: ${resolvedDir}`);
   }
+  const providerInstance = await ensureProvider(provider);
+  const usesTmux = providerInstance.supports("tmux");
   let id = sanitizeSessionName(name);
-  let tmuxName = `${SESSION_PREFIX}${id}`;
+  let tmuxName = usesTmux ? `${SESSION_PREFIX}${id}` : "";
   let suffix = 1;
-  while (sessions.has(id) || await tmuxSessionExists(tmuxName)) {
+  while (sessions.has(id) || usesTmux && await tmuxSessionExists(tmuxName)) {
     suffix++;
     id = sanitizeSessionName(`${name}-${suffix}`);
-    tmuxName = `${SESSION_PREFIX}${id}`;
+    if (usesTmux) tmuxName = `${SESSION_PREFIX}${id}`;
+  }
+  if (usesTmux) {
+    await tmux("new-session", "-d", "-s", tmuxName, "-c", resolvedDir);
   }
-  await tmux("new-session", "-d", "-s", tmuxName, "-c", resolvedDir);
   const session = {
     id,
     channelId,
     directory: resolvedDir,
     projectName,
+    provider,
     tmuxName,
-    claudeSessionId,
+    providerSessionId,
     verbose: false,
     mode: "auto",
     isGenerating: false,
@@ -571,9 +878,11 @@ async function endSession(id) {
   if (session.isGenerating && session._controller) {
     session._controller.abort();
   }
-  try {
-    await tmux("kill-session", "-t", session.tmuxName);
-  } catch {
+  if (session.tmuxName) {
+    try {
+      await tmux("kill-session", "-t", session.tmuxName);
+    } catch {
+    }
   }
   channelToSession.delete(session.channelId);
   sessions.delete(id);
@@ -627,7 +936,7 @@ function setAgentPersona(sessionId, persona) {
     saveSessions();
   }
 }
-function buildSystemPrompt(session) {
+function buildSystemPromptParts(session) {
   const parts = [];
   const personality = getPersonality(session.projectName);
   if (personality) parts.push(personality);
@@ -637,10 +946,14 @@ function buildSystemPrompt(session) {
   }
   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") };
+  return parts;
+}
+function resetProviderSession(sessionId) {
+  const session = sessions.get(sessionId);
+  if (session) {
+    session.providerSessionId = void 0;
+    saveSessions();
   }
-  return { type: "preset", preset: "claude_code" };
 }
 async function* sendPrompt(sessionId, prompt) {
   const session = sessions.get(sessionId);
@@ -650,33 +963,25 @@ async function* sendPrompt(sessionId, prompt) {
   session._controller = controller;
   session.isGenerating = true;
   session.lastActivity = Date.now();
-  const systemPrompt = buildSystemPrompt(session);
+  const provider = await ensureProvider(session.provider);
+  const systemPromptParts = buildSystemPromptParts(session);
   try {
-    const stream = query({
-      prompt,
-      options: {
-        cwd: session.directory,
-        resume: session.claudeSessionId,
-        abortController: controller,
-        permissionMode: "bypassPermissions",
-        allowDangerouslySkipPermissions: true,
-        model: session.model,
-        systemPrompt,
-        includePartialMessages: true,
-        settingSources: ["user", "project", "local"]
-      }
+    const stream = provider.sendPrompt(prompt, {
+      directory: session.directory,
+      providerSessionId: session.providerSessionId,
+      model: session.model,
+      systemPromptParts,
+      abortController: controller
     });
-    for await (const message of stream) {
-      if (message.type === "system" && "subtype" in message && message.subtype === "init") {
-        session.claudeSessionId = message.session_id;
+    for await (const event of stream) {
+      if (event.type === "session_init") {
+        session.providerSessionId = event.providerSessionId || void 0;
         await saveSessions();
       }
-      if (message.type === "result") {
-        if ("total_cost_usd" in message) {
-          session.totalCost += message.total_cost_usd;
-        }
+      if (event.type === "result") {
+        session.totalCost += event.costUsd;
       }
-      yield message;
+      yield event;
     }
     session.messageCount++;
   } catch (err) {
@@ -699,32 +1004,25 @@ async function* continueSession(sessionId) {
   session._controller = controller;
   session.isGenerating = true;
   session.lastActivity = Date.now();
-  const systemPrompt = buildSystemPrompt(session);
+  const provider = await ensureProvider(session.provider);
+  const systemPromptParts = buildSystemPromptParts(session);
   try {
-    const stream = query({
-      prompt: "",
-      options: {
-        cwd: session.directory,
-        continue: true,
-        resume: session.claudeSessionId,
-        abortController: controller,
-        permissionMode: "bypassPermissions",
-        allowDangerouslySkipPermissions: true,
-        model: session.model,
-        systemPrompt,
-        includePartialMessages: true,
-        settingSources: ["user", "project", "local"]
-      }
+    const stream = provider.continueSession({
+      directory: session.directory,
+      providerSessionId: session.providerSessionId,
+      model: session.model,
+      systemPromptParts,
+      abortController: controller
     });
-    for await (const message of stream) {
-      if (message.type === "system" && "subtype" in message && message.subtype === "init") {
-        session.claudeSessionId = message.session_id;
+    for await (const event of stream) {
+      if (event.type === "session_init") {
+        session.providerSessionId = event.providerSessionId || void 0;
         await saveSessions();
       }
-      if (message.type === "result" && "total_cost_usd" in message) {
-        session.totalCost += message.total_cost_usd;
+      if (event.type === "result") {
+        session.totalCost += event.costUsd;
       }
-      yield message;
+      yield event;
     }
     session.messageCount++;
   } catch (err) {
@@ -745,16 +1043,21 @@ function abortSession(sessionId) {
   const controller = session._controller;
   if (controller) {
     controller.abort();
+  }
+  if (session.isGenerating) {
+    session.isGenerating = false;
+    delete session._controller;
+    saveSessions();
     return true;
   }
-  return false;
+  return !!controller;
 }
 function getAttachInfo(sessionId) {
   const session = sessions.get(sessionId);
-  if (!session) return null;
+  if (!session || !session.tmuxName) return null;
   return {
     command: `tmux attach -t ${session.tmuxName}`,
-    sessionId: session.claudeSessionId
+    sessionId: session.providerSessionId
   };
 }
 async function listTmuxSessions() {
@@ -777,16 +1080,209 @@ 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 {
-  EmbedBuilder,
+  AttachmentBuilder,
+  EmbedBuilder as EmbedBuilder2,
   ActionRowBuilder,
   ButtonBuilder,
   ButtonStyle,
   StringSelectMenuBuilder
 } from "discord.js";
+import { existsSync as existsSync4 } from "fs";
+
+// src/codex-renderer.ts
+import { EmbedBuilder } from "discord.js";
+function renderCommandExecutionEmbed(event) {
+  const statusEmoji = event.status === "completed" ? event.exitCode === 0 ? "\u2705" : "\u274C" : event.status === "failed" ? "\u274C" : "\u{1F504}";
+  const embed = new EmbedBuilder().setColor(event.exitCode === 0 ? 3066993 : event.status === "failed" ? 15158332 : 15965202).setTitle(`${statusEmoji} Command`);
+  embed.setDescription(`\`\`\`bash
+$ ${truncate(event.command, 900)}
+\`\`\``);
+  if (event.output) {
+    embed.addFields({
+      name: "Output",
+      value: `\`\`\`
+${truncate(event.output, 900)}
+\`\`\``
+    });
+  }
+  if (event.exitCode !== null) {
+    embed.setFooter({ text: `Exit code: ${event.exitCode}` });
+  }
+  return embed;
+}
+function renderFileChangesEmbed(event) {
+  const kindEmoji = { add: "+", update: "~", delete: "-" };
+  const lines = event.changes.map(
+    (c) => `${kindEmoji[c.changeKind] || "?"} ${c.filePath}`
+  );
+  return new EmbedBuilder().setColor(3447003).setTitle("\u{1F4C1} Files Changed").setDescription(`\`\`\`diff
+${truncate(lines.join("\n"), 3900)}
+\`\`\``);
+}
+function renderReasoningEmbed(event) {
+  return new EmbedBuilder().setColor(10181046).setTitle("\u{1F9E0} Reasoning").setDescription(truncate(event.text, 4e3));
+}
+function renderCodexTodoListEmbed(event) {
+  const lines = event.items.map(
+    (item) => `${item.completed ? "\u2705" : "\u2B1C"} ${item.text}`
+  ).join("\n");
+  return new EmbedBuilder().setColor(3447003).setTitle("\u{1F4CB} Task List").setDescription(truncate(lines, 4e3));
+}
+
+// src/output-handler.ts
+var ABORT_PATTERNS = ["abort", "cancel", "interrupt", "killed", "signal"];
+function isAbortLike(err) {
+  if (err.name === "AbortError") return true;
+  const msg = (err.message || "").toLowerCase();
+  return ABORT_PATTERNS.some((p) => msg.includes(p));
+}
+function isAbortError(errors) {
+  return errors.some((e) => ABORT_PATTERNS.some((p) => e.toLowerCase().includes(p)));
+}
 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;
@@ -807,11 +1303,6 @@ function makeStopButton(sessionId) {
     new ButtonBuilder().setCustomId(`stop:${sessionId}`).setLabel("Stop").setStyle(ButtonStyle.Danger)
   );
 }
-function makeCompletionButtons(sessionId) {
-  return new ActionRowBuilder().addComponents(
-    new ButtonBuilder().setCustomId(`continue:${sessionId}`).setLabel("Continue").setStyle(ButtonStyle.Primary)
-  );
-}
 function makeOptionButtons(sessionId, options) {
   const rows = [];
   const maxOptions = Math.min(options.length, 10);
@@ -847,6 +1338,10 @@ function makeYesNoButtons(sessionId) {
     new ButtonBuilder().setCustomId(`confirm:${sessionId}:no`).setLabel("No").setStyle(ButtonStyle.Danger)
   );
 }
+function shouldSuppressCommandExecution(command) {
+  const normalized = command.toLowerCase();
+  return normalized.includes("total-recall");
+}
 var MessageStreamer = class {
   channel;
   sessionId;
@@ -956,6 +1451,25 @@ var MessageStreamer = class {
     this.currentMessage = null;
     this.currentText = "";
   }
+  /** Discard accumulated text and delete the live message if one exists */
+  async discard() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    while (this.flushing) {
+      await new Promise((r) => setTimeout(r, 50));
+    }
+    if (this.currentMessage) {
+      try {
+        await this.currentMessage.delete();
+      } catch {
+      }
+      this.currentMessage = null;
+    }
+    this.currentText = "";
+    this.dirty = false;
+  }
   getText() {
     return this.currentText;
   }
@@ -966,17 +1480,6 @@ var MessageStreamer = class {
     }
   }
 };
-var USER_FACING_TOOLS = /* @__PURE__ */ new Set([
-  "AskUserQuestion",
-  "EnterPlanMode",
-  "ExitPlanMode"
-]);
-var TASK_TOOLS = /* @__PURE__ */ new Set([
-  "TaskCreate",
-  "TaskUpdate",
-  "TaskList",
-  "TaskGet"
-]);
 var STATUS_EMOJI = {
   pending: "\u2B1C",
   // white square
@@ -987,26 +1490,64 @@ var STATUS_EMOJI = {
   deleted: "\u{1F5D1}\uFE0F"
   // wastebasket
 };
-function renderAskUserQuestion(toolInput, sessionId) {
+function renderTaskToolEmbed(action, dataJson) {
   try {
-    const data = JSON.parse(toolInput);
+    const data = JSON.parse(dataJson);
+    if (action === "TaskCreate") {
+      const embed = new EmbedBuilder2().setColor(3447003).setTitle("\u{1F4CB} New Task").setDescription(`**${data.subject || "Untitled"}**`);
+      if (data.description) {
+        embed.addFields({ name: "Details", value: truncate(data.description, 300) });
+      }
+      return embed;
+    }
+    if (action === "TaskUpdate") {
+      const emoji = STATUS_EMOJI[data.status] || "\u{1F4CB}";
+      const parts = [];
+      if (data.status) parts.push(`${emoji} **${data.status}**`);
+      if (data.subject) parts.push(data.subject);
+      return new EmbedBuilder2().setColor(data.status === "completed" ? 3066993 : 15965202).setTitle(`Task #${data.taskId || "?"} Updated`).setDescription(parts.join(" \u2014 ") || "Updated");
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function renderTaskListEmbed(resultText) {
+  if (!resultText.trim()) return null;
+  let formatted = resultText;
+  for (const [status, emoji] of Object.entries(STATUS_EMOJI)) {
+    formatted = formatted.replaceAll(status, `${emoji} ${status}`);
+  }
+  return new EmbedBuilder2().setColor(10181046).setTitle("\u{1F4CB} Task Board").setDescription(truncate(formatted, 4e3));
+}
+function renderAskUserQuestion(questionsJson, sessionId) {
+  try {
+    const data = JSON.parse(questionsJson);
     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 embed = new EmbedBuilder().setColor(15965202).setTitle(q.header || "Question").setDescription(q.question);
+    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 EmbedBuilder2().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),
@@ -1021,46 +1562,21 @@ function renderAskUserQuestion(toolInput, sessionId) {
       }
       embeds.push(embed);
     }
-    return { embeds, components };
-  } catch {
-    return null;
-  }
-}
-function renderTaskToolEmbed(toolName, toolInput) {
-  try {
-    const data = JSON.parse(toolInput);
-    if (toolName === "TaskCreate") {
-      const embed = new EmbedBuilder().setColor(3447003).setTitle("\u{1F4CB} New Task").setDescription(`**${data.subject || "Untitled"}**`);
-      if (data.description) {
-        embed.addFields({ name: "Details", value: truncate(data.description, 300) });
-      }
-      return embed;
-    }
-    if (toolName === "TaskUpdate") {
-      const emoji = STATUS_EMOJI[data.status] || "\u{1F4CB}";
-      const parts = [];
-      if (data.status) parts.push(`${emoji} **${data.status}**`);
-      if (data.subject) parts.push(data.subject);
-      return new EmbedBuilder().setColor(data.status === "completed" ? 3066993 : 15965202).setTitle(`Task #${data.taskId || "?"} Updated`).setDescription(parts.join(" \u2014 ") || "Updated");
+    if (isMulti) {
+      components.push(
+        new ActionRowBuilder().addComponents(
+          new ButtonBuilder().setCustomId(`submit-answers:${sessionId}`).setLabel("Submit Answers").setStyle(ButtonStyle.Success)
+        )
+      );
     }
-    return null;
+    return { embeds, components };
   } catch {
     return null;
   }
 }
-function renderTaskListEmbed(resultText) {
-  if (!resultText.trim()) return null;
-  let formatted = resultText;
-  for (const [status, emoji] of Object.entries(STATUS_EMOJI)) {
-    formatted = formatted.replaceAll(status, `${emoji} ${status}`);
-  }
-  return new EmbedBuilder().setColor(10181046).setTitle("\u{1F4CB} Task Board").setDescription(truncate(formatted, 4e3));
-}
-async function handleOutputStream(stream, channel, sessionId, verbose = false, mode = "auto") {
+async function handleOutputStream(stream, channel, sessionId, verbose = false, mode = "auto", _provider = "claude") {
   const streamer = new MessageStreamer(channel, sessionId);
-  let currentToolName = null;
-  let currentToolInput = "";
-  let lastFinishedToolName = null;
+  let lastToolName = null;
   channel.sendTyping().catch(() => {
   });
   const typingInterval = setInterval(() => {
@@ -1068,103 +1584,78 @@ async function handleOutputStream(stream, channel, sessionId, verbose = false, m
     });
   }, 8e3);
   try {
-    for await (const message of stream) {
-      if (message.type === "stream_event") {
-        const event = message.event;
-        if (event?.type === "content_block_start") {
-          if (event.content_block?.type === "tool_use") {
-            await streamer.finalize();
-            currentToolName = event.content_block.name || "tool";
-            currentToolInput = "";
-          }
+    for await (const event of stream) {
+      switch (event.type) {
+        case "text_delta": {
+          streamer.append(event.text);
+          break;
         }
-        if (event?.type === "content_block_delta") {
-          if (event.delta?.type === "text_delta" && event.delta.text) {
-            streamer.append(event.delta.text);
-          }
-          if (event.delta?.type === "input_json_delta" && event.delta.partial_json) {
-            currentToolInput += event.delta.partial_json;
+        case "ask_user": {
+          await streamer.discard();
+          const rendered = renderAskUserQuestion(event.questionsJson, sessionId);
+          if (rendered) {
+            rendered.components.push(makeStopButton(sessionId));
+            await channel.send({ embeds: rendered.embeds, components: rendered.components });
           }
+          break;
         }
-        if (event?.type === "content_block_stop") {
-          if (currentToolName) {
-            const isUserFacing = USER_FACING_TOOLS.has(currentToolName);
-            const isTaskTool = TASK_TOOLS.has(currentToolName);
-            const showTool = verbose || isUserFacing || isTaskTool;
-            if (showTool) {
-              const taskEmbed = isTaskTool ? renderTaskToolEmbed(currentToolName, currentToolInput) : null;
-              if (taskEmbed) {
-                await channel.send({
-                  embeds: [taskEmbed],
-                  components: [makeStopButton(sessionId)]
-                });
-              } else if (currentToolName === "AskUserQuestion") {
-                const rendered = renderAskUserQuestion(currentToolInput, sessionId);
-                if (rendered) {
-                  rendered.components.push(makeStopButton(sessionId));
-                  await channel.send({ embeds: rendered.embeds, components: rendered.components });
-                }
-              } else if (!isTaskTool) {
-                const toolInput = currentToolInput;
-                const displayInput = toolInput.length > 1e3 ? truncate(toolInput, 1e3) : toolInput;
-                const embed = new EmbedBuilder().setColor(isUserFacing ? 15965202 : 3447003).setTitle(isUserFacing ? `Waiting for input: ${currentToolName}` : `Tool: ${currentToolName}`).setDescription(`\`\`\`json
-${displayInput}
-\`\`\``);
-                const components = [makeStopButton(sessionId)];
-                if (toolInput.length > 1e3) {
-                  const contentId = storeExpandable(toolInput);
-                  components.unshift(
-                    new ActionRowBuilder().addComponents(
-                      new ButtonBuilder().setCustomId(`expand:${contentId}`).setLabel("Show Full Input").setStyle(ButtonStyle.Secondary)
-                    )
-                  );
-                }
-                await channel.send({ embeds: [embed], components });
-              }
+        case "task": {
+          await streamer.finalize();
+          const isTaskResult = event.action === "TaskList" || event.action === "TaskGet";
+          if (!isTaskResult) {
+            const taskEmbed = renderTaskToolEmbed(event.action, event.dataJson);
+            if (taskEmbed) {
+              await channel.send({
+                embeds: [taskEmbed],
+                components: [makeStopButton(sessionId)]
+              });
             }
-            lastFinishedToolName = currentToolName;
-            currentToolName = null;
-            currentToolInput = "";
           }
+          lastToolName = event.action;
+          break;
         }
-      }
-      if (message.type === "user") {
-        const showResult = verbose || lastFinishedToolName !== null && TASK_TOOLS.has(lastFinishedToolName);
-        if (!showResult) continue;
-        await streamer.finalize();
-        const content = message.message?.content;
-        let resultText = "";
-        if (Array.isArray(content)) {
-          for (const block of content) {
-            if (block.type === "tool_result" && block.content) {
-              if (typeof block.content === "string") {
-                resultText += block.content;
-              } else if (Array.isArray(block.content)) {
-                for (const sub of block.content) {
-                  if (sub.type === "text") resultText += sub.text;
-                }
-              }
+        case "tool_start": {
+          await streamer.finalize();
+          if (verbose) {
+            const displayInput = event.toolInput.length > 1e3 ? truncate(event.toolInput, 1e3) : event.toolInput;
+            const embed = new EmbedBuilder2().setColor(3447003).setTitle(`Tool: ${event.toolName}`).setDescription(`\`\`\`json
+${displayInput}
+\`\`\``);
+            const components = [makeStopButton(sessionId)];
+            if (event.toolInput.length > 1e3) {
+              const contentId = storeExpandable(event.toolInput);
+              components.unshift(
+                new ActionRowBuilder().addComponents(
+                  new ButtonBuilder().setCustomId(`expand:${contentId}`).setLabel("Show Full Input").setStyle(ButtonStyle.Secondary)
+                )
+              );
             }
+            await channel.send({ embeds: [embed], components });
           }
+          lastToolName = event.toolName;
+          break;
         }
-        if (resultText) {
-          const isTaskResult = lastFinishedToolName !== null && TASK_TOOLS.has(lastFinishedToolName);
+        case "tool_result": {
+          const isTaskResult = lastToolName !== null && (lastToolName === "TaskList" || lastToolName === "TaskGet");
+          const showResult = verbose || isTaskResult;
+          if (!showResult) break;
+          await streamer.finalize();
           if (isTaskResult && !verbose) {
-            const boardEmbed = renderTaskListEmbed(resultText);
+            const boardEmbed = renderTaskListEmbed(event.result);
             if (boardEmbed) {
               await channel.send({
                 embeds: [boardEmbed],
                 components: [makeStopButton(sessionId)]
               });
             }
-          } else {
-            const displayResult = resultText.length > 1e3 ? truncate(resultText, 1e3) : resultText;
-            const embed = new EmbedBuilder().setColor(1752220).setTitle("Tool Result").setDescription(`\`\`\`
+          } else if (event.result) {
+            const displayResult = event.result.length > 1e3 ? truncate(event.result, 1e3) : event.result;
+            const embed = new EmbedBuilder2().setColor(1752220).setTitle("Tool Result").setDescription(`\`\`\`
 ${displayResult}
 \`\`\``);
             const components = [makeStopButton(sessionId)];
-            if (resultText.length > 1e3) {
-              const contentId = storeExpandable(resultText);
+            if (event.result.length > 1e3) {
+              const contentId = storeExpandable(event.result);
               components.unshift(
                 new ActionRowBuilder().addComponents(
                   new ButtonBuilder().setCustomId(`expand:${contentId}`).setLabel("Show Full Output").setStyle(ButtonStyle.Secondary)
@@ -1173,47 +1664,111 @@ ${displayResult}
             }
             await channel.send({ embeds: [embed], components });
           }
+          break;
+        }
+        case "image_file": {
+          if (existsSync4(event.filePath)) {
+            await streamer.finalize();
+            const attachment = new AttachmentBuilder(event.filePath);
+            await channel.send({ files: [attachment] });
+          }
+          break;
+        }
+        // ── Codex-specific events ──
+        case "command_execution": {
+          if (shouldSuppressCommandExecution(event.command)) break;
+          await streamer.finalize();
+          const embed = renderCommandExecutionEmbed(event);
+          await channel.send({
+            embeds: [embed],
+            components: [makeStopButton(sessionId)]
+          });
+          break;
+        }
+        case "file_change": {
+          await streamer.finalize();
+          const embed = renderFileChangesEmbed(event);
+          await channel.send({
+            embeds: [embed],
+            components: [makeStopButton(sessionId)]
+          });
+          break;
+        }
+        case "reasoning": {
+          if (verbose) {
+            await streamer.finalize();
+            const embed = renderReasoningEmbed(event);
+            await channel.send({
+              embeds: [embed],
+              components: [makeStopButton(sessionId)]
+            });
+          }
+          break;
+        }
+        case "todo_list": {
+          await streamer.finalize();
+          const embed = renderCodexTodoListEmbed(event);
+          await channel.send({
+            embeds: [embed],
+            components: [makeStopButton(sessionId)]
+          });
+          break;
+        }
+        // ── Shared events ──
+        case "result": {
+          const lastText = streamer.getText();
+          const cost = event.costUsd.toFixed(4);
+          const duration = event.durationMs ? `${(event.durationMs / 1e3).toFixed(1)}s` : "unknown";
+          const turns = event.numTurns || 0;
+          const modeLabel = { auto: "Auto", plan: "Plan", normal: "Normal" }[mode] || "Auto";
+          const statusLine = event.success ? `-# $${cost} | ${duration} | ${turns} turns | ${modeLabel}` : `-# Error | $${cost} | ${duration} | ${turns} turns`;
+          streamer.append(`
+${statusLine}`);
+          if (!event.success && event.errors.length) {
+            streamer.append(`
+\`\`\`
+${event.errors.join("\n")}
+\`\`\``);
+          }
+          if (!event.success && !isAbortError(event.errors)) {
+            resetProviderSession(sessionId);
+            streamer.append("\n-# Session reset \u2014 next message will start a fresh provider session.");
+          }
+          await streamer.finalize();
+          const components = [];
+          const checkText = lastText || "";
+          const options = detectNumberedOptions(checkText);
+          if (options) {
+            components.push(...makeOptionButtons(sessionId, options));
+          } else if (detectYesNoPrompt(checkText)) {
+            components.push(makeYesNoButtons(sessionId));
+          }
+          components.push(makeModeButtons(sessionId, mode));
+          await channel.send({ components });
+          break;
         }
-      }
-      if (message.type === "result") {
-        const lastText = streamer.getText();
-        await streamer.finalize();
-        const result = message;
-        const isSuccess = result.subtype === "success";
-        const cost = result.total_cost_usd?.toFixed(4) || "0.0000";
-        const duration = result.duration_ms ? `${(result.duration_ms / 1e3).toFixed(1)}s` : "unknown";
-        const turns = result.num_turns || 0;
-        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: "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}` });
-        }
-        if (!isSuccess && result.errors?.length) {
-          embed.setDescription(result.errors.join("\n"));
+        case "error": {
+          await streamer.finalize();
+          const embed = new EmbedBuilder2().setColor(15158332).setTitle("Error").setDescription(`\`\`\`
+${event.message}
+\`\`\``);
+          await channel.send({ embeds: [embed] });
+          break;
         }
-        const components = [];
-        const checkText = lastText || result.result || "";
-        const options = detectNumberedOptions(checkText);
-        if (options) {
-          components.push(...makeOptionButtons(sessionId, options));
-        } else if (detectYesNoPrompt(checkText)) {
-          components.push(makeYesNoButtons(sessionId));
+        case "session_init": {
+          break;
         }
-        components.push(makeModeButtons(sessionId, mode));
-        components.push(makeCompletionButtons(sessionId));
-        await channel.send({ embeds: [embed], components });
       }
     }
   } catch (err) {
     await streamer.finalize();
-    if (err.name !== "AbortError") {
-      const embed = new EmbedBuilder().setColor(15158332).setTitle("Error").setDescription(`\`\`\`
-${err.message}
-\`\`\``);
+    const errMsg = err.message || "";
+    if (!isAbortLike(err)) {
+      resetProviderSession(sessionId);
+      const embed = new EmbedBuilder2().setColor(15158332).setTitle("Error").setDescription(`\`\`\`
+${errMsg}
+\`\`\`
+-# Session reset \u2014 next message will start a fresh provider session.`);
       await channel.send({ embeds: [embed] });
     }
   } finally {
@@ -1345,7 +1900,7 @@ async function ensureProjectCategory(guild, projectName, directory) {
   updateProjectCategory(projectName, category.id, logChannel2.id);
   return { category, logChannel: logChannel2 };
 }
-async function handleClaude(interaction) {
+async function handleSession(interaction) {
   if (!isUserAllowed(interaction.user.id, config.allowedUsers, config.allowAllUsers)) {
     await interaction.reply({ content: "You are not authorized to use this bot.", ephemeral: true });
     return;
@@ -1353,66 +1908,90 @@ async function handleClaude(interaction) {
   const sub = interaction.options.getSubcommand();
   switch (sub) {
     case "new":
-      return handleClaudeNew(interaction);
+      return handleSessionNew(interaction);
     case "resume":
-      return handleClaudeResume(interaction);
+      return handleSessionResume(interaction);
     case "list":
-      return handleClaudeList(interaction);
+      return handleSessionList(interaction);
     case "end":
-      return handleClaudeEnd(interaction);
+      return handleSessionEnd(interaction);
     case "continue":
-      return handleClaudeContinue(interaction);
+      return handleSessionContinue(interaction);
     case "stop":
-      return handleClaudeStop(interaction);
+      return handleSessionStop(interaction);
     case "output":
-      return handleClaudeOutput(interaction);
+      return handleSessionOutput(interaction);
     case "attach":
-      return handleClaudeAttach(interaction);
+      return handleSessionAttach(interaction);
     case "sync":
-      return handleClaudeSync(interaction);
+      return handleSessionSync(interaction);
+    case "id":
+      return handleSessionId(interaction);
     case "model":
-      return handleClaudeModel(interaction);
+      return handleSessionModel(interaction);
     case "verbose":
-      return handleClaudeVerbose(interaction);
+      return handleSessionVerbose(interaction);
     case "mode":
-      return handleClaudeMode(interaction);
+      return handleSessionMode(interaction);
     default:
       await interaction.reply({ content: `Unknown subcommand: ${sub}`, ephemeral: true });
   }
 }
-async function handleClaudeNew(interaction) {
+var PROVIDER_LABELS = {
+  claude: "Claude Code",
+  codex: "OpenAI Codex"
+};
+var PROVIDER_COLORS = {
+  claude: 3447003,
+  codex: 1090431
+};
+async function handleSessionNew(interaction) {
   const name = interaction.options.getString("name", true);
-  const directory = interaction.options.getString("directory") || config.defaultDirectory;
+  const provider = interaction.options.getString("provider") || "claude";
+  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 {
     const guild = interaction.guild;
     const projectName = projectNameFromDir(directory);
     const { category } = await ensureProjectCategory(guild, projectName, directory);
-    const session = await createSession(name, directory, "pending", projectName);
+    const session = await createSession(name, directory, "pending", projectName, provider);
     channel = await guild.channels.create({
-      name: `claude-${session.id}`,
+      name: `${provider}-${session.id}`,
       type: ChannelType.GuildText,
       parent: category.id,
-      topic: `Claude session | Dir: ${directory}`
+      topic: `${PROVIDER_LABELS[provider]} session | Dir: ${directory}`
     });
     linkChannel(session.id, channel.id);
-    const embed = new EmbedBuilder2().setColor(3066993).setTitle(`Session Created: ${session.id}`).addFields(
-      { name: "Channel", value: `#claude-${session.id}`, inline: true },
+    const fields = [
+      { name: "Channel", value: `#${provider}-${session.id}`, inline: true },
+      { name: "Provider", value: PROVIDER_LABELS[provider], inline: true },
       { name: "Directory", value: session.directory, inline: true },
-      { name: "Project", value: projectName, inline: true },
-      { name: "Terminal", value: `\`tmux attach -t ${session.tmuxName}\``, inline: false }
-    );
+      { name: "Project", value: projectName, inline: true }
+    ];
+    if (session.tmuxName) {
+      fields.push({ name: "Terminal", value: `\`tmux attach -t ${session.tmuxName}\``, inline: false });
+    }
+    const embed = new EmbedBuilder3().setColor(3066993).setTitle(`Session Created: ${session.id}`).addFields(fields);
     await interaction.editReply({ embeds: [embed] });
-    log(`Session "${session.id}" created by ${interaction.user.tag} in ${directory}`);
-    await channel.send({
-      embeds: [
-        new EmbedBuilder2().setColor(3447003).setTitle("Claude Code Session").setDescription("Type a message to send it to Claude. Use `/claude stop` to cancel generation.").addFields(
-          { name: "Directory", value: `\`${session.directory}\``, inline: false },
-          { name: "Terminal Access", value: `\`tmux attach -t ${session.tmuxName}\``, inline: false }
-        )
-      ]
-    });
+    log(`Session "${session.id}" (${provider}) created by ${interaction.user.tag} in ${directory}`);
+    const welcomeEmbed = new EmbedBuilder3().setColor(PROVIDER_COLORS[provider]).setTitle(`${PROVIDER_LABELS[provider]} Session`).setDescription(`Type a message to send it to the AI. Use \`/session stop\` to cancel generation.`);
+    const welcomeFields = [
+      { name: "Directory", value: `\`${session.directory}\``, inline: false }
+    ];
+    if (session.tmuxName) {
+      welcomeFields.push({ name: "Terminal Access", value: `\`tmux attach -t ${session.tmuxName}\``, inline: false });
+    }
+    welcomeEmbed.addFields(welcomeFields);
+    await channel.send({ embeds: [welcomeEmbed] });
   } catch (err) {
     if (channel) {
       try {
@@ -1424,7 +2003,7 @@ async function handleClaudeNew(interaction) {
   }
 }
 function discoverLocalSessions() {
-  const claudeDir = join3(homedir2(), ".claude", "projects");
+  const claudeDir = join4(homedir3(), ".claude", "projects");
   const results = [];
   let projectDirs;
   try {
@@ -1433,7 +2012,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);
@@ -1447,7 +2026,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;
@@ -1458,7 +2037,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);
@@ -1466,7 +2045,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 {
@@ -1512,7 +2091,7 @@ function formatTimeAgo(mtime) {
   if (ago < 864e5) return `${Math.floor(ago / 36e5)}h ago`;
   return `${Math.floor(ago / 864e5)}d ago`;
 }
-async function handleClaudeAutocomplete(interaction) {
+async function handleSessionAutocomplete(interaction) {
   const focused = interaction.options.getFocused();
   const localSessions = discoverLocalSessions();
   const filtered = focused ? localSessions.filter((s) => s.id.includes(focused.toLowerCase()) || s.project.toLowerCase().includes(focused.toLowerCase())) : localSessions;
@@ -1527,17 +2106,20 @@ async function handleClaudeAutocomplete(interaction) {
   );
   await interaction.respond(choices);
 }
-async function handleClaudeResume(interaction) {
-  const claudeSessionId = interaction.options.getString("session-id", true);
+async function handleSessionResume(interaction) {
+  const providerSessionId = interaction.options.getString("session-id", true);
   const name = interaction.options.getString("name", true);
+  const provider = interaction.options.getString("provider") || "claude";
   const directory = interaction.options.getString("directory") || config.defaultDirectory;
-  const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-  if (!uuidRegex.test(claudeSessionId)) {
-    await interaction.reply({
-      content: "Invalid session ID. Expected a UUID like `9815d35d-6508-476e-8c40-40effa4ffd6b`.",
-      ephemeral: true
-    });
-    return;
+  if (provider === "claude") {
+    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    if (!uuidRegex.test(providerSessionId)) {
+      await interaction.reply({
+        content: "Invalid session ID. Expected a UUID like `9815d35d-6508-476e-8c40-40effa4ffd6b`.",
+        ephemeral: true
+      });
+      return;
+    }
   }
   await interaction.deferReply();
   let channel;
@@ -1545,32 +2127,39 @@ async function handleClaudeResume(interaction) {
     const guild = interaction.guild;
     const projectName = projectNameFromDir(directory);
     const { category } = await ensureProjectCategory(guild, projectName, directory);
-    const session = await createSession(name, directory, "pending", projectName, claudeSessionId);
+    const session = await createSession(name, directory, "pending", projectName, provider, providerSessionId);
     channel = await guild.channels.create({
-      name: `claude-${session.id}`,
+      name: `${provider}-${session.id}`,
       type: ChannelType.GuildText,
       parent: category.id,
-      topic: `Claude session (resumed) | Dir: ${directory}`
+      topic: `${PROVIDER_LABELS[provider]} session (resumed) | Dir: ${directory}`
     });
     linkChannel(session.id, channel.id);
-    const embed = new EmbedBuilder2().setColor(15105570).setTitle(`Session Resumed: ${session.id}`).addFields(
-      { name: "Channel", value: `#claude-${session.id}`, inline: true },
+    const fields = [
+      { name: "Channel", value: `#${provider}-${session.id}`, inline: true },
+      { name: "Provider", value: PROVIDER_LABELS[provider], inline: true },
       { name: "Directory", value: session.directory, inline: true },
       { name: "Project", value: projectName, inline: true },
-      { name: "Claude Session", value: `\`${claudeSessionId}\``, inline: false },
-      { name: "Terminal", value: `\`tmux attach -t ${session.tmuxName}\``, inline: false }
-    );
+      { name: "Provider Session", value: `\`${providerSessionId}\``, inline: false }
+    ];
+    if (session.tmuxName) {
+      fields.push({ name: "Terminal", value: `\`tmux attach -t ${session.tmuxName}\``, inline: false });
+    }
+    const embed = new EmbedBuilder3().setColor(15105570).setTitle(`Session Resumed: ${session.id}`).addFields(fields);
     await interaction.editReply({ embeds: [embed] });
-    log(`Session "${session.id}" (resumed ${claudeSessionId}) created by ${interaction.user.tag} in ${directory}`);
+    log(`Session "${session.id}" (${provider}, resumed ${providerSessionId}) created by ${interaction.user.tag} in ${directory}`);
+    const welcomeFields = [
+      { name: "Directory", value: `\`${session.directory}\``, inline: false },
+      { name: "Provider Session", value: `\`${providerSessionId}\``, inline: false }
+    ];
+    if (session.tmuxName) {
+      welcomeFields.push({ name: "Terminal Access", value: `\`tmux attach -t ${session.tmuxName}\``, inline: false });
+    }
     await channel.send({
       embeds: [
-        new EmbedBuilder2().setColor(15105570).setTitle("Claude Code Session (Resumed)").setDescription(
-          "This session is linked to an existing Claude Code conversation. Type a message to continue the conversation from Discord."
-        ).addFields(
-          { name: "Directory", value: `\`${session.directory}\``, inline: false },
-          { name: "Claude Session", value: `\`${claudeSessionId}\``, inline: false },
-          { name: "Terminal Access", value: `\`tmux attach -t ${session.tmuxName}\``, inline: false }
-        )
+        new EmbedBuilder3().setColor(15105570).setTitle(`${PROVIDER_LABELS[provider]} Session (Resumed)`).setDescription(
+          `This session is linked to an existing ${PROVIDER_LABELS[provider]} conversation. Type a message to continue the conversation from Discord.`
+        ).addFields(welcomeFields)
       ]
     });
   } catch (err) {
@@ -1583,7 +2172,7 @@ async function handleClaudeResume(interaction) {
     await interaction.editReply(`Failed to resume session: ${err.message}`);
   }
 }
-async function handleClaudeList(interaction) {
+async function handleSessionList(interaction) {
   const allSessions = getAllSessions();
   if (allSessions.length === 0) {
     await interaction.reply({ content: "No active sessions.", ephemeral: true });
@@ -1595,33 +2184,42 @@ async function handleClaudeList(interaction) {
     arr.push(s);
     grouped.set(s.projectName, arr);
   }
-  const embed = new EmbedBuilder2().setColor(3447003).setTitle(`Active Sessions (${allSessions.length})`);
+  const embed = new EmbedBuilder3().setColor(3447003).setTitle(`Active Sessions (${allSessions.length})`);
   for (const [project, projectSessions] of grouped) {
     const lines = projectSessions.map((s) => {
       const status = s.isGenerating ? "\u{1F7E2} generating" : "\u26AA idle";
       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)}`;
+      const providerTag = `[${s.provider}]`;
+      return `**${s.id}** ${providerTag} \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") });
   }
   await interaction.reply({ embeds: [embed] });
 }
-async function handleClaudeEnd(interaction) {
+async function handleSessionEnd(interaction) {
   const session = getSessionByChannel(interaction.channelId);
   if (!session) {
     await interaction.reply({ content: "No session in this channel.", ephemeral: true });
     return;
   }
+  const channel = interaction.channel;
   await interaction.deferReply();
   try {
     await endSession(session.id);
-    await interaction.editReply(`Session "${session.id}" ended. You can delete this channel.`);
     log(`Session "${session.id}" ended by ${interaction.user.tag}`);
+    await interaction.editReply(`Session "${session.id}" ended. Deleting channel...`);
+    setTimeout(async () => {
+      try {
+        await channel?.delete();
+      } catch (err) {
+        log(`Failed to delete channel for session "${session.id}": ${err.message}`);
+      }
+    }, 2e3);
   } catch (err) {
     await interaction.editReply(`Failed to end session: ${err.message}`);
   }
 }
-async function handleClaudeContinue(interaction) {
+async function handleSessionContinue(interaction) {
   const session = getSessionByChannel(interaction.channelId);
   if (!session) {
     await interaction.reply({ content: "No session in this channel.", ephemeral: true });
@@ -1636,12 +2234,12 @@ 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, session.mode);
+    await handleOutputStream(stream, channel, session.id, session.verbose, session.mode, session.provider);
   } catch (err) {
     await interaction.editReply(`Error: ${err.message}`);
   }
 }
-async function handleClaudeStop(interaction) {
+async function handleSessionStop(interaction) {
   const session = getSessionByChannel(interaction.channelId);
   if (!session) {
     await interaction.reply({ content: "No session in this channel.", ephemeral: true });
@@ -1653,18 +2251,18 @@ async function handleClaudeStop(interaction) {
     ephemeral: true
   });
 }
-async function handleClaudeOutput(interaction) {
+async function handleSessionOutput(interaction) {
   const session = getSessionByChannel(interaction.channelId);
   if (!session) {
     await interaction.reply({ content: "No session in this channel.", ephemeral: true });
     return;
   }
   await interaction.reply({
-    content: "Conversation history is managed by the Claude Code SDK. Use `/claude attach` to view the full terminal history.",
+    content: "Conversation history is managed by the provider SDK. Use `/session attach` to view the full terminal history.",
     ephemeral: true
   });
 }
-async function handleClaudeAttach(interaction) {
+async function handleSessionAttach(interaction) {
   const session = getSessionByChannel(interaction.channelId);
   if (!session) {
     await interaction.reply({ content: "No session in this channel.", ephemeral: true });
@@ -1672,10 +2270,13 @@ async function handleClaudeAttach(interaction) {
   }
   const info = getAttachInfo(session.id);
   if (!info) {
-    await interaction.reply({ content: "Session not found.", ephemeral: true });
+    await interaction.reply({
+      content: `Terminal attach is not available for ${PROVIDER_LABELS[session.provider]} sessions.`,
+      ephemeral: true
+    });
     return;
   }
-  const embed = new EmbedBuilder2().setColor(10181046).setTitle("Terminal Access").addFields(
+  const embed = new EmbedBuilder3().setColor(10181046).setTitle("Terminal Access").addFields(
     { name: "Attach to tmux", value: `\`\`\`
 ${info.command}
 \`\`\`` }
@@ -1690,7 +2291,7 @@ cd ${session.directory} && claude --resume ${info.sessionId}
   }
   await interaction.reply({ embeds: [embed], ephemeral: true });
 }
-async function handleClaudeSync(interaction) {
+async function handleSessionSync(interaction) {
   await interaction.deferReply();
   const guild = interaction.guild;
   const tmuxSessions = await listTmuxSessions();
@@ -1705,16 +2306,36 @@ async function handleClaudeSync(interaction) {
       name: `claude-${tmuxSession.id}`,
       type: ChannelType.GuildText,
       parent: category.id,
-      topic: `Claude session (synced) | Dir: ${tmuxSession.directory}`
+      topic: `Claude Code session (synced) | Dir: ${tmuxSession.directory}`
     });
-    await createSession(tmuxSession.id, tmuxSession.directory, channel.id, projectName);
+    await createSession(tmuxSession.id, tmuxSession.directory, channel.id, projectName, "claude");
     synced++;
   }
   await interaction.editReply(
     synced > 0 ? `Synced ${synced} orphaned session(s).` : "No orphaned sessions found."
   );
 }
-async function handleClaudeModel(interaction) {
+async function handleSessionId(interaction) {
+  const session = getSessionByChannel(interaction.channelId);
+  if (!session) {
+    await interaction.reply({ content: "No session in this channel.", ephemeral: true });
+    return;
+  }
+  const providerSessionId = session.providerSessionId;
+  if (!providerSessionId) {
+    await interaction.reply({
+      content: "No provider session ID yet. Send a message first to initialize the session.",
+      ephemeral: true
+    });
+    return;
+  }
+  await interaction.reply({
+    content: `**Provider session ID** (${session.provider}):
+\`${providerSessionId}\``,
+    ephemeral: true
+  });
+}
+async function handleSessionModel(interaction) {
   const session = getSessionByChannel(interaction.channelId);
   if (!session) {
     await interaction.reply({ content: "No session in this channel.", ephemeral: true });
@@ -1724,7 +2345,7 @@ async function handleClaudeModel(interaction) {
   setModel(session.id, model);
   await interaction.reply({ content: `Model set to \`${model}\` for this session.`, ephemeral: true });
 }
-async function handleClaudeVerbose(interaction) {
+async function handleSessionVerbose(interaction) {
   const session = getSessionByChannel(interaction.channelId);
   if (!session) {
     await interaction.reply({ content: "No session in this channel.", ephemeral: true });
@@ -1742,7 +2363,7 @@ var MODE_LABELS = {
   plan: "\u{1F4CB} Plan \u2014 always plans before executing changes",
   normal: "\u{1F6E1}\uFE0F Normal \u2014 asks before destructive operations"
 };
-async function handleClaudeMode(interaction) {
+async function handleSessionMode(interaction) {
   const session = getSessionByChannel(interaction.channelId);
   if (!session) {
     await interaction.reply({ content: "No session in this channel.", ephemeral: true });
@@ -1825,7 +2446,7 @@ async function handleAgent(interaction) {
     }
     case "list": {
       const agents2 = listAgents();
-      const embed = new EmbedBuilder2().setColor(10181046).setTitle("Agent Personas").setDescription(agents2.map((a) => `${a.emoji} **${a.name}** \u2014 ${a.description}`).join("\n"));
+      const embed = new EmbedBuilder3().setColor(10181046).setTitle("Agent Personas").setDescription(agents2.map((a) => `${a.emoji} **${a.name}** \u2014 ${a.description}`).join("\n"));
       await interaction.reply({ embeds: [embed], ephemeral: true });
       break;
     }
@@ -1918,7 +2539,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, session.mode);
+        await handleOutputStream(stream, channel, session.id, session.verbose, session.mode, session.provider);
       } catch (err) {
         await interaction.editReply(`Error: ${err.message}`);
       }
@@ -1963,7 +2584,7 @@ ${list}`, ephemeral: true });
         await interaction.reply({ content: "Project not found.", ephemeral: true });
         return;
       }
-      const embed = new EmbedBuilder2().setColor(15965202).setTitle(`Project: ${projectName}`).addFields(
+      const embed = new EmbedBuilder3().setColor(15965202).setTitle(`Project: ${projectName}`).addFields(
         { name: "Directory", value: `\`${project.directory}\``, inline: false },
         {
           name: "Personality",
@@ -1986,9 +2607,438 @@ ${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 EmbedBuilder3().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 EmbedBuilder3().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 EmbedBuilder3().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 EmbedBuilder3().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 EmbedBuilder3().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 TEXT_CONTENT_TYPES = /* @__PURE__ */ new Set([
+  "text/plain",
+  "text/markdown",
+  "text/csv",
+  "text/html",
+  "text/xml",
+  "application/json",
+  "application/xml",
+  "application/javascript",
+  "application/typescript",
+  "application/x-yaml"
+]);
+var TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".txt",
+  ".md",
+  ".json",
+  ".yaml",
+  ".yml",
+  ".xml",
+  ".csv",
+  ".html",
+  ".css",
+  ".js",
+  ".ts",
+  ".jsx",
+  ".tsx",
+  ".swift",
+  ".py",
+  ".rb",
+  ".go",
+  ".rs",
+  ".java",
+  ".kt",
+  ".c",
+  ".cpp",
+  ".h",
+  ".hpp",
+  ".sh",
+  ".bash",
+  ".zsh",
+  ".toml",
+  ".ini",
+  ".cfg",
+  ".conf",
+  ".env",
+  ".log",
+  ".sql",
+  ".graphql",
+  ".proto",
+  ".diff",
+  ".patch"
+]);
+var MAX_IMAGE_SIZE = 20 * 1024 * 1024;
+var MAX_TEXT_FILE_SIZE = 512 * 1024;
+var MAX_RAW_BYTES = Math.floor(5 * 1024 * 1024 * 3 / 4);
 var userLastMessage = /* @__PURE__ */ new Map();
+async function resizeImageToFit(buf) {
+  const meta = await sharp(buf).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" }).jpeg({ quality: 80 }).toBuffer();
+    if (resized.length <= MAX_RAW_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();
+}
+function isTextAttachment(contentType, filename) {
+  if (contentType && TEXT_CONTENT_TYPES.has(contentType.split(";")[0])) return true;
+  if (filename) {
+    const ext = filename.slice(filename.lastIndexOf(".")).toLowerCase();
+    if (TEXT_EXTENSIONS.has(ext)) return true;
+  }
+  return false;
+}
+async function fetchTextFile(url) {
+  const res = await fetch(url);
+  if (!res.ok) throw new Error(`Failed to download file: ${res.status}`);
+  return res.text();
+}
+async function fetchImageAsBase64(url, mediaType) {
+  const res = await fetch(url);
+  if (!res.ok) throw new Error(`Failed to download image: ${res.status}`);
+  const buf = Buffer.from(await res.arrayBuffer());
+  if (buf.length > MAX_RAW_BYTES) {
+    const resized = await resizeImageToFit(buf);
+    return { data: resized.toString("base64"), mediaType: "image/jpeg" };
+  }
+  return { data: buf.toString("base64"), mediaType };
+}
 async function handleMessage(message) {
   if (message.author.bot) return;
   const session = getSessionByChannel(message.channelId);
@@ -2011,27 +3061,92 @@ async function handleMessage(message) {
     }
     if (session.isGenerating) {
       await message.reply({
-        content: "Could not interrupt the current generation. Try `/claude stop`.",
+        content: "Could not interrupt the current generation. Try `/session stop`.",
         allowedMentions: { repliedUser: false }
       });
       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
+  );
+  const textAttachments = message.attachments.filter(
+    (a) => !SUPPORTED_IMAGE_TYPES.has(a.contentType ?? "") && !(a.contentType?.startsWith("video/") || a.contentType?.startsWith("audio/")) && (isTextAttachment(a.contentType, a.name) || !a.contentType) && a.size <= MAX_TEXT_FILE_SIZE
+  );
+  if (!text && imageAttachments.size === 0 && textAttachments.size === 0) return;
   try {
     const channel = message.channel;
-    const stream = sendPrompt(session.id, content);
-    await handleOutputStream(stream, channel, session.id, session.verbose, session.mode);
+    const hasAttachments = imageAttachments.size > 0 || textAttachments.size > 0;
+    let prompt;
+    if (!hasAttachments) {
+      prompt = text;
+    } else {
+      const blocks = [];
+      const textResults = await Promise.allSettled(
+        textAttachments.map(async (a) => ({
+          name: a.name ?? "file",
+          content: await fetchTextFile(a.url)
+        }))
+      );
+      for (const result of textResults) {
+        if (result.status === "fulfilled") {
+          blocks.push({
+            type: "text",
+            text: `<file name="${result.value.name}">
+${result.value.content}
+</file>`
+          });
+        }
+      }
+      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 (imageAttachments.size > 0 && textAttachments.size === 0) {
+        blocks.push({ type: "text", text: "What is in this image?" });
+      } else {
+        blocks.push({ type: "text", text: "Here are the attached files." });
+      }
+      prompt = blocks;
+    }
+    const stream = sendPrompt(session.id, prompt);
+    await handleOutputStream(stream, channel, session.id, session.verbose, session.mode, session.provider);
   } catch (err) {
+    const errMsg = err.message || "";
+    const isAbort = err.name === "AbortError" || /abort|cancel|interrupt/i.test(errMsg);
+    if (isAbort) {
+      return;
+    }
+    resetProviderSession(session.id);
     await message.reply({
-      content: `Error: ${err.message}`,
+      content: `Error: ${errMsg}
+-# Session reset \u2014 next message will start a fresh provider session.`,
       allowedMentions: { repliedUser: false }
     });
   }
 }
 
 // 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 });
@@ -2063,7 +3178,7 @@ async function handleButton(interaction) {
       const channel = interaction.channel;
       const stream = continueSession(sessionId);
       await interaction.editReply("Continuing...");
-      await handleOutputStream(stream, channel, sessionId, session.verbose, session.mode);
+      await handleOutputStream(stream, channel, sessionId, session.verbose, session.mode, session.provider);
     } catch (err) {
       await interaction.editReply(`Error: ${err.message}`);
     }
@@ -2097,7 +3212,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, session.mode);
+      await handleOutputStream(stream, channel, sessionId, session.verbose, session.mode, session.provider);
+    } 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, session.provider);
     } catch (err) {
       await interaction.editReply(`Error: ${err.message}`);
     }
@@ -2106,7 +3293,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 });
@@ -2117,7 +3305,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, session.mode);
+      await handleOutputStream(stream, channel, sessionId, session.verbose, session.mode, session.provider);
     } catch (err) {
       await interaction.editReply(`Error: ${err.message}`);
     }
@@ -2137,7 +3325,7 @@ ${display}
       const channel = interaction.channel;
       const stream = sendPrompt(sessionId, answer);
       await interaction.editReply(`Answered: ${answer}`);
-      await handleOutputStream(stream, channel, sessionId, session.verbose, session.mode);
+      await handleOutputStream(stream, channel, sessionId, session.verbose, session.mode, session.provider);
     } catch (err) {
       await interaction.editReply(`Error: ${err.message}`);
     }
@@ -2184,8 +3372,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) {
@@ -2197,7 +3425,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, session.mode);
+      await handleOutputStream(stream, channel, sessionId, session.verbose, session.mode, session.provider);
     } catch (err) {
       await interaction.editReply(`Error: ${err.message}`);
     }
@@ -2216,7 +3444,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, session.mode);
+      await handleOutputStream(stream, channel, sessionId, session.verbose, session.mode, session.provider);
     } catch (err) {
       await interaction.editReply(`Error: ${err.message}`);
     }
@@ -2293,19 +3521,24 @@ async function startBot() {
     try {
       if (interaction.type === InteractionType.ApplicationCommand && interaction.isChatInputCommand()) {
         switch (interaction.commandName) {
-          case "claude":
-            return await handleClaude(interaction);
+          case "session":
+            return await handleSession(interaction);
           case "shell":
             return await handleShell(interaction);
           case "agent":
             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 === "session") {
+          return await handleSessionAutocomplete(interaction);
+        }
+        if (interaction.commandName === "plugin") {
+          return await handlePluginAutocomplete(interaction);
         }
       }
       if (interaction.isButton()) {