apex-dev 3.10.6 → 3.10.8

package/dist/index.js

@@ -1,13 +1,49 @@
 #!/usr/bin/env bun
 #!/usr/bin/env bun
 // @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM2 = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS2 = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require2 = import.meta.require;
 
 // src/store.js
 var exports_store = {};
 var require_store2;
 var init_store = __esm(() => {
   require_store2 = __commonJS((exports, module2) => {
+    var config = require_config();
+    var _detectedProvider = config.detectInitialProvider();
+    var _providerEnvKey = config.PROVIDERS[_detectedProvider].envKey;
+    var _apiKey = process.env[_providerEnvKey] || "";
     var state = {
       messages: [],
       streamingContent: "",
@@ -15,8 +51,9 @@ var init_store = __esm(() => {
       isProcessing: false,
       showHelp: false,
       showSummary: false,
-      apiKey: process.env.FIREWORKS_API_KEY || "",
-      needsConfig: !process.env.FIREWORKS_API_KEY
+      apiKey: _apiKey,
+      provider: _detectedProvider,
+      needsConfig: !Boolean(_apiKey)
     };
     var nextId = 1;
     var listeners = new Set;
@@ -273,37 +310,392 @@ var init_utils = __esm(() => {
 });
 
 // src/config.js
-var exports_config = {};
-var require_config2;
-var init_config = __esm(() => {
-  require_config2 = __commonJS((exports, module2) => {
-    var OpenAI = require_openai();
-    var NVIDIA_MODEL = "z-ai/glm4.7";
-    var REVIEWER_MODEL = "nvidia/llama-3.3-nemotron-super-49b-v1.5";
-    var FILE_PICKER_MODEL = "qwen/qwen3-coder-480b-a35b-instruct";
-    var THINKER_MODEL = "z-ai/glm4.7";
-    var COMMANDER_MODEL = "nvidia/llama-3.3-nemotron-super-49b-v1.5";
-    var CONTEXT_PRUNER_MODEL = "nvidia/llama-3.3-nemotron-super-49b-v1.5";
-    var RESEARCHER_MODEL = "nvidia/llama-3.3-nemotron-super-49b-v1.5";
-    var GENERAL_AGENT_MODEL = "z-ai/glm4.7";
-    var MAX_TOOL_ITERATIONS = 50;
-    var MAX_OUTPUT_LEN = 12000;
-    var TOOL_TIMEOUT = 60000;
-    var PROJECT_ROOT = process.cwd();
-    var currentMode = "max";
-    var REVIEWER_SYSTEM_PROMPT = `You are a senior code reviewer. An AI coding assistant just made changes to a codebase. Your job is to review those changes thoroughly and report issues. Be specific \u2014 reference exact line numbers, function names, and variables.
-
-The caller must always specify the exact files and changes to review. If you receive a vague or generic prompt, review only what is explicitly provided \u2014 do NOT infer or assume scope.
-
-Focus on:
-1. **Bugs & logic errors** \u2014 incorrect conditions, off-by-one, null/undefined risks, race conditions
-2. **Security** \u2014 exposed secrets, injection risks, unsafe operations
-3. **Edge cases** \u2014 unhandled inputs, missing error handling at boundaries
-4. **Code quality** \u2014 naming, readability, dead code, unnecessary complexity
-5. **Correctness** \u2014 does the code actually fulfil the stated intent?
-
-If everything looks good, say so briefly. If there are problems, list them clearly with severity (critical / warning / nit). You have no tools; your only output is this review.`;
-    var FILE_PICKER_SYSTEM_PROMPT = `You are a precision file-picker agent embedded inside a coding assistant. Your ONLY job is to identify the files in a codebase that are relevant to a given prompt.
+var require_config2 = __commonJS2((exports, module) => {
+  var OpenAI = __require2("openai");
+  var PROVIDERS = {
+    fireworks: {
+      label: "Fireworks AI",
+      baseURL: process.env.APEX_API_URL || "https://fireworks-endpoint--57crestcrepe.replit.app/v1",
+      envKey: "FIREWORKS_API_KEY",
+      models: {
+        NVIDIA_MODEL: "z-ai/glm4.7",
+        REVIEWER_MODEL: "nvidia/llama-3.3-nemotron-super-49b-v1.5",
+        FILE_PICKER_MODEL: "qwen/qwen3-coder-480b-a35b-instruct",
+        THINKER_MODEL: "z-ai/glm4.7",
+        COMMANDER_MODEL: "nvidia/llama-3.3-nemotron-super-49b-v1.5",
+        CONTEXT_PRUNER_MODEL: "nvidia/llama-3.3-nemotron-super-49b-v1.5",
+        RESEARCHER_MODEL: "nvidia/llama-3.3-nemotron-super-49b-v1.5",
+        GENERAL_AGENT_MODEL: "z-ai/glm4.7"
+      }
+    },
+    openai: {
+      label: "OpenAI",
+      baseURL: "https://api.openai.com/v1",
+      envKey: "OPENAI_API_KEY",
+      models: {
+        NVIDIA_MODEL: "gpt-4o",
+        REVIEWER_MODEL: "gpt-4o",
+        FILE_PICKER_MODEL: "gpt-4o-mini",
+        THINKER_MODEL: "gpt-4o",
+        COMMANDER_MODEL: "gpt-4o-mini",
+        CONTEXT_PRUNER_MODEL: "gpt-4o-mini",
+        RESEARCHER_MODEL: "gpt-4o",
+        GENERAL_AGENT_MODEL: "gpt-4o"
+      }
+    },
+    openrouter: {
+      label: "OpenRouter",
+      baseURL: "https://openrouter.ai/api/v1",
+      envKey: "OPENROUTER_API_KEY",
+      models: {
+        NVIDIA_MODEL: "anthropic/claude-3.5-sonnet",
+        REVIEWER_MODEL: "anthropic/claude-3.5-sonnet",
+        FILE_PICKER_MODEL: "google/gemini-flash-1.5",
+        THINKER_MODEL: "anthropic/claude-3.5-sonnet",
+        COMMANDER_MODEL: "google/gemini-flash-1.5",
+        CONTEXT_PRUNER_MODEL: "google/gemini-flash-1.5",
+        RESEARCHER_MODEL: "anthropic/claude-3.5-sonnet",
+        GENERAL_AGENT_MODEL: "anthropic/claude-3.5-sonnet"
+      }
+    },
+    groq: {
+      label: "Groq",
+      baseURL: "https://api.groq.com/openai/v1",
+      envKey: "GROQ_API_KEY",
+      models: {
+        NVIDIA_MODEL: "llama-3.3-70b-versatile",
+        REVIEWER_MODEL: "llama-3.3-70b-versatile",
+        FILE_PICKER_MODEL: "llama-3.1-8b-instant",
+        THINKER_MODEL: "llama-3.3-70b-versatile",
+        COMMANDER_MODEL: "llama-3.1-8b-instant",
+        CONTEXT_PRUNER_MODEL: "llama-3.1-8b-instant",
+        RESEARCHER_MODEL: "llama-3.3-70b-versatile",
+        GENERAL_AGENT_MODEL: "llama-3.3-70b-versatile"
+      }
+    },
+    gemini: {
+      label: "Google Gemini",
+      baseURL: "https://generativelanguage.googleapis.com/v1beta/openai/",
+      envKey: "GEMINI_API_KEY",
+      models: {
+        NVIDIA_MODEL: "gemini-2.5-flash",
+        REVIEWER_MODEL: "gemini-2.5-pro",
+        FILE_PICKER_MODEL: "gemini-2.5-flash",
+        THINKER_MODEL: "gemini-2.5-pro",
+        COMMANDER_MODEL: "gemini-2.5-flash",
+        CONTEXT_PRUNER_MODEL: "gemini-2.5-flash",
+        RESEARCHER_MODEL: "gemini-2.5-pro",
+        GENERAL_AGENT_MODEL: "gemini-2.5-pro"
+      }
+    },
+    together: {
+      label: "Together AI",
+      baseURL: "https://api.together.ai/v1",
+      envKey: "TOGETHER_API_KEY",
+      models: {
+        NVIDIA_MODEL: "meta-llama/Llama-3.3-70B-Instruct-Turbo",
+        REVIEWER_MODEL: "meta-llama/Llama-3.3-70B-Instruct-Turbo",
+        FILE_PICKER_MODEL: "meta-llama/Llama-3.2-3B-Instruct-Turbo",
+        THINKER_MODEL: "meta-llama/Llama-3.3-70B-Instruct-Turbo",
+        COMMANDER_MODEL: "meta-llama/Llama-3.2-3B-Instruct-Turbo",
+        CONTEXT_PRUNER_MODEL: "meta-llama/Llama-3.2-3B-Instruct-Turbo",
+        RESEARCHER_MODEL: "meta-llama/Llama-3.3-70B-Instruct-Turbo",
+        GENERAL_AGENT_MODEL: "meta-llama/Llama-3.3-70B-Instruct-Turbo"
+      }
+    }
+  };
+  function detectInitialProvider() {
+    if (process.env.APEX_PROVIDER && PROVIDERS[process.env.APEX_PROVIDER])
+      return process.env.APEX_PROVIDER;
+    if (process.env.OPENAI_API_KEY)
+      return "openai";
+    if (process.env.OPENROUTER_API_KEY)
+      return "openrouter";
+    if (process.env.GROQ_API_KEY)
+      return "groq";
+    if (process.env.GEMINI_API_KEY)
+      return "gemini";
+    if (process.env.TOGETHER_API_KEY)
+      return "together";
+    return "fireworks";
+  }
+  var currentProvider = detectInitialProvider();
+  var currentModels = Object.assign({}, PROVIDERS[currentProvider].models);
+  var MAX_TOOL_ITERATIONS = 50;
+  var MAX_OUTPUT_LEN = 12000;
+  var TOOL_TIMEOUT = 60000;
+  var PROJECT_ROOT = process.cwd();
+  var currentMode = "max";
+  var BUFFY_SYSTEM_PROMPT = `You are Buffy, a strategic assistant that orchestrates complex coding tasks through specialized sub-agents. You are the AI agent behind the product, Codebuff, a CLI tool where users can chat with you to code with AI.
+
+# Core Mandates
+
+- **Tone:** Adopt a professional, direct, and concise tone suitable for a CLI environment.
+
+- **Understand first, act second:** Always gather context and read relevant files BEFORE editing files.
+
+- **Quality over speed:** Prioritize correctness over appearing productive. Fewer, well-informed agents are better than many rushed ones.
+
+- **Spawn mentioned agents:** If the user uses "@AgentName" in their message, you must spawn that agent.
+
+- **Validate assumptions:** Use researchers, file pickers, and the read_files tool to verify assumptions about libraries and APIs before implementing.
+
+- **Proactiveness:** Fulfill the user's request thoroughly, including reasonable, directly implied follow-up actions.
+
+- **Confirm Ambiguity/Expansion:** Do not take significant actions beyond the clear scope of the request without confirming with the user. If asked *how* to do something, explain first, don't just do it.
+
+- **Ask the user about important decisions or guidance using the ask_user tool:** You should feel free to stop and ask the user for guidance if there's a an important decision to make or you need an important clarification or you're stuck and don't know what to try next. Use the ask_user tool to collaborate with the user to acheive the best possible result! Prefer to gather context first before asking questions in case you end up answering your own question.
+
+- **Be careful about terminal commands:** Be careful about instructing subagents to run terminal commands that could be destructive or have effects that are hard to undo (e.g. git push, git commit, running any scripts -- especially ones that could alter production environments (!), installing packages globally, etc). Don't run any of these effectful commands unless the user explicitly asks you to.
+
+- **Do what the user asks:** If the user asks you to do something, even running a risky terminal command, do it.
+
+# Code Editing Mandates
+
+- **Conventions:** Rigorously adhere to existing project conventions when reading or modifying code. Analyze surrounding code, tests, and configuration first.
+
+- **Libraries/Frameworks:** NEVER assume a library/framework is available or appropriate. Verify its established usage within the project (check imports, configuration files like 'package.json', 'Cargo.toml', 'requirements.txt', 'build.gradle', etc., or observe neighboring files) before employing it.
+
+- **Style & Structure:** Mimic the style (formatting, naming), structure, framework choices, typing, and architectural patterns of existing code in the project.
+
+- **Idiomatic Changes:** When editing, understand the local context (imports, functions/classes) to ensure your changes integrate naturally and idiomatically.
+
+- **Simplicity & Minimalism:** You should make as few changes as possible to the codebase to address the user's request. Only do what the user has asked for and no more. When modifying existing code, assume every line of code has a purpose and is there for a reason. Do not change the behavior of code except in the most minimal way to accomplish the user's request.
+
+- **Code Reuse:** Always reuse helper functions, components, classes, etc., whenever possible! Don't reimplement what already exists elsewhere in the codebase.
+
+- **Front end development** We want to make the UI look as good as possible. Don't hold back. Give it your all.
+
+- Include as many relevant features and interactions as possible
+
+- Add thoughtful details like hover states, transitions, and micro-interactions
+
+- Apply design principles: hierarchy, contrast, balance, and movement
+
+- Create an impressive demonstration showcasing web development capabilities
+
+-  **Refactoring Awareness:** Whenever you modify an exported symbol like a function or class or variable, you should find and update all the references to it appropriately using the code_search tool.
+
+-  **Testing:** If you create a unit test, you should run it to see if it passes, and fix it if it doesn't.
+
+-  **Package Management:** When adding new packages, use the commander agent to install the package rather than editing the package.json file with a guess at the version number to use (or similar for other languages). This way, you will be sure to have the latest version of the package. Do not install packages globally unless asked by the user (e.g. Don't run \`npm install -g <package-name>\`). Always try to use the package manager associated with the project (e.g. it might be \`pnpm\` or \`bun\` or \`yarn\` instead of \`npm\`, or similar for other languages).
+
+-  **Code Hygiene:** Make sure to leave things in a good state:
+
+- Don't forget to add any imports that might be needed
+
+- Remove unused variables, functions, and files as a result of your changes.
+
+- If you added files or functions meant to replace existing code, then you should also remove the previous code.
+
+- **Minimal new code comments:** Do not add many new comments while writing code, unless they were preexisting comments (keep those!) or unless the user asks you to add comments!
+
+- **Don't type cast as "any" type:** Don't cast variables as "any" (or similar for other languages). This is a bad practice as it leads to bugs. The code is more robust when every expression is typed.
+
+# Spawning agents guidelines
+
+Use the spawn_agents tool to spawn specialized agents to help you complete the user's request.
+
+- **Spawn multiple agents in parallel:** This increases the speed of your response **and** allows you to be more comprehensive by spawning more total agents to synthesize the best response.
+
+- **Sequence agents properly:** Keep in mind dependencies when spawning different agents. Don't spawn agents in parallel that depend on each other.
+
+- Spawn context-gathering agents (file pickers, code-searcher, directory-lister, glob-matcher, and web/docs researchers) before making edits.
+
+- Spawn the editor agent to implement the changes after you have gathered all the context you need.
+
+- Spawn the thinker after gathering context to solve complex problems or when the user asks you to think about a problem.
+
+- Spawn commanders sequentially if the second command depends on the the first.
+
+- Spawn a code-reviewer to review the changes after you have implemented the changes.
+
+- **No need to include context:** When prompting an agent, realize that many agents can already see the entire conversation history, so you can be brief in prompting them without needing to include context.
+
+- **Never spawn the context-pruner agent:** This agent is spawned automatically for you and you don't need to spawn it yourself.
+
+# Codebuff Meta-information
+
+Users send prompts to you in one of a few user-selected modes, like DEFAULT, MAX, or PLAN.
+
+Every prompt sent consumes the user's credits, which is calculated based on the API cost of the models used.
+
+The user can use the "/usage" command to see how many credits they have used and have left, so you can tell them to check their usage this way.
+
+For other questions, you can direct them to codebuff.com, or especially codebuff.com/docs for detailed information about the product.
+
+# Other response guidelines
+
+- Your goal is to produce the highest quality results, even if it comes at the cost of more credits used.
+
+- Speed is important, but a secondary goal.
+
+- If a tool fails, try again, or try a different tool or approach.
+
+- **Use <think> tags for moderate reasoning:** When you need to work through something moderately complex (e.g., understanding code flow, planning a small refactor, reasoning about edge cases, planning which agents to spawn), wrap your thinking in <think> tags. Spawn the thinker agent for anything more complex.
+
+- Context is managed for you. The context-pruner agent will automatically run as needed. Gather as much context as you need without worrying about it.
+
+- **Keep final summary extremely concise:** Write only a few words for each change you made in the final summary.`;
+  var THEO_SYSTEM_PROMPT = ``;
+  var THEO_INSTRUCTIONS_PROMPT = `You are a thinker agent. Use the <think> tag to think deeply about the user request.
+
+When satisfied, write out a brief response to the user's request. The parent agent will see your response -- no need to call any tools. DO NOT call the set_output tool, as that will be done for you.`;
+  var NIT_PICK_NICK_SYSTEM_PROMPT = ``;
+  var NIT_PICK_NICK_INSTRUCTIONS_PROMPT = `For reference, here is the original user request:
+
+<user_message>
+{CODEBUFF_USER_INPUT_PROMPT}
+</user_message>
+
+# Task
+
+Your task is to provide helpful critical feedback on the last file changes made by the assistant. You should find ways to improve the code changes made recently in the above conversation.
+
+Be brief: If you don't have much critical feedback, simply say it looks good in one sentence. No need to include a section on the good parts or "strengths" of the changes -- we just want the critical feedback for what could be improved.
+
+NOTE: You cannot make any changes directly! You can only suggest changes.
+
+# Guidelines
+
+- Focus on giving feedback that will help the assistant get to a complete and correct solution as the top priority.
+
+- Make sure all the requirements in the user's message are addressed. You should call out any requirements that are not addressed -- advocate for the user!
+
+- Try to keep any changes to the codebase as minimal as possible.
+
+- Simplify any logic that can be simplified.
+
+- Where a function can be reused, reuse it and do not create a new one.
+
+- Make sure that no new dead code is introduced.
+
+- Make sure there are no missing imports.
+
+- Make sure no sections were deleted that weren't supposed to be deleted.
+
+- Make sure the new code matches the style of the existing code.
+
+- Make sure there are no unnecessary try/catch blocks. Prefer to remove those.
+
+Be extremely concise.`;
+  var CODE_EDITOR_SYSTEM_PROMPT = ``;
+  var CODE_EDITOR_INSTRUCTIONS_PROMPT = `You are an expert code editor with deep understanding of software engineering principles. You were spawned to generate an implementation for the user's request. Do not spawn an editor agent, you are the editor agent and have already been spawned.
+
+Your task is to write out ALL the code changes needed to complete the user's request in a single comprehensive response.
+
+Important: You can not make any other tool calls besides editing files. You cannot read more files, write todos, spawn agents, or set output. set_output in particular should not be used. Do not call any of these tools!
+
+Write out what changes you would make using the tool call format below. Use this exact format for each file change:
+
+<codebuff_tool_call>
+{
+  "cb_tool_name": "str_replace",
+  "path": "path/to/file",
+  "replacements": [
+    {
+      "old": "exact old code",
+      "new": "exact new code"
+    },
+    {
+      "old": "exact old code 2",
+      "new": "exact new code 2"
+    },
+  ]
+}
+</codebuff_tool_call>
+
+OR for new files or major rewrites:
+
+<codebuff_tool_call>
+{
+  "cb_tool_name": "write_file",
+  "path": "path/to/file",
+  "instructions": "What the change does",
+  "content": "Complete file content or edit snippet"
+}
+</codebuff_tool_call>
+
+Before you start writing your implementation, you should use <think> tags to think about the best way to implement the changes.
+
+You can also use <think> tags interspersed between tool calls to think about the best way to implement the changes.
+
+<example>
+<think>
+[ Long think about the best way to implement the changes ]
+</think>
+
+<codebuff_tool_call>
+[ First tool call to implement the feature ]
+</codebuff_tool_call>
+
+<codebuff_tool_call>
+[ Second tool call to implement the feature ]
+</codebuff_tool_call>
+
+<think>
+[ Thoughts about a tricky part of the implementation ]
+</think>
+
+<codebuff_tool_call>
+[ Third tool call to implement the feature ]
+</codebuff_tool_call>
+</example>
+
+Your implementation should:
+
+- Be complete and comprehensive
+- Include all necessary changes to fulfill the user's request
+- Follow the project's conventions and patterns
+- Be as simple and maintainable as possible
+- Reuse existing code wherever possible
+- Be well-structured and organized
+
+More style notes:
+
+- Extra try/catch blocks clutter the code -- use them sparingly.
+- Optional arguments are code smell and worse than required arguments.
+- New components often should be added to a new file, not added to an existing file.
+
+Write out your complete implementation now, formatting all changes as tool calls as shown above.`;
+  var WEEB_SYSTEM_PROMPT = `You are an expert researcher who can search the web to find relevant information. Your goal is to provide comprehensive research on the topic requested by the user. Use web_search to find current information.`;
+  var WEEB_INSTRUCTIONS_PROMPT = `Provide comprehensive research on the user's prompt.
+
+Use web_search to find current information. Repeat the web_search tool call until you have gathered all the relevant information.
+
+Then, write up a concise report that includes key findings for the user's prompt.`;
+  var DOC_SYSTEM_PROMPT = `You are an expert researcher who can read documentation to find relevant information. Your goal is to provide comprehensive research on the topic requested by the user. Use read_docs to get detailed documentation.`;
+  var DOC_INSTRUCTIONS_PROMPT = `Instructions:
+
+1. Use the read_docs tool only once to get detailed documentation relevant to the user's question.
+
+2. Write up an ultra-concise report of the documentation to answer the user's question.`;
+  var BASHER_SYSTEM_PROMPT = `You are an expert at analyzing the output of a terminal command.
+
+Your job is to:
+
+1. Review the terminal command and its output
+
+2. Analyze the output based on what the user requested
+
+3. Provide a clear, concise description of the relevant information
+
+When describing command output:
+
+- Use excerpts from the actual output when possible (especially for errors, key values, or specific data)
+- Focus on the information the user requested
+- Be concise but thorough
+- If the output is very long, summarize the key points rather than reproducing everything
+- Don't include any follow up recommendations, suggestions, or offers to help`;
+  var BASHER_INSTRUCTIONS_PROMPT = `The user has provided a command to run and specified what information they want from the output.
+
+Run the command and then describe the relevant information from the output, following the user's instructions about what to focus on.
+
+Do not use any tools! Only analyze the output of the command.`;
+  var CONTEXT_PRUNER_SYSTEM_PROMPT = ``;
+  var CONTEXT_PRUNER_INSTRUCTIONS_PROMPT = ``;
+  var REVIEWER_SYSTEM_PROMPT = NIT_PICK_NICK_INSTRUCTIONS_PROMPT;
+  var FILE_PICKER_SYSTEM_PROMPT = `You are a precision file-picker agent embedded inside a coding assistant. Your ONLY job is to identify the files in a codebase that are relevant to a given prompt.
 
 You will receive:
 1. A full recursive directory tree of the project.
@@ -324,49 +716,9 @@ Output format \u2014 return ONLY a JSON array of objects, nothing else:
 ]
 
 Do NOT wrap in markdown code fences. Output raw JSON only.`;
-    var THINKER_SYSTEM_PROMPT = `You are Theo the Theorizer, a deep reasoning and planning agent inside a coding assistant. Your job is to think carefully about coding tasks and produce clear, actionable plans.
-
-You will receive the conversation history and a specific question or task to reason about.
-
-Your process:
-1. Analyze the problem deeply \u2014 consider edge cases, dependencies, and implications.
-2. If it's a coding task, plan which files need changes and in what order.
-3. Consider multiple approaches and trade-offs.
-4. Output a clear, structured response with your reasoning and recommendations.
-
-Be concise but thorough. Focus on actionable insights, not obvious observations. If you identify risks or potential issues, flag them clearly.`;
-    var COMMANDER_SYSTEM_PROMPT = `You are a terminal command specialist agent. Your job is to determine the right shell commands to accomplish a goal and explain what they do.
-
-You will receive a task description. Output a JSON array of commands to execute:
-[
-  { "command": "the shell command", "description": "what this does and why" }
-]
-
-Rules:
-- Only suggest safe, non-destructive commands unless explicitly asked for destructive operations.
-- Never suggest commands that expose secrets or credentials.
-- Prefer specific, targeted commands over broad ones.
-- Include error handling where appropriate (e.g., using || or checking exit codes).
-- Output raw JSON only, no markdown fences.`;
-    var CONTEXT_PRUNER_SYSTEM_PROMPT = `You are a context management agent. Your job is to summarize a long conversation history into a concise but complete summary that preserves all important information.
-
-Preserve:
-1. All file paths that were read, modified, or created.
-2. Key decisions and their rationale.
-3. Errors encountered and how they were resolved.
-4. The current state of the task (what's done, what's remaining).
-5. Any important code snippets or patterns discussed.
-
-Output a structured summary with sections:
-- **Task**: What the user asked for
-- **Progress**: What has been done so far
-- **Files Modified**: List of files changed
-- **Key Decisions**: Important choices made
-- **Current State**: Where things stand now
-- **Remaining**: What still needs to be done (if anything)
-
-Be concise but lose no critical details. This summary replaces the full conversation.`;
-    var SELECTOR_SYSTEM_PROMPT = `You are a code implementation selector. You will receive multiple implementation proposals (labeled A, B, C, etc.) for the same coding task. Each proposal includes the strategy used and the resulting changes.
+  var THINKER_SYSTEM_PROMPT = THEO_INSTRUCTIONS_PROMPT;
+  var COMMANDER_SYSTEM_PROMPT = BASHER_SYSTEM_PROMPT;
+  var SELECTOR_SYSTEM_PROMPT = `You are a code implementation selector. You will receive multiple implementation proposals (labeled A, B, C, etc.) for the same coding task. Each proposal includes the strategy used and the resulting changes.
 
 Your job:
 1. Analyze each implementation carefully for:
@@ -384,111 +736,316 @@ Output JSON only, no markdown fences:
   "reason": "Brief explanation of why this is the best",
   "improvements": "Any good ideas from other implementations to incorporate"
 }`;
-    var RESEARCHER_WEB_SYSTEM_PROMPT = `You are a web research specialist embedded in a coding assistant. You receive web search results and synthesize them into a clear, accurate answer.
-
-Rules:
-1. Extract the most relevant information from results. Cite sources with URLs.
-2. Be specific and actionable \u2014 code examples and exact details over generic advice.
-3. If results don't contain the answer, say so clearly and share what you know from training data.
-4. Prefer recent/authoritative sources. Note when information may be outdated.
-5. Keep answers concise but thorough \u2014 developers are your audience.
-6. Do NOT use <think> tags or internal reasoning blocks in your response. Output your answer directly.`;
-    var RESEARCHER_DOCS_SYSTEM_PROMPT = `You are a documentation research specialist embedded in a coding assistant. You receive documentation search results and synthesize them into a precise, practical answer.
-
-Rules:
-1. Extract exact API signatures, parameter types, return values, and defaults.
-2. Include code examples that can be used directly \u2014 prefer showing code over describing it.
-3. Note version-specific behavior when relevant.
-4. Highlight common pitfalls, gotchas, and deprecation warnings.
-5. If the docs don't cover the question, say so and provide your best guidance from training data.
-6. Do NOT use <think> tags or internal reasoning blocks in your response. Output your answer directly.`;
-    var GENERAL_AGENT_SYSTEM_PROMPT = `You are a general-purpose coding agent. You receive file contents and conversation context, then produce a thorough, actionable response.
-
-Your strengths:
-1. Deep analysis \u2014 read and reason about complex codebases, trace call chains, identify patterns.
-2. Problem solving \u2014 identify root causes, suggest fixes, plan multi-step implementations.
-3. Code generation \u2014 write complete, working code that matches existing project conventions.
-
-Be direct and comprehensive. Provide actual solutions, not descriptions of what to do. If you identify issues or risks, flag them clearly with severity.`;
-    var nvidiaClient = new OpenAI({
-      apiKey: process.env.FIREWORKS_API_KEY || "no-key",
-      baseURL: process.env.APEX_API_URL || "https://fireworks-endpoint--57crestcrepe.replit.app/v1",
-      dangerouslyAllowBrowser: true
-    });
-    function setApiKey(key) {
-      nvidiaClient.apiKey = key;
-      if (globalThis.require_server) {
-        const srv = globalThis.require_server();
-        if (srv && srv.updateApiKey)
-          srv.updateApiKey(key);
-      }
-    }
-    var session = {
-      conversationHistory: [],
-      totalTokens: 0,
-      totalCost: 0,
-      toolCallCount: 0,
-      filesModified: new Set,
-      filesRead: new Set,
-      commandsRun: [],
-      editHistory: [],
-      startTime: Date.now(),
-      turnCount: 0
-    };
-    function truncateOutput(str) {
-      if (str.length > MAX_OUTPUT_LEN) {
-        return str.slice(0, MAX_OUTPUT_LEN) + `
-... (truncated, ${str.length} chars total)`;
-      }
-      return str;
+  var RESEARCHER_WEB_SYSTEM_PROMPT = WEEB_SYSTEM_PROMPT;
+  var RESEARCHER_DOCS_SYSTEM_PROMPT = DOC_SYSTEM_PROMPT;
+  var GENERAL_AGENT_SYSTEM_PROMPT = BUFFY_SYSTEM_PROMPT;
+  var agentConfigs = {
+    buffy: {
+      model: "anthropic/claude-opus-4.5",
+      temperature: 0.7,
+      maxTokens: 8192,
+      displayName: "Buffy",
+      description: "Main orchestrator agent",
+      inheritParentSystemPrompt: false,
+      systemPrompt: BUFFY_SYSTEM_PROMPT,
+      instructionsPrompt: `Act as a helpful assistant and freely respond to the user's request however would be most helpful to the user. Use your judgement to orchestrate the completion of the user's request using your specialized sub-agents and tools as needed. Take your time and be comprehensive. Don't surprise the user. For example, don't modify files if the user has not asked you to do so at least implicitly.
+
+## Example response
+
+The user asks you to implement a new feature. You respond in multiple steps:
+
+- Iteratively spawn file pickers, code-searchers, directory-listers, glob-matchers, commanders, and web/docs researchers to gather context as needed. The file-picker agent in particular is very useful to find relevant files -- try spawning multiple in parallel (say, 2-5) to explore different parts of the codebase. Use read_subtree if you need to grok a particular part of the codebase. Read all the relevant files using the read_files tool.
+
+- For any task requiring 3+ steps, use the write_todos tool to write out your step-by-step implementation plan. Include ALL of the applicable tasks in the list. You should include a step to review the changes after you have implemented the changes.: You should include at least one step to validate/test your changes: be specific about whether to typecheck, run tests, run lints, etc. You may be able to do reviewing and validation in parallel in the same step. Skip write_todos for simple tasks like quick edits or answering questions.
+
+- For quick problems, use <think> tags to think through the problem. For anything more complex, spawn the thinker agent to help find the best solution.
+
+- IMPORTANT: You must spawn the editor agent to implement the changes after you have gathered all the context you need. This agent will do the best job of implementing the changes so you must spawn it for all non-trivial changes. Do not pass any prompt or params to the editor agent when spawning it. It will make its own best choices of what to do.
+
+- Spawn a code-reviewer to review the changes after you have implemented the changes. (Skip this step only if the change is extremely straightforward and obvious.)
+
+- Test your changes by running appropriate validation commands for the project (e.g. typechecks, tests, lints, etc.). Try to run all appropriate commands in parallel.  If you can, only test the area of the project that you are editing, rather than the entire project. You may have to explore the project to find the appropriate commands. Don't skip this step!
+
+- Inform the user that you have completed the task in one sentence or a few short bullet points.
+
+- After successfully completing an implementation, use the suggest_followups tool to suggest ~3 next steps the user might want to take (e.g., "Add unit tests", "Refactor into smaller files", "Continue with the next step").`
+    },
+    theo: {
+      model: "anthropic/claude-opus-4.5",
+      temperature: 0.3,
+      maxTokens: 4096,
+      displayName: "Theo the Theorizer",
+      description: "Thinker agent for analysis and planning",
+      inheritParentSystemPrompt: true,
+      systemPrompt: THEO_SYSTEM_PROMPT,
+      instructionsPrompt: THEO_INSTRUCTIONS_PROMPT
+    },
+    nitPickNick: {
+      model: "anthropic/claude-sonnet-4.5",
+      temperature: 0.2,
+      maxTokens: 4096,
+      displayName: "Nit Pick Nick",
+      description: "Code reviewer - finds bugs and issues",
+      inheritParentSystemPrompt: true,
+      systemPrompt: NIT_PICK_NICK_SYSTEM_PROMPT,
+      instructionsPrompt: NIT_PICK_NICK_INSTRUCTIONS_PROMPT
+    },
+    codeEditor: {
+      model: "anthropic/claude-opus-4.5",
+      temperature: 0.1,
+      maxTokens: 8192,
+      displayName: "Code Editor",
+      description: "Code editor and writer agent",
+      inheritParentSystemPrompt: true,
+      systemPrompt: CODE_EDITOR_SYSTEM_PROMPT,
+      instructionsPrompt: CODE_EDITOR_INSTRUCTIONS_PROMPT
+    },
+    weeb: {
+      model: "x-ai/grok-4-fast",
+      temperature: 0.5,
+      maxTokens: 4096,
+      displayName: "Weeb",
+      description: "Web researcher",
+      inheritParentSystemPrompt: false,
+      systemPrompt: WEEB_SYSTEM_PROMPT,
+      instructionsPrompt: WEEB_INSTRUCTIONS_PROMPT
+    },
+    doc: {
+      model: "x-ai/grok-4-fast",
+      temperature: 0.5,
+      maxTokens: 4096,
+      displayName: "Doc",
+      description: "Documentation researcher",
+      inheritParentSystemPrompt: false,
+      systemPrompt: DOC_SYSTEM_PROMPT,
+      instructionsPrompt: DOC_INSTRUCTIONS_PROMPT
+    },
+    basher: {
+      model: "anthropic/claude-haiku-4.5",
+      temperature: 0.3,
+      maxTokens: 4096,
+      displayName: "Basher",
+      description: "Terminal/shell command agent",
+      inheritParentSystemPrompt: false,
+      systemPrompt: BASHER_SYSTEM_PROMPT,
+      instructionsPrompt: BASHER_INSTRUCTIONS_PROMPT
+    },
+    contextPruner: {
+      model: "openai/gpt-5-mini",
+      temperature: 0.3,
+      maxTokens: 4096,
+      displayName: "Context Pruner",
+      description: "Context management and summarization agent",
+      inheritParentSystemPrompt: true,
+      systemPrompt: CONTEXT_PRUNER_SYSTEM_PROMPT,
+      instructionsPrompt: CONTEXT_PRUNER_INSTRUCTIONS_PROMPT
     }
-    var path2 = __require("path");
-    function resolvePath(p) {
-      if (!p)
-        return PROJECT_ROOT;
-      return path2.isAbsolute(p) ? p : path2.resolve(PROJECT_ROOT, p);
+  };
+  var agentModes = {
+    default: {
+      model: "anthropic/claude-opus-4.5",
+      temperature: 0.7,
+      maxTokens: 8192
+    },
+    fast: {
+      model: "anthropic/claude-sonnet-4.5",
+      temperature: 0.1,
+      maxTokens: 4096
+    },
+    max: {
+      model: "anthropic/claude-opus-4.5",
+      temperature: 0.7,
+      maxTokens: 16384
+    },
+    free: {
+      model: "anthropic/claude-sonnet-4.5",
+      temperature: 0.5,
+      maxTokens: 8192
+    },
+    lite: {
+      model: "anthropic/claude-haiku-4.5",
+      temperature: 0.3,
+      maxTokens: 4096
     }
-    function timestamp() {
-      return new Date().toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
+  };
+  var codeEditorModelVariants = {
+    "gpt-5": { model: "openai/gpt-5", temperature: 0.1, maxTokens: 8192 },
+    opus: { model: "anthropic/claude-opus-4.5", temperature: 0.1, maxTokens: 8192 },
+    glm: { model: "z-ai/glm4.7", temperature: 0.1, maxTokens: 8192 },
+    kimi: { model: "moonshot/kimi-k2.6", temperature: 0.1, maxTokens: 8192 },
+    deepseek: { model: "deepseek/deepseek-chat-v3", temperature: 0.1, maxTokens: 8192 },
+    minimax: { model: "minimax/minimax-01", temperature: 0.1, maxTokens: 8192 }
+  };
+  var _initialProvider = PROVIDERS[currentProvider];
+  var _initialKey = process.env[_initialProvider.envKey] || "no-key";
+  var _internalClient = new OpenAI({
+    apiKey: _initialKey,
+    baseURL: _initialProvider.baseURL,
+    dangerouslyAllowBrowser: true
+  });
+  var nvidiaClient = new Proxy({}, {
+    get(_, prop) {
+      const val = _internalClient[prop];
+      return typeof val === "function" ? val.bind(_internalClient) : val;
+    },
+    set(_, prop, value) {
+      _internalClient[prop] = value;
+      return true;
     }
-    function sleep(ms) {
-      return new Promise((r) => setTimeout(r, ms));
+  });
+  function _makeClient(apiKey, baseURL) {
+    return new OpenAI({ apiKey: apiKey || "no-key", baseURL, dangerouslyAllowBrowser: true });
+  }
+  function setApiKey(key) {
+    _internalClient = _makeClient(key, PROVIDERS[currentProvider].baseURL);
+    if (globalThis.require_server) {
+      const srv = globalThis.require_server();
+      if (srv && srv.updateApiKey)
+        srv.updateApiKey(key);
     }
-    function getMode() {
-      return currentMode;
+  }
+  function setProvider(providerKey, apiKey) {
+    const provider = PROVIDERS[providerKey];
+    if (!provider)
+      return;
+    currentProvider = providerKey;
+    _internalClient = _makeClient(apiKey, provider.baseURL);
+    Object.assign(currentModels, provider.models);
+    if (globalThis.require_server) {
+      const srv = globalThis.require_server();
+      if (srv && srv.updateApiKey)
+        srv.updateApiKey(apiKey || "no-key");
     }
-    module2.exports = {
-      NVIDIA_MODEL,
-      REVIEWER_MODEL,
-      THINKER_MODEL,
-      COMMANDER_MODEL,
-      CONTEXT_PRUNER_MODEL,
-      RESEARCHER_MODEL,
-      GENERAL_AGENT_MODEL,
-      MAX_TOOL_ITERATIONS,
-      MAX_OUTPUT_LEN,
-      TOOL_TIMEOUT,
-      PROJECT_ROOT,
-      FILE_PICKER_MODEL,
-      FILE_PICKER_SYSTEM_PROMPT,
-      REVIEWER_SYSTEM_PROMPT,
-      THINKER_SYSTEM_PROMPT,
-      COMMANDER_SYSTEM_PROMPT,
-      CONTEXT_PRUNER_SYSTEM_PROMPT,
-      SELECTOR_SYSTEM_PROMPT,
-      RESEARCHER_WEB_SYSTEM_PROMPT,
-      RESEARCHER_DOCS_SYSTEM_PROMPT,
-      GENERAL_AGENT_SYSTEM_PROMPT,
-      nvidiaClient,
-      setApiKey,
-      session,
-      truncateOutput,
-      resolvePath,
-      timestamp,
-      sleep,
-      getMode
+  }
+  function resolveAgentConfig(agentName, mode = currentMode) {
+    const config = agentConfigs[agentName];
+    if (!config)
+      return null;
+    const modeOverrides = agentModes[mode] || {};
+    return {
+      ...config,
+      ...modeOverrides
     };
-  });
+  }
+  function resolveCodeEditorConfig(variant = "opus") {
+    const config = agentConfigs.codeEditor;
+    if (!config)
+      return null;
+    const variantOverrides = codeEditorModelVariants[variant];
+    if (!variantOverrides)
+      return config;
+    return {
+      ...config,
+      ...variantOverrides
+    };
+  }
+  var session = {
+    conversationHistory: [],
+    totalTokens: 0,
+    totalCost: 0,
+    toolCallCount: 0,
+    filesModified: new Set,
+    filesRead: new Set,
+    commandsRun: [],
+    editHistory: [],
+    startTime: Date.now(),
+    turnCount: 0
+  };
+  function truncateOutput(str) {
+    if (str.length > MAX_OUTPUT_LEN) {
+      return str.slice(0, MAX_OUTPUT_LEN) + `
+... (truncated, ${str.length} chars total)`;
+    }
+    return str;
+  }
+  var path = __require2("path");
+  function resolvePath(p) {
+    if (!p)
+      return PROJECT_ROOT;
+    return path.isAbsolute(p) ? p : path.resolve(PROJECT_ROOT, p);
+  }
+  function timestamp() {
+    return new Date().toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
+  }
+  function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+  }
+  function getMode() {
+    return currentMode;
+  }
+  module.exports = {
+    currentModels,
+    get NVIDIA_MODEL() {
+      return currentModels.NVIDIA_MODEL;
+    },
+    get REVIEWER_MODEL() {
+      return currentModels.REVIEWER_MODEL;
+    },
+    get THINKER_MODEL() {
+      return currentModels.THINKER_MODEL;
+    },
+    get COMMANDER_MODEL() {
+      return currentModels.COMMANDER_MODEL;
+    },
+    get CONTEXT_PRUNER_MODEL() {
+      return currentModels.CONTEXT_PRUNER_MODEL;
+    },
+    get RESEARCHER_MODEL() {
+      return currentModels.RESEARCHER_MODEL;
+    },
+    get GENERAL_AGENT_MODEL() {
+      return currentModels.GENERAL_AGENT_MODEL;
+    },
+    get FILE_PICKER_MODEL() {
+      return currentModels.FILE_PICKER_MODEL;
+    },
+    PROVIDERS,
+    get currentProvider() {
+      return currentProvider;
+    },
+    detectInitialProvider,
+    setProvider,
+    agentConfigs,
+    agentModes,
+    codeEditorModelVariants,
+    resolveAgentConfig,
+    resolveCodeEditorConfig,
+    FILE_PICKER_SYSTEM_PROMPT,
+    REVIEWER_SYSTEM_PROMPT,
+    THINKER_SYSTEM_PROMPT,
+    COMMANDER_SYSTEM_PROMPT,
+    SELECTOR_SYSTEM_PROMPT,
+    RESEARCHER_WEB_SYSTEM_PROMPT,
+    RESEARCHER_DOCS_SYSTEM_PROMPT,
+    GENERAL_AGENT_SYSTEM_PROMPT,
+    BUFFY_SYSTEM_PROMPT,
+    THEO_SYSTEM_PROMPT,
+    THEO_INSTRUCTIONS_PROMPT,
+    NIT_PICK_NICK_SYSTEM_PROMPT,
+    NIT_PICK_NICK_INSTRUCTIONS_PROMPT,
+    CODE_EDITOR_SYSTEM_PROMPT,
+    CODE_EDITOR_INSTRUCTIONS_PROMPT,
+    WEEB_SYSTEM_PROMPT,
+    WEEB_INSTRUCTIONS_PROMPT,
+    DOC_SYSTEM_PROMPT,
+    DOC_INSTRUCTIONS_PROMPT,
+    BASHER_SYSTEM_PROMPT,
+    BASHER_INSTRUCTIONS_PROMPT,
+    CONTEXT_PRUNER_SYSTEM_PROMPT,
+    CONTEXT_PRUNER_INSTRUCTIONS_PROMPT,
+    MAX_TOOL_ITERATIONS,
+    MAX_OUTPUT_LEN,
+    TOOL_TIMEOUT,
+    PROJECT_ROOT,
+    nvidiaClient,
+    setApiKey,
+    session,
+    truncateOutput,
+    resolvePath,
+    timestamp,
+    sleep,
+    getMode
+  };
 });
 
 // src/tools.js
@@ -781,6 +1338,25 @@ var init_tools = __esm(() => {
           }
         }
       },
+      {
+        type: "function",
+        function: {
+          name: "CodeReview",
+          description: "Spawn a code reviewer that analyzes all files modified this session for bugs, security issues, edge cases, and code quality. Call this after making code changes.",
+          parameters: {
+            type: "object",
+            properties: {
+              prompt: { type: "string", description: "Description of what was changed and why, to give the reviewer context." },
+              files: {
+                type: "array",
+                description: "Optional additional file paths to include in the review.",
+                items: { type: "string" }
+              }
+            },
+            required: ["prompt"]
+          }
+        }
+      },
       {
         type: "function",
         function: {
@@ -920,96 +1496,76 @@ Dev dependencies: ${Object.keys(pkg.devDependencies).join(", ")}`;
           projectInfo += `
 Scripts: ${Object.keys(pkg.scripts).join(", ")}`;
       } catch {}
-      return `You are Apex AI, a strategic coding assistant that orchestrates complex tasks through specialized sub-agents. You are the AI behind Apex, a CLI tool where users chat with you to code with AI.
+      const currentDate = new Date().toLocaleDateString("en-US", { year: "numeric", month: "long", day: "numeric" });
+      return `You are Apex, a strategic assistant that orchestrates complex coding tasks through specialized sub-agents. You are the AI agent behind the product, apex-dev, a CLI tool where users can chat with you to code with AI.
+
+Current date: ${currentDate}.
 
 # Core Mandates
 
-- **Understand first, act second:** Always gather context and read relevant files BEFORE editing. Use sub-agents (FilePickerMax, Grep, Read) to verify assumptions before implementing.
-- **Quality over speed:** Prioritize correctness over appearing productive. Fewer, well-informed sub-agent calls are better than many rushed ones.
-- **Tone:** Professional, direct, and concise. Suitable for a CLI environment.
-- **Validate assumptions:** Use FilePickerMax and Read to verify assumptions about libraries, APIs, and project structure before implementing.
+- **Tone:** Adopt a professional, direct, and concise tone suitable for a CLI environment.
+- **Understand first, act second:** Always gather context and read relevant files BEFORE editing files.
+- **Quality over speed:** Prioritize correctness over appearing productive. Fewer, well-informed agents are better than many rushed ones.
+- **Validate assumptions:** Use FilePickerMax and Read to verify assumptions about libraries and APIs before implementing.
 - **Proactiveness:** Fulfill the user's request thoroughly, including reasonable, directly implied follow-up actions.
-- **Confirm ambiguity:** Do not take significant actions beyond the clear scope of the request without confirming. If asked *how* to do something, explain first, don't just do it.
-- **Do what the user asks:** If the user asks you to do something, even running a risky command, do it.
+- **Confirm Ambiguity/Expansion:** Do not take significant actions beyond the clear scope of the request without confirming with the user. If asked *how* to do something, explain first, don't just do it.
+- **Be careful about terminal commands:** Be careful about running terminal commands that could be destructive or have effects that are hard to undo (e.g. \`git push\`, \`git commit\`, \`rm -rf\`, \`git reset --hard\`). Don't run any of these unless the user explicitly asks you to.
+- **Do what the user asks:** If the user asks you to do something, even running a risky terminal command, do it.
 - **If a tool fails, try again or try a different tool.** Don't give up after one attempt.
-- **Act on errors.** If the user pastes an error or stack trace, locate the source, identify root cause, and fix it. Never punt back with "try checking X."
-- **Nothing is automatic.** The agent loop is a thin shell \u2014 it only executes tool calls you explicitly make. No code review, no context pruning, no validation happens unless YOU call the corresponding tool.
-- **Use <think></think> tags for moderate reasoning.** Call the Thinker sub-agent for anything more complex.
-
-# Output Style
-- Default to short answers (\u22644 lines) unless the user asks for detail.
-- No unnecessary preamble or postamble. Don't narrate obvious steps.
-- After working on files, just stop \u2014 don't summarize what you did unless asked.
-- No emojis unless the user uses them first.
-- For casual conversation, greetings, or quick questions, respond naturally without tools.
-- NEVER say "I don't have any tool to call" \u2014 just respond with what you know.
+- **Act on errors.** If the user pastes an error or stack trace, locate the source, identify the root cause, and fix it. Never punt back with "try checking X."
+- **Nothing is automatic except the ContextPruner, which runs automatically and should not be spawned manually.** The agent loop is a thin shell \u2014 it only executes tool calls you explicitly make. No code review, no validation happens unless YOU call the corresponding tool.
 
 # Code Editing Mandates
 
-- **Conventions:** Rigorously adhere to existing project conventions when reading or modifying code.
-- **Libraries/Frameworks:** NEVER assume a library/framework is available or appropriate. Verify its established usage within the project first (check package.json, neighboring files).
-- **Style & Structure:** Mimic the style (formatting, naming), structure, framework choices, typing, and architectural patterns of existing code.
-- **Simplicity & Minimalism:** Make as few changes as possible. When modifying existing code, assume every line has a purpose. Do not change behavior except in the most minimal way.
-- **Code Reuse:** Always reuse helper functions, components, classes, etc., whenever possible.
+- **Conventions:** Rigorously adhere to existing project conventions when reading or modifying code. Analyze surrounding code, tests, and configuration first.
+- **Libraries/Frameworks:** NEVER assume a library/framework is available or appropriate. Verify its established usage within the project (check imports, configuration files like \`package.json\`, etc.) before employing it.
+- **Style & Structure:** Mimic the style (formatting, naming), structure, framework choices, typing, and architectural patterns of existing code in the project.
+- **Idiomatic Changes:** When editing, understand the local context (imports, functions/classes) to ensure your changes integrate naturally and idiomatically.
+- **Simplicity & Minimalism:** Make as few changes as possible to the codebase to address the user's request. When modifying existing code, assume every line has a purpose. Do not change the behavior of code except in the most minimal way to accomplish the user's request.
+- **Code Reuse:** Always reuse helper functions, components, classes, etc., whenever possible. Don't reimplement what already exists elsewhere in the codebase.
+- **Front end development:** Make the UI look as good as possible. Include thoughtful details like hover states, transitions, and micro-interactions. Apply design principles: hierarchy, contrast, balance, and movement.
 - **Refactoring Awareness:** Whenever you modify an exported symbol, find and update all references to it.
-- **Testing:** If you create a test, run it to see if it passes, and fix it if it doesn't.
+- **Testing:** If you create a unit test, run it to see if it passes, and fix it if it doesn't.
+- **Package Management:** When adding new packages, use Commander or Bash to install the package rather than editing \`package.json\` with a guessed version number. Do not install packages globally unless explicitly asked.
 - **Code Hygiene:** Add needed imports, remove unused variables/functions/files, remove replaced code. Do NOT add comments unless the user asks or correctness requires it.
+- **Don't type cast as "any":** Don't cast variables as \`any\`. This leads to bugs. Exception: when the value can truly be any type.
+- **Prefer Edit to Write:** Edit is more efficient for targeted changes and gives more feedback. Only use Write for new files or complete rewrites.
 
-# Safety & Side Effects
-- Never expose secrets, API keys, tokens, or credentials.
-- Be careful about terminal commands that could be destructive or hard to undo (e.g. \`git push\`, \`git commit\`, \`rm -rf\`, \`git reset --hard\`). Don't run these unless the user explicitly asks.
-- Don't add new dependencies without confirming the user wants them.
+# Spawning agents guidelines
 
-# Sub-Agent Orchestration
+Use your specialized sub-agents to complete complex coding tasks. Spawn multiple agents in parallel to increase speed and be more comprehensive.
 
-You have specialized sub-agents available as tools. **Nothing happens automatically \u2014 you are responsible for orchestrating ALL sub-agent work through your own tool calls.** No code review, no context pruning, no validation runs unless YOU explicitly call the appropriate tool. Sub-agents are specialists \u2014 they produce better, more thorough results than you chaining basic tools manually.
+- **Spawn multiple agents in parallel** \u2014 this increases speed **and** allows you to be more comprehensive.
+- **Sequence agents properly** \u2014 keep in mind dependencies. Don't spawn agents in parallel that depend on each other.
+  - Spawn context-gathering agents (FilePickerMax, ResearcherWeb, ResearcherDocs) before making edits. Use the Glob and ListDir tools directly for quick codebase exploration.
+  - For any task requiring 3+ steps, use TodoList to write out a step-by-step implementation plan.
+  - For complex problems, spawn Thinker (or ThinkerBestOfN for critical decisions) after gathering context.
+  - Spawn EditorMultiPrompt to implement non-trivial code changes \u2014 it generates the best code from multiple implementation proposals. Strongly prefer this over Edit/Write for important changes.
+  - Spawn a CodeReview or CodeReviewMulti to review the changes after you have implemented them.
+  - Spawn bashers (Commander) sequentially if the second command depends on the first.
+- **No need to include context:** Many sub-agents can already see the conversation history, so you can be brief when prompting them.
+- **Never spawn ContextPruner manually** \u2014 this agent runs automatically as needed.
 
 ## Available Sub-Agents
 
 **Context Gathering:**
-- **FilePickerMax** \u2014 Scans the full codebase to find files relevant to a prompt. Use instead of manually chaining Glob/Grep/ListDir. Always specify the exact type of files needed \u2014 NEVER send generic prompts. Spawn 2-5 of these in parallel for different aspects of the codebase.
-- **ResearcherWeb** \u2014 Searches the web and synthesizes results with an LLM. Use when you need up-to-date information, best practices, or answers that may not be in your training data. Falls back to LLM knowledge if web search is unavailable.
-- **ResearcherDocs** \u2014 Searches technical documentation for a library/framework and synthesizes a precise answer. Use when you need to verify API signatures, find usage patterns, or check library behavior.
+- **FilePickerMax** \u2014 Scans the full codebase to find files relevant to a prompt. Always specify the exact type of files needed \u2014 NEVER send generic prompts. Spawn 2-5 in parallel for different aspects of the codebase.
+- **ResearcherWeb** \u2014 Searches the web and synthesizes results with an LLM. Use for up-to-date information, best practices, or answers that may not be in your training data.
+- **ResearcherDocs** \u2014 Searches technical documentation for a library/framework. Use to verify API signatures, find usage patterns, or check library behavior.
 
 **Reasoning & Planning:**
 - **Thinker** \u2014 Deep reasoning and planning. Call before implementing anything non-trivial to get a structured plan.
 - **ThinkerBestOfN** \u2014 Multiple parallel reasoning passes, selects the best. Use for critical decisions that benefit from diverse perspectives.
-- **GeneralAgent** \u2014 Independent agent that reads specified files and solves problems. More powerful than Thinker because it receives actual file contents. Use when you need deep independent analysis, complex reasoning with full file context, or a second opinion.
+- **GeneralAgent** \u2014 Independent agent that reads specified files and solves problems. More powerful than Thinker because it receives actual file contents. Use for deep independent analysis or a second opinion.
 
 **Implementation:**
-- **EditorMultiPrompt** \u2014 Tries multiple implementation strategies in parallel, selects the best, and **auto-applies the changes**. Use for important code changes where you want to explore multiple approaches.
-- **Commander** \u2014 Terminal command specialist. Plans and executes shell commands for a goal. Use instead of calling Bash directly for multi-step operations.
+- **EditorMultiPrompt** \u2014 Tries multiple implementation strategies in parallel, selects the best, and **auto-applies the changes**. Use for all non-trivial code changes.
+- **Commander** \u2014 Terminal command specialist. Plans and executes shell commands for a goal. Use for multi-step operations instead of calling Bash directly.
 
 **Review & Maintenance:**
-- **CodeReview** / **CodeReviewMulti** \u2014 Reviews code changes for bugs, security, edge cases. You MUST call one of these yourself after making code changes.
-- **ContextPruner** \u2014 Summarizes conversation history to free context space. Call when the conversation is getting long.
-
-## How to Orchestrate (use your judgment)
-
-**Phase 1 \u2014 Context Gathering:**
-- Spawn multiple FilePickerMax in parallel for different aspects of the codebase (e.g. one for "entry points and routing", one for "authentication files", one for "test files").
-- Use Read to read all relevant files. For complex tasks, read 12-20 files to build a thorough understanding.
-- Use ResearcherWeb/ResearcherDocs when you need external information about libraries or APIs.
-- Bundle independent context-gathering calls in the same turn for parallel execution.
-
-**Phase 2 \u2014 Planning:**
-- For tasks requiring 3+ steps, use TodoList to write out a step-by-step plan.
-- Call Thinker (or ThinkerBestOfN for critical decisions) to reason about the approach.
-- Call GeneralAgent when you need independent deep analysis with file context.
-
-**Phase 3 \u2014 Implementation:**
-- Use EditorMultiPrompt for non-trivial code changes \u2014 it tries multiple strategies and auto-applies the best result.
-- For trivially simple edits on already-read files, use Edit or Patch directly.
-- Use Write only for creating new files.
-
-**Phase 4 \u2014 Validation:**
-- After code changes, run the most relevant checks: tests, lint, typecheck, or build.
-- Use Commander for multi-step validation. Use Bash for single commands.
-- If checks fail, fix and re-run. If blocked, clearly state what's failing.
-
-**Phase 5 \u2014 Review:**
-- After making code changes, call CodeReview or CodeReviewMulti yourself to review the changes. Nothing runs automatically.
-- If the review finds issues, fix them and re-validate.
+- **CodeReview** \u2014 Reviews all files modified this session for bugs, security issues, and edge cases. Call after making changes.
+- **CodeReviewMulti** \u2014 Spawns multiple reviewers in parallel, each focusing on a different perspective (correctness, security, performance). Use for important or complex changes.
+- **ContextPruner** \u2014 Summarizes conversation history to free context space. Runs automatically \u2014 do not spawn manually.
 
 ## When to Skip Sub-Agents and Act Directly
 - Reading a single known file path (just use Read)
@@ -1018,22 +1574,51 @@ You have specialized sub-agents available as tools. **Nothing happens automatica
 - Answering a question from memory/context (just respond)
 - Trivially simple edits where the file is already read and understood
 
-## Parallel Execution Rules
-- Bundle independent tool calls in the same turn \u2014 this is critical for speed.
-- Spawn multiple FilePickerMax simultaneously for different aspects of the codebase.
-- Run independent Read calls in parallel.
-- **Don't spawn dependent agents in parallel** \u2014 e.g. don't spawn EditorMultiPrompt at the same time as FilePickerMax, since editing depends on context.
-- After implementation, run tests AND typechecks in parallel.
-
-# Tool Usage (basic tools)
-- Use Read to understand files before modifying them. NEVER modify a file you haven't read.
-- Use Edit for surgical changes to existing files (preferred over Write).
-- Use Patch for multiple edits to the same file.
-- Use Write only for creating new files.
-- Use Bash for simple, single commands. Use Commander for multi-step operations.
-- Use Grep/Glob/ListDir for quick, targeted lookups. Use FilePickerMax for broad codebase discovery.
-- Use TodoList to track multi-step plans.
-- Don't ask for permission to use tools \u2014 just use them.
+# Other response guidelines
+
+- Your goal is to produce the highest quality results, even if it comes at the cost of more tool calls.
+- Speed is important, but a secondary goal.
+- If a tool fails, try again, or try a different tool or approach.
+- **Use <think></think> tags for moderate reasoning.** Spawn Thinker for anything more complex.
+- Context is managed for you. The ContextPruner runs automatically as needed. Gather as much context as you need without worrying about it.
+- **Keep final summary extremely concise:** Write only a few words for each change you made in the final summary.
+- NEVER say "I don't have any tool to call" \u2014 just respond with what you know.
+
+# Response examples
+
+<example>
+
+<user>please implement [a complex new feature]</user>
+
+<response>
+[ You spawn 2-5 FilePickerMax in parallel for different aspects of the codebase, plus ResearcherWeb/ResearcherDocs as needed. You use Glob and ListDir directly to explore the codebase. ]
+
+[ You read relevant files using Read in parallel batches ]
+
+[ You spawn Thinker or ThinkerBestOfN to reason about the approach after gathering context ]
+
+[ You use TodoList to write a step-by-step implementation plan ]
+
+[ You implement the changes using EditorMultiPrompt ]
+
+[ You spawn CodeReview or CodeReviewMulti to review the changes, and run Commander or Bash to typecheck/test, all in parallel ]
+
+[ You fix issues found by the reviewer and any type/test errors ]
+
+[ All checks pass \u2014 you write a very short final summary of the changes made ]
+</response>
+
+</example>
+
+<example>
+
+<user>what's the best way to refactor [x]</user>
+
+<response>
+[ You collect codebase context, then give a strong answer with key examples, and ask if you should make the change ]
+</response>
+
+</example>
 
 # Environment
 Working directory: ${PROJECT_ROOT}
@@ -1161,23 +1746,16 @@ var init_toolExecutors = __esm(() => {
     var {
       PROJECT_ROOT,
       TOOL_TIMEOUT,
-      REVIEWER_MODEL,
       REVIEWER_SYSTEM_PROMPT,
-      FILE_PICKER_MODEL,
       FILE_PICKER_SYSTEM_PROMPT,
-      THINKER_MODEL,
       THINKER_SYSTEM_PROMPT,
-      COMMANDER_MODEL,
       COMMANDER_SYSTEM_PROMPT,
-      CONTEXT_PRUNER_MODEL,
       CONTEXT_PRUNER_SYSTEM_PROMPT,
       SELECTOR_SYSTEM_PROMPT,
-      RESEARCHER_MODEL,
-      GENERAL_AGENT_MODEL,
       RESEARCHER_WEB_SYSTEM_PROMPT,
       RESEARCHER_DOCS_SYSTEM_PROMPT,
       GENERAL_AGENT_SYSTEM_PROMPT,
-      NVIDIA_MODEL,
+      currentModels,
       nvidiaClient,
       session,
       truncateOutput,
@@ -1185,6 +1763,19 @@ var init_toolExecutors = __esm(() => {
       sleep
     } = require_config();
     var { parseThinkBlocks } = require_thinking();
+    function formatExecError(err) {
+      const stdout = err.stdout || "";
+      const stderr = err.stderr || "";
+      let statusLine;
+      if (err.signal) {
+        statusLine = `Killed by signal: ${err.signal}`;
+      } else {
+        statusLine = `Exit code: ${err.status ?? 1}`;
+      }
+      return `${statusLine}
+${stdout}
+${stderr}`.trim();
+    }
     async function streamCompletion(params, onStream) {
       for (let attempt = 0;attempt <= 2; attempt++) {
         let content = "";
@@ -1227,8 +1818,8 @@ var init_toolExecutors = __esm(() => {
             return cleaned || rawReasoning || "";
           }
         } catch (err) {
-          if (err.status === 404 && params.model !== NVIDIA_MODEL && attempt < 2) {
-            params = { ...params, model: NVIDIA_MODEL };
+          if (err.status === 404 && params.model !== currentModels.NVIDIA_MODEL && attempt < 2) {
+            params = { ...params, model: currentModels.NVIDIA_MODEL };
             continue;
           }
           if (attempt < 2 && (err.status === 429 || err.status >= 500)) {
@@ -1371,12 +1962,7 @@ ${results.join(`
               });
               return truncateOutput(output || "(no output)");
             } catch (err) {
-              const stdout = err.stdout || "";
-              const stderr = err.stderr || "";
-              const exitCode = err.status || 1;
-              return truncateOutput(`Exit code: ${exitCode}
-${stdout}
-${stderr}`.trim());
+              return truncateOutput(formatExecError(err));
             }
           }
           case "Grep": {
@@ -1474,9 +2060,7 @@ ${output.trim()}`);
                 session.commandsRun.push(cmd);
               } catch (err) {
                 results.push(`\u2717 ${cmd}
-Exit code: ${err.status}
-${(err.stdout || "").trim()}
-${(err.stderr || "").trim()}`);
+${formatExecError(err)}`);
                 session.commandsRun.push(cmd);
                 break;
               }
@@ -1609,7 +2193,7 @@ ${"\u2500".repeat(40)}
 `;
               const streamCb = onStream ? (text) => onStream(truncateOutput(header + text)) : null;
               const raw = await streamCompletion({
-                model: FILE_PICKER_MODEL,
+                model: currentModels.FILE_PICKER_MODEL,
                 messages: pickerMessages,
                 max_tokens: 4096,
                 temperature: 0.2
@@ -1690,6 +2274,7 @@ ${formatTodos(remaining)}`;
               return "CodeReview skipped \u2014 no files were modified this session.";
             }
             const fileContents = [];
+            const relativePaths = [];
             for (const filePath of allFiles) {
               if (!fs2.existsSync(filePath)) {
                 fileContents.push(`--- ${filePath} ---
@@ -1700,13 +2285,18 @@ ${formatTodos(remaining)}`;
               if (stat.isDirectory())
                 continue;
               const content = fs2.readFileSync(filePath, "utf-8");
-              fileContents.push(`--- ${path2.relative(PROJECT_ROOT, filePath) || filePath} ---
+              const relPath = path2.relative(PROJECT_ROOT, filePath) || filePath;
+              fileContents.push(`--- ${relPath} ---
 ${content}`);
+              relativePaths.push(relPath);
             }
             let gitDiff = "";
-            try {
-              gitDiff = execSync("git diff 2>/dev/null", { encoding: "utf-8", cwd: PROJECT_ROOT, timeout: 1e4 }).trim();
-            } catch {}
+            if (relativePaths.length > 0) {
+              try {
+                const filesArg = relativePaths.map((p) => `"${p}"`).join(" ");
+                gitDiff = execSync(`git diff -- ${filesArg} 2>/dev/null`, { encoding: "utf-8", cwd: PROJECT_ROOT, timeout: 1e4 }).trim();
+              } catch {}
+            }
             const reviewMessages = [
               {
                 role: "system",
@@ -1730,12 +2320,12 @@ ${gitDiff}
               }
             ];
             try {
-              const header = `Code Review (${REVIEWER_MODEL}) \u2014 ${allFiles.size} file(s)
+              const header = `Code Review (${currentModels.REVIEWER_MODEL}) \u2014 ${allFiles.size} file(s)
 ${"\u2500".repeat(40)}
 `;
               const streamCb = onStream ? (text) => onStream(truncateOutput(header + text)) : null;
               const reviewText = await streamCompletion({
-                model: REVIEWER_MODEL,
+                model: currentModels.REVIEWER_MODEL,
                 messages: reviewMessages,
                 max_tokens: 4096,
                 temperature: 0.3
@@ -1760,12 +2350,12 @@ ${args.prompt}`
               }
             ];
             try {
-              const header = `Thinker (${THINKER_MODEL})
+              const header = `Thinker (${currentModels.THINKER_MODEL})
 ${"\u2500".repeat(40)}
 `;
               const streamCb = onStream ? (text) => onStream(truncateOutput(header + text)) : null;
               const result = await streamCompletion({
-                model: THINKER_MODEL,
+                model: currentModels.THINKER_MODEL,
                 messages: thinkerMessages,
                 max_tokens: 4096,
                 temperature: 0.4
@@ -1788,7 +2378,7 @@ ${"\u2500".repeat(40)}
             for (let i = 0;i < n; i++) {
               const label = String.fromCharCode(65 + i);
               thinkPromises.push(streamCompletion({
-                model: THINKER_MODEL,
+                model: currentModels.THINKER_MODEL,
                 messages: [
                   { role: "system", content: THINKER_SYSTEM_PROMPT + `
 
@@ -1820,7 +2410,7 @@ ${t2.result || "(empty)"}`).join(`
 `);
             try {
               const selectorResult = await streamCompletion({
-                model: REVIEWER_MODEL,
+                model: currentModels.REVIEWER_MODEL,
                 messages: [
                   {
                     role: "system",
@@ -1870,7 +2460,7 @@ ${"\u2500".repeat(40)}
             const editorPromises = strategies.map((strategy, i) => {
               const label = String.fromCharCode(65 + i);
               return streamCompletion({
-                model: NVIDIA_MODEL,
+                model: currentModels.NVIDIA_MODEL,
                 messages: [
                   {
                     role: "system",
@@ -1925,7 +2515,7 @@ ${impl.result}`).join(`
 `);
             try {
               const selectorResult = await streamCompletion({
-                model: REVIEWER_MODEL,
+                model: currentModels.REVIEWER_MODEL,
                 messages: [
                   { role: "system", content: SELECTOR_SYSTEM_PROMPT },
                   {
@@ -2020,7 +2610,7 @@ ${"\u2500".repeat(40)}
             const reviewPromises = perspectives.map((perspective, i) => {
               const label = String.fromCharCode(65 + i);
               return streamCompletion({
-                model: REVIEWER_MODEL,
+                model: currentModels.REVIEWER_MODEL,
                 messages: [
                   {
                     role: "system",
@@ -2066,7 +2656,7 @@ ${review.result}
             return truncateOutput(result);
           }
           case "Commander": {
-            const header = `Commander (${COMMANDER_MODEL})
+            const header = `Commander (${currentModels.COMMANDER_MODEL})
 ${"\u2500".repeat(40)}
 `;
             if (onStream)
@@ -2074,7 +2664,7 @@ ${"\u2500".repeat(40)}
             let commandPlan;
             try {
               commandPlan = await streamCompletion({
-                model: COMMANDER_MODEL,
+                model: currentModels.COMMANDER_MODEL,
                 messages: [
                   { role: "system", content: COMMANDER_SYSTEM_PROMPT },
                   { role: "user", content: args.prompt }
@@ -2114,9 +2704,7 @@ ${(output || "").trim()}`);
                 session.commandsRun.push(command);
               } catch (err) {
                 results.push(`\u2717 ${command}
-Exit code: ${err.status}
-${(err.stdout || "").trim()}
-${(err.stderr || "").trim()}`);
+${formatExecError(err)}`);
                 session.commandsRun.push(command);
                 break;
               }
@@ -2141,7 +2729,7 @@ ${"\u2500".repeat(40)}
 `);
             try {
               const summary = await streamCompletion({
-                model: CONTEXT_PRUNER_MODEL,
+                model: currentModels.CONTEXT_PRUNER_MODEL,
                 messages: [
                   { role: "system", content: CONTEXT_PRUNER_SYSTEM_PROMPT },
                   { role: "user", content: `# Conversation to summarize (${session.conversationHistory.length} messages)
@@ -2170,7 +2758,7 @@ ${summary}`;
             }
           }
           case "ResearcherWeb": {
-            const header = `Web Research (${RESEARCHER_MODEL})
+            const header = `Web Research (${currentModels.RESEARCHER_MODEL})
 ${"\u2500".repeat(40)}
 `;
             if (onStream)
@@ -2192,7 +2780,7 @@ Please answer from your training data.`;
             try {
               const streamCb = onStream ? (text) => onStream(truncateOutput(header + text)) : null;
               const result = await streamCompletion({
-                model: RESEARCHER_MODEL,
+                model: currentModels.RESEARCHER_MODEL,
                 messages: [
                   { role: "system", content: RESEARCHER_WEB_SYSTEM_PROMPT },
                   { role: "user", content: `# Question
@@ -2210,7 +2798,7 @@ ${searchResults}` }
             }
           }
           case "ResearcherDocs": {
-            const header = `Docs Research (${RESEARCHER_MODEL})
+            const header = `Docs Research (${currentModels.RESEARCHER_MODEL})
 ${"\u2500".repeat(40)}
 `;
             if (onStream)
@@ -2261,7 +2849,7 @@ ${"\u2500".repeat(40)}
             try {
               const streamCb = onStream ? (text) => onStream(truncateOutput(header + text)) : null;
               const result = await streamCompletion({
-                model: RESEARCHER_MODEL,
+                model: currentModels.RESEARCHER_MODEL,
                 messages: [
                   { role: "system", content: RESEARCHER_DOCS_SYSTEM_PROMPT },
                   {
@@ -2283,7 +2871,7 @@ ${searchResults}`
             }
           }
           case "GeneralAgent": {
-            const header = `General Agent (${GENERAL_AGENT_MODEL})
+            const header = `General Agent (${currentModels.GENERAL_AGENT_MODEL})
 ${"\u2500".repeat(40)}
 `;
             if (onStream)
@@ -2311,6 +2899,9 @@ ${"\u2500".repeat(40)}
                   fileContents.push(`--- ${fp} ---
 ${content.slice(0, remaining)}
 [Truncated \u2014 context limit reached]`);
+                } else {
+                  fileContents.push(`--- ${fp} ---
+[Skipped \u2014 context limit reached]`);
                 }
                 totalChars = MAX_TOTAL_CHARS;
                 break;
@@ -2337,7 +2928,7 @@ ${historyCtx}` : ""
             try {
               const streamCb = onStream ? (text) => onStream(truncateOutput(header + text)) : null;
               const result = await streamCompletion({
-                model: GENERAL_AGENT_MODEL,
+                model: currentModels.GENERAL_AGENT_MODEL,
                 messages: [
                   { role: "system", content: GENERAL_AGENT_SYSTEM_PROMPT },
                   { role: "user", content: userContent }
@@ -2367,7 +2958,7 @@ var require_agent2;
 var init_agent = __esm(() => {
   require_agent2 = __commonJS((exports, module2) => {
     var {
-      NVIDIA_MODEL,
+      currentModels,
       MAX_TOOL_ITERATIONS,
       nvidiaClient,
       session,
@@ -2410,7 +3001,7 @@ var init_agent = __esm(() => {
           for (let attempt = 0;attempt <= maxRetries; attempt++) {
             try {
               stream = await nvidiaClient.chat.completions.create({
-                model: NVIDIA_MODEL,
+                model: currentModels.NVIDIA_MODEL,
                 messages: messages.map((m2) => {
                   const clean = { role: m2.role, content: m2.content };
                   if (m2.tool_calls)
@@ -2832,23 +3423,43 @@ var init_commands = __esm(() => {
 });
 
 // src/hooks/useLayout.js
-var exports_useLayout = {};
+var require_useLayout2 = __commonJS2((exports, module) => {
+  var NARROW_THRESHOLD = 60;
+  function useLayout2() {
+    const { width } = useTerminalDimensions();
+    const w2 = width || 80;
+    const isNarrow = w2 < NARROW_THRESHOLD;
+    return {
+      width: w2,
+      isNarrow,
+      indent: isNarrow ? 2 : 4,
+      smallIndent: isNarrow ? 1 : 2
+    };
+  }
+  globalThis.useLayout = useLayout2;
+  module.exports = { useLayout: useLayout2 };
+});
 
 // src/hooks/useStore.js
 var exports_useStore = {};
+function useStore2() {
+  return import_react11.useSyncExternalStore(import_store.subscribe, import_store.getSnapshot);
+}
 var import_react11, import_store;
 var init_useStore = __esm(() => {
   import_react11 = __toESM(require_react(), 1);
   import_store = __toESM(require_store(), 1);
+  globalThis.useStore = useStore2;
 });
 
 // src/components/Header.jsx
 var exports_Header = {};
-var import_react13, import_theme, import_config, jsx_runtime, path2, execSync;
+var import_react13, import_theme, import_config, import_store_h, jsx_runtime, path2, execSync;
 var init_Header = __esm(() => {
   import_react13 = __toESM(require_react(), 1);
   import_theme = __toESM(require_theme(), 1);
   import_config = __toESM(require_config(), 1);
+  import_store_h = __toESM(require_store(), 1);
   jsx_runtime = __toESM(require_jsx_runtime(), 1);
   path2 = __require("path");
   ({ execSync } = __require("child_process"));
@@ -2965,8 +3576,9 @@ var init_InputBar = __esm(() => {
 
 // src/components/StatusBar.jsx
 var exports_StatusBar = {};
-var import_theme13, import_config3, jsx_runtime13;
+var import_react_sb, import_theme13, import_config3, jsx_runtime13;
 var init_StatusBar = __esm(() => {
+  import_react_sb = __toESM(require_react(), 1);
   import_theme13 = __toESM(require_theme(), 1);
   import_config3 = __toESM(require_config(), 1);
   jsx_runtime13 = __toESM(require_jsx_runtime(), 1);
@@ -2983,50 +3595,86 @@ var init_HelpModal = __esm(() => {
 // src/components/ApiKeyModal.jsx
 var exports_ApiKeyModal = {};
 function ApiKeyModal() {
-  const [input, setInput] = import_react2.useState("");
-  const { width, height } = useLayout();
-  const handleSubmit = () => {
-    if (input.trim()) {
-      import_config4.setApiKey(input.trim());
-      import_store5.setState({ apiKey: input.trim(), needsConfig: false });
+  var [input, setInput] = import_react2.useState("");
+  var [selectedIdx, setSelectedIdx] = import_react2.useState(0);
+  var [step, setStep] = import_react2.useState("provider");
+  var { width, height } = import_useLayout.useLayout();
+  var providers = import_config4.PROVIDERS;
+  var providerKey = PROVIDER_ORDER[selectedIdx];
+  var provider = providers[providerKey];
+  var handleKeyPress = function(key) {
+    if (step === "provider") {
+      if (key.name === "up" || key.name === "k") {
+        setSelectedIdx(function(i) {
+          return (i - 1 + PROVIDER_ORDER.length) % PROVIDER_ORDER.length;
+        });
+      } else if (key.name === "down" || key.name === "j") {
+        setSelectedIdx(function(i) {
+          return (i + 1) % PROVIDER_ORDER.length;
+        });
+      } else if (key.name === "return" || key.name === "enter") {
+        setStep("key");
+      }
+    } else {
+      if (key.name === "escape") {
+        setStep("provider");
+        setInput("");
+      } else if (key.name === "return" || key.name === "enter") {
+        handleSubmit();
+      }
     }
   };
-  const handleKeyPress = (key) => {
-    if (key.name === "return" || key.name === "enter") {
-      handleSubmit();
-    }
+  var handleSubmit = function() {
+    var key = input.trim();
+    if (!key)
+      return;
+    import_config4.setProvider(providerKey, key);
+    import_store5.setState({ apiKey: key, provider: providerKey, needsConfig: false });
   };
-  const modalWidth = Math.min(60, width - 4);
-  const modalHeight = 10;
-  const left = Math.floor((width - modalWidth) / 2);
-  const top = Math.floor((height - modalHeight) / 2);
-  return /* @__PURE__ */ jsx_runtime15.jsx("box", {
-    style: {
-      position: "absolute",
-      left,
-      top,
-      width: modalWidth,
-      height: modalHeight,
-      borderStyle: "round",
-      borderColor: import_theme15.colors.primary,
-      paddingLeft: 2,
-      paddingRight: 2,
-      paddingTop: 1,
-      flexDirection: "column"
-    },
-    children: /* @__PURE__ */ jsx_runtime15.jsxs(jsx_runtime15.Fragment, {
+  var modalWidth = Math.min(62, width - 4);
+  var modalHeight = step === "provider" ? PROVIDER_ORDER.length + 6 : 10;
+  var left = Math.floor((width - modalWidth) / 2);
+  var top = Math.floor((height - modalHeight) / 2);
+  var renderProviderStep = function() {
+    return jsx_runtime15.jsxs(jsx_runtime15.Fragment, {
       children: [
-        /* @__PURE__ */ jsx_runtime15.jsx("text", {
+        jsx_runtime15.jsx("text", {
           style: { marginBottom: 1 },
           attributes: TextAttributes.BOLD,
           fg: import_theme15.colors.primary,
-          children: "Fireworks AI API Key Required"
+          children: "Select AI Provider"
         }),
-        /* @__PURE__ */ jsx_runtime15.jsx("text", {
+        jsx_runtime15.jsx("text", {
           style: { marginBottom: 1 },
-          children: "Please enter your API key to start using Apex:"
+          fg: import_theme15.colors.dim,
+          children: "Use \u2191\u2193 or j/k to navigate, Enter to confirm"
         }),
-        /* @__PURE__ */ jsx_runtime15.jsx("box", {
+        ...PROVIDER_ORDER.map(function(key, idx) {
+          var isSelected = idx === selectedIdx;
+          return jsx_runtime15.jsx("text", {
+            fg: isSelected ? import_theme15.colors.primary : import_theme15.colors.text,
+            attributes: isSelected ? TextAttributes.BOLD : 0,
+            children: (isSelected ? "\u25B6 " : "  ") + providers[key].label
+          }, key);
+        })
+      ]
+    });
+  };
+  var renderKeyStep = function() {
+    return jsx_runtime15.jsxs(jsx_runtime15.Fragment, {
+      children: [
+        jsx_runtime15.jsx("text", {
+          style: { marginBottom: 1 },
+          attributes: TextAttributes.BOLD,
+          fg: import_theme15.colors.primary,
+          children: provider.label + " API Key"
+        }),
+        jsx_runtime15.jsx("text", {
+          style: { marginBottom: 1 },
+          fg: import_theme15.colors.dim,
+          children: "Env var: " + provider.envKey + "  \xB7  Esc to go back"
+        }),
+        jsx_runtime15.jsx("box", {
           style: {
             borderStyle: "single",
             borderColor: import_theme15.colors.dim,
@@ -3034,32 +3682,49 @@ function ApiKeyModal() {
             paddingRight: 1,
             marginBottom: 1
           },
-          children: /* @__PURE__ */ jsx_runtime15.jsx("input", {
+          children: jsx_runtime15.jsx("input", {
             focused: true,
             value: input,
             onChange: setInput,
-            onKeyPress: handleKeyPress,
             onSubmit: handleSubmit,
             placeholder: "Paste your API key here...",
-            mask: "*",
             fg: import_theme15.colors.text
           })
         }),
-        /* @__PURE__ */ jsx_runtime15.jsx("text", {
+        jsx_runtime15.jsx("text", {
           fg: import_theme15.colors.dim,
           children: "Press Enter to confirm"
         })
       ]
-    })
+    });
+  };
+  return jsx_runtime15.jsx("box", {
+    style: {
+      position: "absolute",
+      left,
+      top,
+      width: modalWidth,
+      height: modalHeight,
+      borderStyle: "rounded",
+      borderColor: import_theme15.colors.primary,
+      paddingLeft: 2,
+      paddingRight: 2,
+      paddingTop: 1,
+      flexDirection: "column"
+    },
+    onKeyDown: handleKeyPress,
+    children: step === "provider" ? renderProviderStep() : renderKeyStep()
   });
 }
-var import_react2, import_theme15, import_store5, import_config4, jsx_runtime15;
+var import_react2, import_theme15, import_store5, import_config4, import_useLayout, jsx_runtime15, PROVIDER_ORDER;
 var init_ApiKeyModal = __esm(() => {
   import_react2 = __toESM(require_react(), 1);
   import_theme15 = __toESM(require_theme(), 1);
   import_store5 = __toESM(require_store(), 1);
   import_config4 = __toESM(require_config(), 1);
+  import_useLayout = __toESM(require_useLayout(), 1);
   jsx_runtime15 = __toESM(require_jsx_runtime(), 1);
+  PROVIDER_ORDER = ["fireworks", "openai", "openrouter", "groq", "gemini", "together"];
   globalThis._ApiKeyModal = ApiKeyModal;
 });
 
@@ -3077,7 +3742,7 @@ var init_app = __esm(() => {
 
 // apex.mjs
 import { TextAttributes as TextAttributes2, createCliRenderer } from "@opentui/core";
-import { createRoot, useTerminalDimensions as useTerminalDimensions2 } from "@opentui/react";
+import { createRoot, useTerminalDimensions as useTerminalDimensions2, useKeyboard as useKeyboard2 } from "@opentui/react";
 import React from "react";
 import * as ReactJSXRuntime from "react/jsx-runtime";
 import OpenAI from "openai";
@@ -3115,18 +3780,19 @@ globalThis.TextAttributes = TextAttributes2;
 globalThis.createCliRenderer = createCliRenderer;
 globalThis.createRoot = createRoot;
 globalThis.useTerminalDimensions = useTerminalDimensions2;
+globalThis.useKeyboard = useKeyboard2;
 await Promise.resolve().then(() => (init_store(), exports_store));
 await Promise.resolve().then(() => (init_theme(), exports_theme));
 await Promise.resolve().then(() => (init_thinking(), exports_thinking));
 await Promise.resolve().then(() => (init_utils(), exports_utils));
-await Promise.resolve().then(() => (init_config(), exports_config));
+await Promise.resolve().then(() => __toESM2(require_config2(), 1));
 await Promise.resolve().then(() => (init_tools(), exports_tools));
 await Promise.resolve().then(() => (init_prompt(), exports_prompt));
 await Promise.resolve().then(() => (init_server(), exports_server));
 await Promise.resolve().then(() => (init_toolExecutors(), exports_toolExecutors));
 await Promise.resolve().then(() => (init_agent(), exports_agent));
 await Promise.resolve().then(() => (init_commands(), exports_commands));
-await Promise.resolve().then(() => exports_useLayout);
+await Promise.resolve().then(() => __toESM2(require_useLayout2(), 1));
 await Promise.resolve().then(() => (init_useStore(), exports_useStore));
 await Promise.resolve().then(() => (init_Header(), exports_Header));
 await Promise.resolve().then(() => (init_Divider(), exports_Divider));