apex-dev 3.1.0 → 3.4.0

package/dist/index.js

@@ -29,8 +29,8 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
-// node_modules/@opentui/react/chunk-2mx7fq49.js
-var init_chunk_2mx7fq49 = () => {};
+// node_modules/@opentui/react/chunk-eecw9x2f.js
+var init_chunk_eecw9x2f = () => {};
 
 // node_modules/react/cjs/react.production.js
 var exports_react_production = {};
@@ -24044,11 +24044,11 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
   });
 });
 
-// node_modules/@opentui/react/chunk-bdqvmfwv.js
-var exports_chunk_bdqvmfwv = {};
+// node_modules/@opentui/react/chunk-pm1hna8x.js
+var exports_chunk_pm1hna8x = {};
 var import_react_devtools_core, g;
-var init_chunk_bdqvmfwv = __esm(async () => {
-  init_chunk_2mx7fq49();
+var init_chunk_pm1hna8x = __esm(async () => {
+  init_chunk_eecw9x2f();
   import_react_devtools_core = __toESM(require_backend(), 1);
   g = globalThis;
   if (typeof g.WebSocket === "undefined") {
@@ -31683,7 +31683,7 @@ var require_config = __commonJS((exports, module2) => {
   var MAX_OUTPUT_LEN = 12000;
   var TOOL_TIMEOUT = 60000;
   var PROJECT_ROOT = process.cwd();
-  var currentMode = "default";
+  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.
@@ -31815,13 +31815,6 @@ Output JSON only, no markdown fences:
   function getMode() {
     return currentMode;
   }
-  function setMode(mode) {
-    if (["default", "max", "lite"].includes(mode)) {
-      currentMode = mode;
-      return true;
-    }
-    return false;
-  }
   module2.exports = {
     NVIDIA_MODEL,
     REVIEWER_MODEL,
@@ -31845,8 +31838,7 @@ Output JSON only, no markdown fences:
     resolvePath,
     timestamp,
     sleep,
-    getMode,
-    setMode
+    getMode
   };
 });
 
@@ -31855,7 +31847,7 @@ var require_prompt = __commonJS((exports, module2) => {
   var fs2 = __require("fs");
   var path2 = __require("path");
   var { execSync } = __require("child_process");
-  var { PROJECT_ROOT, MAX_TOOL_ITERATIONS, getMode } = require_config();
+  var { PROJECT_ROOT, MAX_TOOL_ITERATIONS } = require_config();
   function buildSystemPrompt() {
     let gitInfo = "";
     try {
@@ -31883,82 +31875,87 @@ Dev dependencies: ${Object.keys(pkg.devDependencies).join(", ")}`;
         projectInfo += `
 Scripts: ${Object.keys(pkg.scripts).join(", ")}`;
     } catch {}
-    return `You are Apex AI, an agentic CLI coding assistant that runs in the terminal. Be concise, precise, and action-oriented.
+    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.
+
+# Core Mandates
+
+- **Tone:** Professional, direct, and concise. Suitable for a CLI environment.
+- **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.
+- **Validate assumptions:** Use FilePickerMax and Read to verify assumptions about libraries, APIs, and project structure 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.
+- **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."
 
 # Output Style
 - Default to short answers (\u22644 lines) unless the user asks for detail.
-- No unnecessary preamble or postamble. Don't narrate obvious steps or explain what you're about to do.
+- 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.
-- Use bullets and monospace for commands, file paths, and code identifiers.
 - No emojis unless the user uses them first.
-- For casual conversation, greetings, or quick questions, respond naturally without tools or formatting.
-- NEVER say things like "I don't have any tool to call" \u2014 just respond with what you know.
-
-# Core Behavior
-1. **Finish the task.** When asked to do something, DO it with tools until complete. Don't just explain how.
-2. **Read before edit.** NEVER modify a file you haven't read. Understand existing code first.
-3. **Work incrementally.** Make small changes, verify they work, then continue.
-4. **Keep going.** If a tool call fails, recover and try another approach. Don't give up after one attempt.
-5. **Existing code: be surgical.** Only change what's needed. Don't refactor, add features, or "improve" beyond what was asked. Match existing style, patterns, and dependencies.
-6. **New/greenfield work:** You may propose structure and be creative, but keep scope minimal.
-7. **Act on errors.** If the user pastes an error or stack trace, use tools to locate the exact source, identify root cause, and fix it. Never punt back with "try checking X."
+- 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.
+- Use <think></think> tags for moderate reasoning. Call the Thinker sub-agent for anything more complex.
+
+# 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.
+- **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.
+- **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.
 
 # Safety & Side Effects
-- Never expose secrets, API keys, tokens, or credentials. Don't display .env contents.
-- Never run destructive commands (\`rm -rf\`, \`git reset --hard\`, \`git clean -fdx\`) without asking.
-- Never \`git commit\` or \`git push\` unless the user explicitly asks.
+- 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.
-- NEVER assume a library is available. Check package.json or neighboring files first.
 
-# Code Hygiene
-- Do NOT add code comments or docstrings unless the user asks or correctness requires it.
-- Match existing code style, naming conventions, frameworks, and patterns.
-- When creating new files or components, look at existing ones first to follow conventions.
-- Follow security best practices. Never introduce code that exposes or logs secrets.
-
-# Validation
-- After code changes, run the most relevant checks: tests, lint, typecheck, or build. Prefer scripts from package.json.
-- If checks fail, fix and re-run. If blocked, clearly state what's failing and why.
-- Start with targeted tests for what you changed, then broaden if needed.
+# Sub-Agent Orchestration
+
+You have specialized sub-agents available as tools. **Your strong default should be to delegate to sub-agents** for anything beyond trivially simple operations. Sub-agents are specialists \u2014 they produce better, more thorough results than you chaining basic tools manually.
+
+**Available sub-agents:**
+- **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.
+- **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.
+- **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.
+- **CodeReview** \u2014 Reviews code changes for bugs, security, edge cases. Runs automatically after edits.
+- **CodeReviewMulti** \u2014 Multiple reviewers analyze from different perspectives.
+- **ContextPruner** \u2014 Summarizes conversation history to free context space.
+
+**How to orchestrate (use your judgment):**
+1. Spawn context-gathering sub-agents first (FilePickerMax, Read) to understand the codebase before making edits.
+2. For complex problems, call Thinker to reason and plan before implementing.
+3. Call Commander for shell operations (builds, tests, installs, git) instead of Bash directly.
+4. After implementing changes, validate by running tests/builds/lints via Commander.
+5. A code reviewer runs automatically after edits (skipped in lite mode, multi-perspective in max mode).
+6. If a sub-agent fails, fall back to doing the work yourself with basic tools (Read, Edit, Bash, Grep, etc.).
+7. Bundle independent sub-agent calls in the same turn for parallel execution.
+
+**When to skip sub-agents and act directly:**
+- Reading a single known file path (just use Read)
+- A single targeted grep for a known pattern (just use Grep)
+- A quick one-line bash command (just use Bash)
+- Answering a question from memory/context (just respond)
+- Trivially simple edits where the file is already read and understood
 
-# Tool Usage
-- Use Grep/Glob/ListDir to explore and locate code.
+# Tool Usage (basic tools)
 - Use Read to understand files before modifying them.
 - 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 running commands (tests, builds, linters, git).
-- Bundle independent tool calls in the same turn for parallel execution.
+- 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.
 - Don't ask for permission to use tools \u2014 just use them.
-- When using FilePickerMax, ALWAYS specify the exact type of files you need (e.g. "show me the main entry point and config files", "files handling authentication"). NEVER send generic prompts like "give me an overview of the codebase".
-
-# Sub-Agents \u2014 ALWAYS DELEGATE FIRST
-You have specialized sub-agents. **Your default behavior is to delegate work to sub-agents FIRST.** Only do the work yourself if the sub-agent fails or for trivially simple operations (e.g. reading a single file, a quick grep).
-
-**Delegation rules (follow strictly):**
-1. **Planning & reasoning** \u2192 Call **Thinker** BEFORE implementing anything non-trivial. Let it analyze the problem and produce a plan, then follow that plan.
-2. **Finding files** \u2192 Call **FilePickerMax** to locate relevant files instead of manually running Glob/Grep/ListDir chains. Always specify the exact type of files needed.
-3. **Shell commands** \u2192 Call **Commander** to plan and execute terminal commands (builds, tests, installs, git ops) instead of calling Bash directly.
-4. **Critical decisions** \u2192 Call **ThinkerBestOfN** (MAX mode) to get multiple perspectives before deciding.
-5. **Important code changes** \u2192 Call **EditorMultiPrompt** (MAX mode) to try multiple implementation strategies.
-6. **Code review** \u2192 **CodeReviewMulti** (MAX mode) runs automatically; don't duplicate its work.
-7. **Context management** \u2192 **ContextPruner** summarizes long conversations automatically.
-
-**Fallback rule:** If a sub-agent call fails or returns an error, THEN do the work yourself using basic tools (Read, Edit, Bash, Grep, etc.). Never give up \u2014 always fall back to manual if delegation fails.
-
-**Do NOT skip delegation** just because you think you can do it faster. Sub-agents provide better results through specialization. The only exceptions are:
-- Reading a single known file path (just use Read)
-- A single targeted grep for a known pattern (just use Grep)
-- Answering a question from memory/context (just respond)
 
-# Modes
-Current mode: ${getMode()}
-- **default**: Standard single-agent pass with auto code review.
-- **max**: Best-of-N thinking, multi-strategy editing, multi-perspective review, auto context pruning. Higher quality, more API calls.
-- **lite**: Fast mode \u2014 skips validation and review steps.
-
-# Note
-A separate code reviewer runs automatically after edits (skipped in lite mode, multi-perspective in max mode).
+# Validation
+- After code changes, run the most relevant checks: tests, lint, typecheck, or build. Prefer Commander or scripts from package.json.
+- If checks fail, fix and re-run. If blocked, clearly state what's failing and why.
 
 # Environment
 Working directory: ${PROJECT_ROOT}
@@ -32214,7 +32211,7 @@ var require_tools = __commonJS((exports, module2) => {
       type: "function",
       function: {
         name: "ThinkerBestOfN",
-        description: "Spawn N parallel thinking agents that each independently reason about the same problem, then a selector picks the best response. Use for critical decisions that benefit from multiple perspectives. Only available in MAX mode.",
+        description: "Spawn N parallel thinking agents that each independently reason about the same problem, then a selector picks the best response. Use for critical decisions that benefit from multiple perspectives.",
         parameters: {
           type: "object",
           properties: {
@@ -32229,7 +32226,7 @@ var require_tools = __commonJS((exports, module2) => {
       type: "function",
       function: {
         name: "EditorMultiPrompt",
-        description: "Spawn multiple editor agents in parallel, each with a different implementation strategy, then a selector picks the best result and applies it. Only available in MAX mode. Use for important code changes where you want to explore multiple approaches.",
+        description: "Spawn multiple editor agents in parallel, each with a different implementation strategy, then a selector picks the best result and applies it. Use for important code changes where you want to explore multiple approaches.",
         parameters: {
           type: "object",
           properties: {
@@ -32260,7 +32257,7 @@ var require_tools = __commonJS((exports, module2) => {
       type: "function",
       function: {
         name: "CodeReviewMulti",
-        description: "Spawn multiple code reviewers in parallel, each analyzing from a different perspective (correctness, security, performance, etc.). Only available in MAX mode.",
+        description: "Spawn multiple code reviewers in parallel, each analyzing from a different perspective (correctness, security, performance, etc.).",
         parameters: {
           type: "object",
           properties: {
@@ -32330,8 +32327,7 @@ var require_toolExecutors = __commonJS((exports, module2) => {
     session,
     truncateOutput,
     resolvePath,
-    sleep,
-    getMode
+    sleep
   } = require_config();
   async function streamCompletion(params, onStream) {
     for (let attempt = 0;attempt <= 2; attempt++) {
@@ -32873,10 +32869,6 @@ ${"\u2500".repeat(40)}
           }
         }
         case "ThinkerBestOfN": {
-          const mode = getMode();
-          if (mode !== "max") {
-            return "ThinkerBestOfN is only available in MAX mode. Use /mode max to enable it, or use Thinker instead.";
-          }
           const n = Math.min(5, Math.max(2, args.n || 3));
           const historyCtx = session.conversationHistory.slice(-10).map((m2) => `[${m2.role}]: ${(m2.content || "").slice(0, 500)}`).join(`
 `);
@@ -32958,10 +32950,6 @@ ${thoughts[0].result}`;
           }
         }
         case "EditorMultiPrompt": {
-          const mode = getMode();
-          if (mode !== "max") {
-            return "EditorMultiPrompt is only available in MAX mode. Use /mode max to enable it.";
-          }
           const strategies = args.strategies || ["straightforward implementation", "alternative approach"];
           const filesCtx = (args.files || []).map((f) => `--- ${f.path} ---
 ${f.content}`).join(`
@@ -33075,10 +33063,6 @@ ${implementations[0].result}`;
           }
         }
         case "CodeReviewMulti": {
-          const mode = getMode();
-          if (mode !== "max") {
-            return "CodeReviewMulti is only available in MAX mode. Use /mode max to enable it, or use CodeReview for a single review.";
-          }
           const perspectives = args.perspectives || [
             "correctness, logic errors, and edge cases",
             "security vulnerabilities and data safety",
@@ -33395,8 +33379,7 @@ var require_agent = __commonJS((exports, module2) => {
     MAX_TOOL_ITERATIONS,
     nvidiaClient,
     session,
-    sleep,
-    getMode
+    sleep
   } = require_config();
   var { buildSystemPrompt } = require_prompt();
   var { toolDefs } = require_tools();
@@ -33413,208 +33396,12 @@ var require_agent = __commonJS((exports, module2) => {
   function getIsProcessing() {
     return isProcessing;
   }
-  var EXPLORATION_KEYWORDS = [
-    "explore",
-    "find files",
-    "where is",
-    "search for",
-    "locate",
-    "what files",
-    "which files",
-    "show me all",
-    "list all",
-    "find code",
-    "search code",
-    "find function",
-    "find class",
-    "find module",
-    "find component",
-    "find endpoint",
-    "find route",
-    "find api",
-    "find service",
-    "find model",
-    "find controller",
-    "where can i find",
-    "how do i find",
-    "look for",
-    "codebase structure",
-    "project structure",
-    "directory structure"
-  ];
-  function isExplorationTask(text) {
-    const lower = text.toLowerCase();
-    return EXPLORATION_KEYWORDS.some((keyword) => lower.includes(keyword));
-  }
-  var CODING_TASK_KEYWORDS = [
-    "refactor",
-    "redesign",
-    "architect",
-    "migrate",
-    "overhaul",
-    "implement",
-    "build",
-    "create",
-    "design",
-    "add feature",
-    "new feature",
-    "integrate",
-    "convert",
-    "multiple files",
-    "across files",
-    "full stack",
-    "database",
-    "api",
-    "endpoint",
-    "authentication",
-    "complex",
-    "tricky",
-    "challenging",
-    "difficult",
-    "fix",
-    "bug",
-    "error",
-    "broken",
-    "crash",
-    "issue",
-    "problem",
-    "update",
-    "change",
-    "modify",
-    "edit",
-    "write",
-    "rewrite",
-    "add",
-    "remove",
-    "delete",
-    "move",
-    "rename",
-    "replace",
-    "optimize",
-    "improve",
-    "enhance",
-    "extend",
-    "upgrade",
-    "set up",
-    "setup",
-    "configure",
-    "install",
-    "connect",
-    "debug",
-    "troubleshoot",
-    "investigate",
-    "diagnose",
-    "test",
-    "spec",
-    "coverage"
-  ];
-  function isCodingTask(text) {
-    const lower = text.toLowerCase();
-    const wordCount = text.split(/\s+/).length;
-    const keywordMatch = CODING_TASK_KEYWORDS.some((kw) => lower.includes(kw));
-    return keywordMatch || wordCount > 20;
-  }
-  var COMMAND_TASK_KEYWORDS = [
-    "run",
-    "execute",
-    "start",
-    "stop",
-    "restart",
-    "deploy",
-    "build",
-    "compile",
-    "bundle",
-    "test",
-    "lint",
-    "format",
-    "install",
-    "uninstall",
-    "upgrade",
-    "npm",
-    "bun",
-    "yarn",
-    "git commit",
-    "git push",
-    "git pull",
-    "git merge",
-    "git rebase",
-    "docker",
-    "container",
-    "serve",
-    "dev server",
-    "check status",
-    "disk space",
-    "process",
-    "kill"
-  ];
-  function isCommandTask(text) {
-    const lower = text.toLowerCase();
-    return COMMAND_TASK_KEYWORDS.some((kw) => lower.includes(kw)) && !isCodingTask(text);
-  }
   async function handleUserInput(userInput) {
     isProcessing = true;
     store.setState({ isProcessing: true });
     session.turnCount++;
     store.addMessage({ role: "user", content: userInput });
     session.conversationHistory.push({ role: "user", content: userInput });
-    if (isExplorationTask(userInput)) {
-      const exploreId = store.addMessage({ role: "system", content: "Exploring codebase...", label: "\uD83D\uDD0D Exploring" });
-      try {
-        const pickerResult = await executeTool("FilePickerMax", { prompt: userInput }, (partial) => {
-          store.updateMessage(exploreId, { content: partial, label: "\uD83D\uDD0D Exploring" });
-        });
-        store.updateMessage(exploreId, { content: pickerResult, label: "\uD83D\uDD0D Codebase Exploration Results" });
-        session.conversationHistory.push({
-          role: "assistant",
-          content: `I've explored the codebase and found the following relevant files:
-
-${pickerResult}`
-        });
-      } catch (err) {
-        store.updateMessage(exploreId, { content: `Exploration failed: ${err.message}` });
-      }
-    }
-    const mode = getMode();
-    if (isCommandTask(userInput)) {
-      const cmdId = store.addMessage({ role: "system", content: "Delegating to Commander...", label: "\u26A1 Commander" });
-      try {
-        const cmdResult = await executeTool("Commander", { prompt: userInput }, (partial) => {
-          store.updateMessage(cmdId, { content: partial, label: "\u26A1 Commander" });
-        });
-        store.updateMessage(cmdId, { content: cmdResult, label: "\u26A1 Commander" });
-        session.conversationHistory.push({
-          role: "assistant",
-          content: `[Commander result]
-${cmdResult}`
-        });
-      } catch (err) {
-        store.updateMessage(cmdId, { content: `Commander failed (falling back to main agent): ${err.message}` });
-      }
-    }
-    if (isCodingTask(userInput) && !isCommandTask(userInput)) {
-      const thinkLabel = mode === "max" ? "\uD83E\uDDE0 Deep Thinker (MAX)" : "\uD83E\uDDE0 Thinker";
-      const thinkId = store.addMessage({ role: "system", content: "Planning approach...", label: thinkLabel });
-      try {
-        const toolName = mode === "max" ? "ThinkerBestOfN" : "Thinker";
-        const toolArgs = mode === "max" ? { prompt: userInput, n: 3 } : { prompt: userInput };
-        const thinkerResult = await executeTool(toolName, toolArgs, (partial) => {
-          store.updateMessage(thinkId, { content: partial, label: thinkLabel });
-        });
-        store.updateMessage(thinkId, { content: thinkerResult, label: thinkLabel });
-        session.conversationHistory.push({
-          role: "assistant",
-          content: `[Thinker analysis \u2014 follow this plan]
-${thinkerResult}`
-        });
-      } catch (err) {
-        store.updateMessage(thinkId, { content: `Thinker failed (falling back to main agent): ${err.message}` });
-      }
-    }
-    if (session.conversationHistory.length > 20) {
-      try {
-        await executeTool("ContextPruner", {}, null);
-      } catch {}
-    }
     const startTime2 = Date.now();
     let turnTokens = 0;
     let turnToolCalls = 0;
@@ -33934,40 +33721,21 @@ ${thinkerResult}`
         const reviewPrompt = `User request: ${userInput}
 
 ${turnTokens > 0 ? `Processed with ${turnTokens} tokens and ${turnToolCalls} tool calls.` : ""}`;
-        if (mode === "max") {
-          const reviewId = store.addMessage({ role: "system", content: "Multi-perspective code review...", label: "\uD83D\uDCCB Code Review (MAX)" });
-          try {
-            const reviewResult = await executeTool("CodeReviewMulti", { prompt: reviewPrompt }, (partial) => {
-              store.updateMessage(reviewId, { content: partial, label: "\uD83D\uDCCB Code Review (MAX)" });
-            });
-            store.updateMessage(reviewId, { content: reviewResult, label: "\uD83D\uDCCB Code Review (MAX)" });
-            session.conversationHistory.push({
-              role: "assistant",
-              content: `
-
---- Multi-Perspective Code Review ---
-${reviewResult}`
-            });
-          } catch (err) {
-            store.updateMessage(reviewId, { content: `Multi-review failed: ${err.message}` });
-          }
-        } else if (mode !== "lite") {
-          const reviewId = store.addMessage({ role: "system", content: "Reviewing code changes...", label: "\uD83D\uDCCB Code Review" });
-          try {
-            const reviewResult = await executeTool("CodeReview", { prompt: reviewPrompt }, (partial) => {
-              store.updateMessage(reviewId, { content: partial, label: "\uD83D\uDCCB Code Review" });
-            });
-            store.updateMessage(reviewId, { content: reviewResult, label: "\uD83D\uDCCB Code Review" });
-            session.conversationHistory.push({
-              role: "assistant",
-              content: `
+        const reviewId = store.addMessage({ role: "system", content: "Multi-perspective code review...", label: "\uD83D\uDCCB Code Review" });
+        try {
+          const reviewResult = await executeTool("CodeReviewMulti", { prompt: reviewPrompt }, (partial) => {
+            store.updateMessage(reviewId, { content: partial, label: "\uD83D\uDCCB Code Review" });
+          });
+          store.updateMessage(reviewId, { content: reviewResult, label: "\uD83D\uDCCB Code Review" });
+          session.conversationHistory.push({
+            role: "assistant",
+            content: `
 
 --- Code Review ---
 ${reviewResult}`
-            });
-          } catch (err) {
-            store.updateMessage(reviewId, { content: `Code review failed: ${err.message}` });
-          }
+          });
+        } catch (err) {
+          store.updateMessage(reviewId, { content: `Code review failed: ${err.message}` });
         }
       }
     } catch (err) {
@@ -33998,7 +33766,7 @@ var require_commands = __commonJS((exports, module2) => {
   var fs2 = __require("fs");
   var path2 = __require("path");
   var { execSync } = __require("child_process");
-  var { PROJECT_ROOT, session, resolvePath, getMode, setMode } = require_config();
+  var { PROJECT_ROOT, session, resolvePath } = require_config();
   var { executeTool } = require_toolExecutors();
   var store = require_store();
   async function handleSlashCommand(input) {
@@ -34072,30 +33840,6 @@ var require_commands = __commonJS((exports, module2) => {
         }
         break;
       }
-      case "/mode": {
-        if (!arg) {
-          const current = getMode();
-          const modes = ["default", "max", "lite"];
-          const modeDescriptions = {
-            default: "Single agent pass with auto code review",
-            max: "Multi-strategy editing, best-of-N thinking, multi-perspective review, auto context pruning",
-            lite: "Fast mode \u2014 skips validation and review steps"
-          };
-          const lines = modes.map((m2) => `${m2 === current ? "\u2192 " : "  "}${m2.padEnd(10)} ${modeDescriptions[m2]}`);
-          store.addMessage({ role: "system", content: `Current mode: ${current}
-
-${lines.join(`
-`)}`, label: "Mode" });
-        } else {
-          const success = setMode(arg.trim());
-          if (success) {
-            store.addMessage({ role: "system", content: `Mode set to: ${arg.trim()}`, label: "Mode" });
-          } else {
-            store.addMessage({ role: "system", content: `Invalid mode: ${arg}. Use default, max, or lite.` });
-          }
-        }
-        break;
-      }
       case "/compact": {
         const pruneId = store.addMessage({ role: "system", content: "Compacting conversation...", label: "Context Pruner" });
         try {
@@ -34181,7 +33925,7 @@ var require_jsx_runtime = __commonJS((exports, module2) => {
   } else {}
 });
 
-// node_modules/@opentui/core/index-qr7b6cvh.js
+// node_modules/@opentui/core/index-a215gqtt.js
 import { Buffer as Buffer2 } from "buffer";
 import { EventEmitter } from "events";
 import { EventEmitter as EventEmitter2 } from "events";
@@ -34222,7 +33966,7 @@ var highlights_default5 = "./highlights-hk7bwhj4.scm";
 // node_modules/@opentui/core/assets/zig/tree-sitter-zig.wasm
 var tree_sitter_zig_default = "./tree-sitter-zig-e78zbjpm.wasm";
 
-// node_modules/@opentui/core/index-qr7b6cvh.js
+// node_modules/@opentui/core/index-a215gqtt.js
 import { resolve as resolve2, isAbsolute, parse } from "path";
 import { existsSync } from "fs";
 import { basename, join } from "path";
@@ -34246,17 +33990,13 @@ import { Writable } from "stream";
 import { EventEmitter as EventEmitter7 } from "events";
 import { EventEmitter as EventEmitter9 } from "events";
 var __defProp2 = Object.defineProperty;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
 var __export2 = (target, all) => {
   for (var name in all)
     __defProp2(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: __exportSetter.bind(all, name)
+      set: (newValue) => all[name] = () => newValue
     });
 };
 var exports_src = {};
@@ -53665,6 +53405,604 @@ class LineNumberRenderable extends Renderable {
     }
   }
 }
+
+class Diff {
+  diff(oldStr, newStr, options = {}) {
+    let callback;
+    if (typeof options === "function") {
+      callback = options;
+      options = {};
+    } else if ("callback" in options) {
+      callback = options.callback;
+    }
+    const oldString = this.castInput(oldStr, options);
+    const newString = this.castInput(newStr, options);
+    const oldTokens = this.removeEmpty(this.tokenize(oldString, options));
+    const newTokens = this.removeEmpty(this.tokenize(newString, options));
+    return this.diffWithOptionsObj(oldTokens, newTokens, options, callback);
+  }
+  diffWithOptionsObj(oldTokens, newTokens, options, callback) {
+    var _a;
+    const done = (value) => {
+      value = this.postProcess(value, options);
+      if (callback) {
+        setTimeout(function() {
+          callback(value);
+        }, 0);
+        return;
+      } else {
+        return value;
+      }
+    };
+    const newLen = newTokens.length, oldLen = oldTokens.length;
+    let editLength = 1;
+    let maxEditLength = newLen + oldLen;
+    if (options.maxEditLength != null) {
+      maxEditLength = Math.min(maxEditLength, options.maxEditLength);
+    }
+    const maxExecutionTime = (_a = options.timeout) !== null && _a !== undefined ? _a : Infinity;
+    const abortAfterTimestamp = Date.now() + maxExecutionTime;
+    const bestPath = [{ oldPos: -1, lastComponent: undefined }];
+    let newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options);
+    if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+      return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));
+    }
+    let minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
+    const execEditLength = () => {
+      for (let diagonalPath = Math.max(minDiagonalToConsider, -editLength);diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
+        let basePath;
+        const removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
+        if (removePath) {
+          bestPath[diagonalPath - 1] = undefined;
+        }
+        let canAdd = false;
+        if (addPath) {
+          const addPathNewPos = addPath.oldPos - diagonalPath;
+          canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
+        }
+        const canRemove = removePath && removePath.oldPos + 1 < oldLen;
+        if (!canAdd && !canRemove) {
+          bestPath[diagonalPath] = undefined;
+          continue;
+        }
+        if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos) {
+          basePath = this.addToPath(addPath, true, false, 0, options);
+        } else {
+          basePath = this.addToPath(removePath, false, true, 1, options);
+        }
+        newPos = this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options);
+        if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+          return done(this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || true;
+        } else {
+          bestPath[diagonalPath] = basePath;
+          if (basePath.oldPos + 1 >= oldLen) {
+            maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
+          }
+          if (newPos + 1 >= newLen) {
+            minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
+          }
+        }
+      }
+      editLength++;
+    };
+    if (callback) {
+      (function exec() {
+        setTimeout(function() {
+          if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
+            return callback(undefined);
+          }
+          if (!execEditLength()) {
+            exec();
+          }
+        }, 0);
+      })();
+    } else {
+      while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
+        const ret = execEditLength();
+        if (ret) {
+          return ret;
+        }
+      }
+    }
+  }
+  addToPath(path2, added, removed, oldPosInc, options) {
+    const last = path2.lastComponent;
+    if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
+      return {
+        oldPos: path2.oldPos + oldPosInc,
+        lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
+      };
+    } else {
+      return {
+        oldPos: path2.oldPos + oldPosInc,
+        lastComponent: { count: 1, added, removed, previousComponent: last }
+      };
+    }
+  }
+  extractCommon(basePath, newTokens, oldTokens, diagonalPath, options) {
+    const newLen = newTokens.length, oldLen = oldTokens.length;
+    let oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
+    while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldTokens[oldPos + 1], newTokens[newPos + 1], options)) {
+      newPos++;
+      oldPos++;
+      commonCount++;
+      if (options.oneChangePerToken) {
+        basePath.lastComponent = { count: 1, previousComponent: basePath.lastComponent, added: false, removed: false };
+      }
+    }
+    if (commonCount && !options.oneChangePerToken) {
+      basePath.lastComponent = { count: commonCount, previousComponent: basePath.lastComponent, added: false, removed: false };
+    }
+    basePath.oldPos = oldPos;
+    return newPos;
+  }
+  equals(left, right, options) {
+    if (options.comparator) {
+      return options.comparator(left, right);
+    } else {
+      return left === right || !!options.ignoreCase && left.toLowerCase() === right.toLowerCase();
+    }
+  }
+  removeEmpty(array) {
+    const ret = [];
+    for (let i = 0;i < array.length; i++) {
+      if (array[i]) {
+        ret.push(array[i]);
+      }
+    }
+    return ret;
+  }
+  castInput(value, options) {
+    return value;
+  }
+  tokenize(value, options) {
+    return Array.from(value);
+  }
+  join(chars) {
+    return chars.join("");
+  }
+  postProcess(changeObjects, options) {
+    return changeObjects;
+  }
+  get useLongestToken() {
+    return false;
+  }
+  buildValues(lastComponent, newTokens, oldTokens) {
+    const components = [];
+    let nextComponent;
+    while (lastComponent) {
+      components.push(lastComponent);
+      nextComponent = lastComponent.previousComponent;
+      delete lastComponent.previousComponent;
+      lastComponent = nextComponent;
+    }
+    components.reverse();
+    const componentLen = components.length;
+    let componentPos = 0, newPos = 0, oldPos = 0;
+    for (;componentPos < componentLen; componentPos++) {
+      const component = components[componentPos];
+      if (!component.removed) {
+        if (!component.added && this.useLongestToken) {
+          let value = newTokens.slice(newPos, newPos + component.count);
+          value = value.map(function(value2, i) {
+            const oldValue = oldTokens[oldPos + i];
+            return oldValue.length > value2.length ? oldValue : value2;
+          });
+          component.value = this.join(value);
+        } else {
+          component.value = this.join(newTokens.slice(newPos, newPos + component.count));
+        }
+        newPos += component.count;
+        if (!component.added) {
+          oldPos += component.count;
+        }
+      } else {
+        component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));
+        oldPos += component.count;
+      }
+    }
+    return components;
+  }
+}
+
+class CharacterDiff extends Diff {
+}
+var characterDiff = new CharacterDiff;
+function longestCommonPrefix(str1, str2) {
+  let i;
+  for (i = 0;i < str1.length && i < str2.length; i++) {
+    if (str1[i] != str2[i]) {
+      return str1.slice(0, i);
+    }
+  }
+  return str1.slice(0, i);
+}
+function longestCommonSuffix(str1, str2) {
+  let i;
+  if (!str1 || !str2 || str1[str1.length - 1] != str2[str2.length - 1]) {
+    return "";
+  }
+  for (i = 0;i < str1.length && i < str2.length; i++) {
+    if (str1[str1.length - (i + 1)] != str2[str2.length - (i + 1)]) {
+      return str1.slice(-i);
+    }
+  }
+  return str1.slice(-i);
+}
+function replacePrefix(string, oldPrefix, newPrefix) {
+  if (string.slice(0, oldPrefix.length) != oldPrefix) {
+    throw Error(`string ${JSON.stringify(string)} doesn't start with prefix ${JSON.stringify(oldPrefix)}; this is a bug`);
+  }
+  return newPrefix + string.slice(oldPrefix.length);
+}
+function replaceSuffix(string, oldSuffix, newSuffix) {
+  if (!oldSuffix) {
+    return string + newSuffix;
+  }
+  if (string.slice(-oldSuffix.length) != oldSuffix) {
+    throw Error(`string ${JSON.stringify(string)} doesn't end with suffix ${JSON.stringify(oldSuffix)}; this is a bug`);
+  }
+  return string.slice(0, -oldSuffix.length) + newSuffix;
+}
+function removePrefix(string, oldPrefix) {
+  return replacePrefix(string, oldPrefix, "");
+}
+function removeSuffix(string, oldSuffix) {
+  return replaceSuffix(string, oldSuffix, "");
+}
+function maximumOverlap(string1, string2) {
+  return string2.slice(0, overlapCount(string1, string2));
+}
+function overlapCount(a, b) {
+  let startA = 0;
+  if (a.length > b.length) {
+    startA = a.length - b.length;
+  }
+  let endB = b.length;
+  if (a.length < b.length) {
+    endB = a.length;
+  }
+  const map = Array(endB);
+  let k = 0;
+  map[0] = 0;
+  for (let j = 1;j < endB; j++) {
+    if (b[j] == b[k]) {
+      map[j] = map[k];
+    } else {
+      map[j] = k;
+    }
+    while (k > 0 && b[j] != b[k]) {
+      k = map[k];
+    }
+    if (b[j] == b[k]) {
+      k++;
+    }
+  }
+  k = 0;
+  for (let i = startA;i < a.length; i++) {
+    while (k > 0 && a[i] != b[k]) {
+      k = map[k];
+    }
+    if (a[i] == b[k]) {
+      k++;
+    }
+  }
+  return k;
+}
+function trailingWs(string) {
+  let i;
+  for (i = string.length - 1;i >= 0; i--) {
+    if (!string[i].match(/\s/)) {
+      break;
+    }
+  }
+  return string.substring(i + 1);
+}
+function leadingWs(string) {
+  const match = string.match(/^\s*/);
+  return match ? match[0] : "";
+}
+var extendedWordChars = "a-zA-Z0-9_\\u{C0}-\\u{FF}\\u{D8}-\\u{F6}\\u{F8}-\\u{2C6}\\u{2C8}-\\u{2D7}\\u{2DE}-\\u{2FF}\\u{1E00}-\\u{1EFF}";
+var tokenizeIncludingWhitespace = new RegExp(`[${extendedWordChars}]+|\\s+|[^${extendedWordChars}]`, "ug");
+
+class WordDiff extends Diff {
+  equals(left, right, options) {
+    if (options.ignoreCase) {
+      left = left.toLowerCase();
+      right = right.toLowerCase();
+    }
+    return left.trim() === right.trim();
+  }
+  tokenize(value, options = {}) {
+    let parts;
+    if (options.intlSegmenter) {
+      const segmenter = options.intlSegmenter;
+      if (segmenter.resolvedOptions().granularity != "word") {
+        throw new Error('The segmenter passed must have a granularity of "word"');
+      }
+      parts = Array.from(segmenter.segment(value), (segment) => segment.segment);
+    } else {
+      parts = value.match(tokenizeIncludingWhitespace) || [];
+    }
+    const tokens = [];
+    let prevPart = null;
+    parts.forEach((part) => {
+      if (/\s/.test(part)) {
+        if (prevPart == null) {
+          tokens.push(part);
+        } else {
+          tokens.push(tokens.pop() + part);
+        }
+      } else if (prevPart != null && /\s/.test(prevPart)) {
+        if (tokens[tokens.length - 1] == prevPart) {
+          tokens.push(tokens.pop() + part);
+        } else {
+          tokens.push(prevPart + part);
+        }
+      } else {
+        tokens.push(part);
+      }
+      prevPart = part;
+    });
+    return tokens;
+  }
+  join(tokens) {
+    return tokens.map((token, i) => {
+      if (i == 0) {
+        return token;
+      } else {
+        return token.replace(/^\s+/, "");
+      }
+    }).join("");
+  }
+  postProcess(changes, options) {
+    if (!changes || options.oneChangePerToken) {
+      return changes;
+    }
+    let lastKeep = null;
+    let insertion = null;
+    let deletion = null;
+    changes.forEach((change) => {
+      if (change.added) {
+        insertion = change;
+      } else if (change.removed) {
+        deletion = change;
+      } else {
+        if (insertion || deletion) {
+          dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, change);
+        }
+        lastKeep = change;
+        insertion = null;
+        deletion = null;
+      }
+    });
+    if (insertion || deletion) {
+      dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, null);
+    }
+    return changes;
+  }
+}
+var wordDiff = new WordDiff;
+function dedupeWhitespaceInChangeObjects(startKeep, deletion, insertion, endKeep) {
+  if (deletion && insertion) {
+    const oldWsPrefix = leadingWs(deletion.value);
+    const oldWsSuffix = trailingWs(deletion.value);
+    const newWsPrefix = leadingWs(insertion.value);
+    const newWsSuffix = trailingWs(insertion.value);
+    if (startKeep) {
+      const commonWsPrefix = longestCommonPrefix(oldWsPrefix, newWsPrefix);
+      startKeep.value = replaceSuffix(startKeep.value, newWsPrefix, commonWsPrefix);
+      deletion.value = removePrefix(deletion.value, commonWsPrefix);
+      insertion.value = removePrefix(insertion.value, commonWsPrefix);
+    }
+    if (endKeep) {
+      const commonWsSuffix = longestCommonSuffix(oldWsSuffix, newWsSuffix);
+      endKeep.value = replacePrefix(endKeep.value, newWsSuffix, commonWsSuffix);
+      deletion.value = removeSuffix(deletion.value, commonWsSuffix);
+      insertion.value = removeSuffix(insertion.value, commonWsSuffix);
+    }
+  } else if (insertion) {
+    if (startKeep) {
+      const ws = leadingWs(insertion.value);
+      insertion.value = insertion.value.substring(ws.length);
+    }
+    if (endKeep) {
+      const ws = leadingWs(endKeep.value);
+      endKeep.value = endKeep.value.substring(ws.length);
+    }
+  } else if (startKeep && endKeep) {
+    const newWsFull = leadingWs(endKeep.value), delWsStart = leadingWs(deletion.value), delWsEnd = trailingWs(deletion.value);
+    const newWsStart = longestCommonPrefix(newWsFull, delWsStart);
+    deletion.value = removePrefix(deletion.value, newWsStart);
+    const newWsEnd = longestCommonSuffix(removePrefix(newWsFull, newWsStart), delWsEnd);
+    deletion.value = removeSuffix(deletion.value, newWsEnd);
+    endKeep.value = replacePrefix(endKeep.value, newWsFull, newWsEnd);
+    startKeep.value = replaceSuffix(startKeep.value, newWsFull, newWsFull.slice(0, newWsFull.length - newWsEnd.length));
+  } else if (endKeep) {
+    const endKeepWsPrefix = leadingWs(endKeep.value);
+    const deletionWsSuffix = trailingWs(deletion.value);
+    const overlap = maximumOverlap(deletionWsSuffix, endKeepWsPrefix);
+    deletion.value = removeSuffix(deletion.value, overlap);
+  } else if (startKeep) {
+    const startKeepWsSuffix = trailingWs(startKeep.value);
+    const deletionWsPrefix = leadingWs(deletion.value);
+    const overlap = maximumOverlap(startKeepWsSuffix, deletionWsPrefix);
+    deletion.value = removePrefix(deletion.value, overlap);
+  }
+}
+
+class WordsWithSpaceDiff extends Diff {
+  tokenize(value) {
+    const regex = new RegExp(`(\\r?\\n)|[${extendedWordChars}]+|[^\\S\\n\\r]+|[^${extendedWordChars}]`, "ug");
+    return value.match(regex) || [];
+  }
+}
+var wordsWithSpaceDiff = new WordsWithSpaceDiff;
+
+class LineDiff extends Diff {
+  constructor() {
+    super(...arguments);
+    this.tokenize = tokenize;
+  }
+  equals(left, right, options) {
+    if (options.ignoreWhitespace) {
+      if (!options.newlineIsToken || !left.includes(`
+`)) {
+        left = left.trim();
+      }
+      if (!options.newlineIsToken || !right.includes(`
+`)) {
+        right = right.trim();
+      }
+    } else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {
+      if (left.endsWith(`
+`)) {
+        left = left.slice(0, -1);
+      }
+      if (right.endsWith(`
+`)) {
+        right = right.slice(0, -1);
+      }
+    }
+    return super.equals(left, right, options);
+  }
+}
+var lineDiff = new LineDiff;
+function tokenize(value, options) {
+  if (options.stripTrailingCr) {
+    value = value.replace(/\r\n/g, `
+`);
+  }
+  const retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
+  if (!linesAndNewlines[linesAndNewlines.length - 1]) {
+    linesAndNewlines.pop();
+  }
+  for (let i = 0;i < linesAndNewlines.length; i++) {
+    const line = linesAndNewlines[i];
+    if (i % 2 && !options.newlineIsToken) {
+      retLines[retLines.length - 1] += line;
+    } else {
+      retLines.push(line);
+    }
+  }
+  return retLines;
+}
+function isSentenceEndPunct(char) {
+  return char == "." || char == "!" || char == "?";
+}
+
+class SentenceDiff extends Diff {
+  tokenize(value) {
+    var _a;
+    const result = [];
+    let tokenStartI = 0;
+    for (let i = 0;i < value.length; i++) {
+      if (i == value.length - 1) {
+        result.push(value.slice(tokenStartI));
+        break;
+      }
+      if (isSentenceEndPunct(value[i]) && value[i + 1].match(/\s/)) {
+        result.push(value.slice(tokenStartI, i + 1));
+        i = tokenStartI = i + 1;
+        while ((_a = value[i + 1]) === null || _a === undefined ? undefined : _a.match(/\s/)) {
+          i++;
+        }
+        result.push(value.slice(tokenStartI, i + 1));
+        tokenStartI = i + 1;
+      }
+    }
+    return result;
+  }
+}
+var sentenceDiff = new SentenceDiff;
+
+class CssDiff extends Diff {
+  tokenize(value) {
+    return value.split(/([{}:;,]|\s+)/);
+  }
+}
+var cssDiff = new CssDiff;
+
+class JsonDiff extends Diff {
+  constructor() {
+    super(...arguments);
+    this.tokenize = tokenize;
+  }
+  get useLongestToken() {
+    return true;
+  }
+  castInput(value, options) {
+    const { undefinedReplacement, stringifyReplacer = (k, v) => typeof v === "undefined" ? undefinedReplacement : v } = options;
+    return typeof value === "string" ? value : JSON.stringify(canonicalize(value, null, null, stringifyReplacer), null, "  ");
+  }
+  equals(left, right, options) {
+    return super.equals(left.replace(/,([\r\n])/g, "$1"), right.replace(/,([\r\n])/g, "$1"), options);
+  }
+}
+var jsonDiff = new JsonDiff;
+function canonicalize(obj, stack, replacementStack, replacer, key) {
+  stack = stack || [];
+  replacementStack = replacementStack || [];
+  if (replacer) {
+    obj = replacer(key === undefined ? "" : key, obj);
+  }
+  let i;
+  for (i = 0;i < stack.length; i += 1) {
+    if (stack[i] === obj) {
+      return replacementStack[i];
+    }
+  }
+  let canonicalizedObj;
+  if (Object.prototype.toString.call(obj) === "[object Array]") {
+    stack.push(obj);
+    canonicalizedObj = new Array(obj.length);
+    replacementStack.push(canonicalizedObj);
+    for (i = 0;i < obj.length; i += 1) {
+      canonicalizedObj[i] = canonicalize(obj[i], stack, replacementStack, replacer, String(i));
+    }
+    stack.pop();
+    replacementStack.pop();
+    return canonicalizedObj;
+  }
+  if (obj && obj.toJSON) {
+    obj = obj.toJSON();
+  }
+  if (typeof obj === "object" && obj !== null) {
+    stack.push(obj);
+    canonicalizedObj = {};
+    replacementStack.push(canonicalizedObj);
+    const sortedKeys = [];
+    let key2;
+    for (key2 in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, key2)) {
+        sortedKeys.push(key2);
+      }
+    }
+    sortedKeys.sort();
+    for (i = 0;i < sortedKeys.length; i += 1) {
+      key2 = sortedKeys[i];
+      canonicalizedObj[key2] = canonicalize(obj[key2], stack, replacementStack, replacer, key2);
+    }
+    stack.pop();
+    replacementStack.pop();
+  } else {
+    canonicalizedObj = obj;
+  }
+  return canonicalizedObj;
+}
+
+class ArrayDiff extends Diff {
+  tokenize(value) {
+    return value.slice();
+  }
+  join(value) {
+    return value;
+  }
+  removeEmpty(value) {
+    return value;
+  }
+}
+var arrayDiff = new ArrayDiff;
 function parsePatch(uniDiff) {
   const diffstr = uniDiff.split(/\n/), list = [];
   let i = 0;
@@ -56077,7 +56415,6 @@ class TextTableRenderable extends Renderable {
   _content;
   _wrapMode;
   _columnWidthMode;
-  _columnFitter;
   _cellPadding;
   _showBorders;
   _border;
@@ -56105,9 +56442,8 @@ class TextTableRenderable extends Renderable {
   _cachedMeasureWidth = undefined;
   _defaultOptions = {
     content: [],
-    wrapMode: "word",
-    columnWidthMode: "full",
-    columnFitter: "proportional",
+    wrapMode: "none",
+    columnWidthMode: "content",
     cellPadding: 0,
     showBorders: true,
     border: true,
@@ -56124,11 +56460,10 @@ class TextTableRenderable extends Renderable {
     attributes: 0
   };
   constructor(ctx, options = {}) {
-    super(ctx, { ...options, flexShrink: options.flexShrink ?? 0, buffered: true });
+    super(ctx, { ...options, buffered: true });
     this._content = options.content ?? this._defaultOptions.content;
     this._wrapMode = options.wrapMode ?? this._defaultOptions.wrapMode;
     this._columnWidthMode = options.columnWidthMode ?? this._defaultOptions.columnWidthMode;
-    this._columnFitter = this.resolveColumnFitter(options.columnFitter);
     this._cellPadding = this.resolveCellPadding(options.cellPadding);
     this._showBorders = options.showBorders ?? this._defaultOptions.showBorders;
     this._border = options.border ?? this._defaultOptions.border;
@@ -56177,16 +56512,6 @@ class TextTableRenderable extends Renderable {
     this._columnWidthMode = value;
     this.invalidateLayoutAndRaster();
   }
-  get columnFitter() {
-    return this._columnFitter;
-  }
-  set columnFitter(value) {
-    const next = this.resolveColumnFitter(value);
-    if (this._columnFitter === next)
-      return;
-    this._columnFitter = next;
-    this.invalidateLayoutAndRaster();
-  }
   get cellPadding() {
     return this._cellPadding;
   }
@@ -56340,7 +56665,7 @@ class TextTableRenderable extends Renderable {
     super.destroySelf();
   }
   setupMeasureFunc() {
-    const measureFunc = (width, widthMode, _height, _heightMode) => {
+    const measureFunc = (width, widthMode, height, heightMode) => {
       const hasWidthConstraint = widthMode !== MeasureMode.Undefined && Number.isFinite(width);
       const rawWidthConstraint = hasWidthConstraint ? Math.max(1, Math.floor(width)) : undefined;
       const widthConstraint = this.resolveLayoutWidthConstraint(rawWidthConstraint);
@@ -56352,6 +56677,9 @@ class TextTableRenderable extends Renderable {
       if (widthMode === MeasureMode.AtMost && rawWidthConstraint !== undefined && this._positionType !== "absolute") {
         measuredWidth = Math.min(rawWidthConstraint, measuredWidth);
       }
+      if (heightMode === MeasureMode.AtMost && Number.isFinite(height) && this._positionType !== "absolute") {
+        measuredHeight = Math.min(Math.max(1, Math.floor(height)), measuredHeight);
+      }
       return {
         width: measuredWidth,
         height: measuredHeight
@@ -56523,9 +56851,6 @@ class TextTableRenderable extends Renderable {
       tableHeight: (rowOffsets[rowOffsets.length - 1] ?? 0) + 1
     };
   }
-  isFullWidthMode() {
-    return this._columnWidthMode === "full";
-  }
   computeColumnWidths(maxTableWidth, borderLayout) {
     const horizontalPadding = this.getHorizontalCellPadding();
     const intrinsicWidths = new Array(this._columnCount).fill(1 + horizontalPadding);
@@ -56548,7 +56873,7 @@ class TextTableRenderable extends Renderable {
       return intrinsicWidths;
     }
     if (currentWidth < maxContentWidth) {
-      if (this.isFullWidthMode()) {
+      if (this._columnWidthMode === "fill") {
         return this.expandColumnWidths(intrinsicWidths, maxContentWidth);
       }
       return intrinsicWidths;
@@ -56578,12 +56903,6 @@ class TextTableRenderable extends Renderable {
     return expanded;
   }
   fitColumnWidths(widths, targetContentWidth) {
-    if (this._columnFitter === "balanced") {
-      return this.fitColumnWidthsBalanced(widths, targetContentWidth);
-    }
-    return this.fitColumnWidthsProportional(widths, targetContentWidth);
-  }
-  fitColumnWidthsProportional(widths, targetContentWidth) {
     const minWidth = 1 + this.getHorizontalCellPadding();
     const hardMinWidths = new Array(widths.length).fill(minWidth);
     const baseWidths = widths.map((width) => Math.max(1, Math.floor(width)));
@@ -56634,80 +56953,6 @@ class TextTableRenderable extends Renderable {
     }
     return baseWidths.map((width, idx) => Math.max(floorWidths[idx], width - integerShrink[idx]));
   }
-  fitColumnWidthsBalanced(widths, targetContentWidth) {
-    const minWidth = 1 + this.getHorizontalCellPadding();
-    const hardMinWidths = new Array(widths.length).fill(minWidth);
-    const baseWidths = widths.map((width) => Math.max(1, Math.floor(width)));
-    const totalBaseWidth = baseWidths.reduce((sum, width) => sum + width, 0);
-    const columns = baseWidths.length;
-    if (columns === 0 || totalBaseWidth <= targetContentWidth) {
-      return baseWidths;
-    }
-    const evenShare = Math.max(minWidth, Math.floor(targetContentWidth / columns));
-    const preferredMinWidths = baseWidths.map((width) => Math.min(width, evenShare));
-    const preferredMinTotal = preferredMinWidths.reduce((sum, width) => sum + width, 0);
-    const floorWidths = preferredMinTotal <= targetContentWidth ? preferredMinWidths : hardMinWidths;
-    const floorTotal = floorWidths.reduce((sum, width) => sum + width, 0);
-    const clampedTarget = Math.max(floorTotal, targetContentWidth);
-    if (totalBaseWidth <= clampedTarget) {
-      return baseWidths;
-    }
-    const shrinkable = baseWidths.map((width, idx) => width - floorWidths[idx]);
-    const totalShrinkable = shrinkable.reduce((sum, value) => sum + value, 0);
-    if (totalShrinkable <= 0) {
-      return [...floorWidths];
-    }
-    const targetShrink = totalBaseWidth - clampedTarget;
-    const shrink = this.allocateShrinkByWeight(shrinkable, targetShrink, "sqrt");
-    return baseWidths.map((width, idx) => Math.max(floorWidths[idx], width - shrink[idx]));
-  }
-  allocateShrinkByWeight(shrinkable, targetShrink, mode) {
-    const shrink = new Array(shrinkable.length).fill(0);
-    if (targetShrink <= 0) {
-      return shrink;
-    }
-    const weights = shrinkable.map((value) => {
-      if (value <= 0) {
-        return 0;
-      }
-      return mode === "sqrt" ? Math.sqrt(value) : value;
-    });
-    const totalWeight = weights.reduce((sum, value) => sum + value, 0);
-    if (totalWeight <= 0) {
-      return shrink;
-    }
-    const fractions = new Array(shrinkable.length).fill(0);
-    let usedShrink = 0;
-    for (let idx = 0;idx < shrinkable.length; idx++) {
-      if (shrinkable[idx] <= 0 || weights[idx] <= 0)
-        continue;
-      const exact = weights[idx] / totalWeight * targetShrink;
-      const whole = Math.min(shrinkable[idx], Math.floor(exact));
-      shrink[idx] = whole;
-      fractions[idx] = exact - whole;
-      usedShrink += whole;
-    }
-    let remainingShrink = targetShrink - usedShrink;
-    while (remainingShrink > 0) {
-      let bestIdx = -1;
-      let bestFraction = -1;
-      for (let idx = 0;idx < shrinkable.length; idx++) {
-        if (shrinkable[idx] - shrink[idx] <= 0)
-          continue;
-        if (bestIdx === -1 || fractions[idx] > bestFraction || fractions[idx] === bestFraction && shrinkable[idx] > shrinkable[bestIdx]) {
-          bestIdx = idx;
-          bestFraction = fractions[idx];
-        }
-      }
-      if (bestIdx === -1) {
-        break;
-      }
-      shrink[bestIdx] += 1;
-      fractions[bestIdx] = 0;
-      remainingShrink -= 1;
-    }
-    return shrink;
-  }
   computeRowHeights(columnWidths) {
     const horizontalPadding = this.getHorizontalCellPadding();
     const verticalPadding = this.getVerticalCellPadding();
@@ -57031,7 +57276,7 @@ class TextTableRenderable extends Renderable {
     if (width === undefined || !Number.isFinite(width) || width <= 0) {
       return;
     }
-    if (this._wrapMode !== "none" || this.isFullWidthMode()) {
+    if (this._wrapMode !== "none" || this._columnWidthMode === "fill") {
       return Math.max(1, Math.floor(width));
     }
     return;
@@ -57042,12 +57287,6 @@ class TextTableRenderable extends Renderable {
   getVerticalCellPadding() {
     return this._cellPadding * 2;
   }
-  resolveColumnFitter(value) {
-    if (value === undefined) {
-      return this._defaultOptions.columnFitter;
-    }
-    return value === "balanced" ? "balanced" : "proportional";
-  }
   resolveCellPadding(value) {
     if (value === undefined || !Number.isFinite(value)) {
       return this._defaultOptions.cellPadding;
@@ -58823,9 +59062,8 @@ class MarkdownRenderable extends Renderable {
   resolveTableRenderableOptions() {
     const borders = this._tableOptions?.borders ?? true;
     return {
-      columnWidthMode: this._tableOptions?.widthMode ?? "full",
-      columnFitter: this._tableOptions?.columnFitter ?? "proportional",
-      wrapMode: this._tableOptions?.wrapMode ?? "word",
+      columnWidthMode: this._tableOptions?.widthMode ?? "content",
+      wrapMode: this._tableOptions?.wrapMode ?? "none",
       cellPadding: this._tableOptions?.cellPadding ?? 0,
       border: borders,
       outerBorder: this._tableOptions?.outerBorder ?? borders,
@@ -58837,7 +59075,6 @@ class MarkdownRenderable extends Renderable {
   }
   applyTableRenderableOptions(tableRenderable, options) {
     tableRenderable.columnWidthMode = options.columnWidthMode;
-    tableRenderable.columnFitter = options.columnFitter;
     tableRenderable.wrapMode = options.wrapMode;
     tableRenderable.cellPadding = options.cellPadding;
     tableRenderable.border = options.border;
@@ -58868,7 +59105,6 @@ class MarkdownRenderable extends Renderable {
       width: "100%",
       marginBottom,
       columnWidthMode: options.columnWidthMode,
-      columnFitter: options.columnFitter,
       wrapMode: options.wrapMode,
       cellPadding: options.cellPadding,
       border: options.border,
@@ -59728,34 +59964,6 @@ class ContentRenderable extends BoxRenderable {
     return this.getChildrenSortedByPrimaryAxis().map((child) => child.num);
   }
 }
-var SCROLLBOX_PADDING_KEYS = [
-  "padding",
-  "paddingX",
-  "paddingY",
-  "paddingTop",
-  "paddingRight",
-  "paddingBottom",
-  "paddingLeft"
-];
-function pickScrollBoxPadding(options) {
-  if (!options)
-    return {};
-  const picked = {};
-  for (const key of SCROLLBOX_PADDING_KEYS) {
-    const value = options[key];
-    if (value !== undefined) {
-      picked[key] = value;
-    }
-  }
-  return picked;
-}
-function stripScrollBoxPadding(options) {
-  const sanitized = { ...options };
-  for (const key of SCROLLBOX_PADDING_KEYS) {
-    delete sanitized[key];
-  }
-  return sanitized;
-}
 
 class ScrollBoxRenderable extends BoxRenderable {
   static idCounter = 0;
@@ -59903,38 +60111,27 @@ class ScrollBoxRenderable extends BoxRenderable {
       this._isApplyingStickyScroll = wasApplyingStickyScroll;
     }
   }
-  constructor(ctx, options) {
-    const {
-      wrapperOptions,
-      viewportOptions,
-      contentOptions,
-      rootOptions,
-      scrollbarOptions,
-      verticalScrollbarOptions,
-      horizontalScrollbarOptions,
-      stickyScroll = false,
-      stickyStart,
-      scrollX = false,
-      scrollY = true,
-      scrollAcceleration,
-      viewportCulling = true,
-      ...rootBoxOptions
-    } = options;
-    const forwardedContentPadding = {
-      ...pickScrollBoxPadding(rootBoxOptions),
-      ...pickScrollBoxPadding(rootOptions)
-    };
-    const sanitizedRootBoxOptions = stripScrollBoxPadding(rootBoxOptions);
-    const sanitizedRootOptions = rootOptions ? stripScrollBoxPadding(rootOptions) : undefined;
-    const mergedContentOptions = {
-      ...forwardedContentPadding,
-      ...contentOptions
-    };
+  constructor(ctx, {
+    wrapperOptions,
+    viewportOptions,
+    contentOptions,
+    rootOptions,
+    scrollbarOptions,
+    verticalScrollbarOptions,
+    horizontalScrollbarOptions,
+    stickyScroll = false,
+    stickyStart,
+    scrollX = false,
+    scrollY = true,
+    scrollAcceleration,
+    viewportCulling = true,
+    ...options
+  }) {
     super(ctx, {
       flexDirection: "row",
       alignItems: "stretch",
-      ...sanitizedRootBoxOptions,
-      ...sanitizedRootOptions
+      ...options,
+      ...rootOptions
     });
     this.internalId = ScrollBoxRenderable.idCounter++;
     this._stickyScroll = stickyScroll;
@@ -59966,7 +60163,7 @@ class ScrollBoxRenderable extends BoxRenderable {
       onSizeChange: () => {
         this.recalculateBarProps();
       },
-      ...mergedContentOptions,
+      ...contentOptions,
       id: `scroll-box-content-${this.internalId}`
     });
     this.viewport.add(this.content);
@@ -60282,34 +60479,6 @@ class ScrollBoxRenderable extends BoxRenderable {
       this.requestRender();
     });
   }
-  set padding(value) {
-    this.content.padding = value;
-    this.requestRender();
-  }
-  set paddingX(value) {
-    this.content.paddingX = value;
-    this.requestRender();
-  }
-  set paddingY(value) {
-    this.content.paddingY = value;
-    this.requestRender();
-  }
-  set paddingTop(value) {
-    this.content.paddingTop = value;
-    this.requestRender();
-  }
-  set paddingRight(value) {
-    this.content.paddingRight = value;
-    this.requestRender();
-  }
-  set paddingBottom(value) {
-    this.content.paddingBottom = value;
-    this.requestRender();
-  }
-  set paddingLeft(value) {
-    this.content.paddingLeft = value;
-    this.requestRender();
-  }
   set rootOptions(options) {
     Object.assign(this, options);
     this.requestRender();
@@ -61071,8 +61240,8 @@ class TabSelectRenderable extends Renderable {
   }
 }
 
-// node_modules/@opentui/react/chunk-7v2hbtna.js
-init_chunk_2mx7fq49();
+// node_modules/@opentui/react/chunk-9gg102mq.js
+init_chunk_eecw9x2f();
 var import_react = __toESM(require_react(), 1);
 var import_react2 = __toESM(require_react(), 1);
 var import_react3 = __toESM(require_react(), 1);
@@ -61199,7 +61368,7 @@ class ErrorBoundary extends import_react3.default.Component {
 }
 var package_default = {
   name: "@opentui/react",
-  version: "0.1.84",
+  version: "0.1.83",
   description: "React renderer for building terminal user interfaces using OpenTUI core",
   license: "MIT",
   repository: {
@@ -61534,7 +61703,7 @@ var hostConfig = {
 var reconciler = import_react_reconciler.default(hostConfig);
 if (process.env["DEV"] === "true") {
   try {
-    await init_chunk_bdqvmfwv().then(() => exports_chunk_bdqvmfwv);
+    await init_chunk_pm1hna8x().then(() => exports_chunk_pm1hna8x);
   } catch (error) {
     if (error.code === "ERR_MODULE_NOT_FOUND") {
       console.warn(`
@@ -61579,7 +61748,7 @@ function createRoot(renderer) {
 }
 
 // node_modules/@opentui/react/index.js
-init_chunk_2mx7fq49();
+init_chunk_eecw9x2f();
 var import_react5 = __toESM(require_react(), 1);
 var import_react6 = __toESM(require_react(), 1);
 var import_react7 = __toESM(require_react(), 1);
@@ -61689,8 +61858,6 @@ function Header() {
   const [branch, setBranch] = import_react13.useState("");
   const { isNarrow } = useLayout();
   const cwd = path2.basename(import_config.PROJECT_ROOT);
-  const mode = import_config.getMode();
-  const modeColors = { default: import_theme.colors.dim, max: import_theme.colors.accent, lite: import_theme.colors.muted };
   import_react13.useEffect(() => {
     try {
       const b2 = execSync("git rev-parse --abbrev-ref HEAD 2>/dev/null", {
@@ -61713,13 +61880,9 @@ function Header() {
           fg: import_theme.colors.dim,
           children: "  "
         }),
-        /* @__PURE__ */ jsx_runtime.jsxs("span", {
-          fg: modeColors[mode] || import_theme.colors.dim,
-          children: [
-            "[",
-            mode,
-            "]"
-          ]
+        /* @__PURE__ */ jsx_runtime.jsx("span", {
+          fg: import_theme.colors.accent,
+          children: "[max]"
         }),
         /* @__PURE__ */ jsx_runtime.jsx("span", {
           fg: import_theme.colors.dim,
@@ -62369,8 +62532,7 @@ var import_theme14 = __toESM(require_theme(), 1);
 var jsx_runtime14 = __toESM(require_jsx_runtime(), 1);
 var COMMANDS = [
   { cmd: "/help", desc: "Show this menu" },
-  { cmd: "/mode", desc: "Show/set mode (default, max, lite)" },
-  { cmd: "/compact", desc: "Compact conversation context" },
+  { cmd: "/compact", desc: "Compact/summarize conversation context" },
   { cmd: "/files", desc: "Show project file tree" },
   { cmd: "/clear", desc: "Clear conversation" },
   { cmd: "/cost", desc: "Show session stats" },