apex-dev 3.1.0 → 3.6.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") {
@@ -31679,11 +31679,13 @@ var require_config = __commonJS((exports, module2) => {
   var THINKER_MODEL = "z-ai/glm4.7";
   var COMMANDER_MODEL = "nvidia/llama-3.3-nemotron-70b-instruct";
   var CONTEXT_PRUNER_MODEL = "nvidia/llama-3.3-nemotron-70b-instruct";
+  var RESEARCHER_MODEL = "nvidia/llama-3.3-nemotron-70b-instruct";
+  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 = "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.
@@ -31777,6 +31779,30 @@ 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.`;
+  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.`;
+  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.NVIDIA_API_KEY || "",
     baseURL: "https://integrate.api.nvidia.com/v1"
@@ -31815,19 +31841,14 @@ 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,
     THINKER_MODEL,
     COMMANDER_MODEL,
     CONTEXT_PRUNER_MODEL,
+    RESEARCHER_MODEL,
+    GENERAL_AGENT_MODEL,
     MAX_TOOL_ITERATIONS,
     MAX_OUTPUT_LEN,
     TOOL_TIMEOUT,
@@ -31839,14 +31860,16 @@ Output JSON only, no markdown fences:
     COMMANDER_SYSTEM_PROMPT,
     CONTEXT_PRUNER_SYSTEM_PROMPT,
     SELECTOR_SYSTEM_PROMPT,
+    RESEARCHER_WEB_SYSTEM_PROMPT,
+    RESEARCHER_DOCS_SYSTEM_PROMPT,
+    GENERAL_AGENT_SYSTEM_PROMPT,
     nvidiaClient,
     session,
     truncateOutput,
     resolvePath,
     timestamp,
     sleep,
-    getMode,
-    setMode
+    getMode
   };
 });
 
@@ -31855,7 +31878,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 +31906,119 @@ 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
+
+- **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.
+- **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."
+- **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 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.
+
+# 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.
-
-# Tool Usage
-- Use Grep/Glob/ListDir to explore and locate code.
-- 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.
-- 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).
+# 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
+
+**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.
+
+**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.
+
+**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.
+
+**Review & Maintenance:**
+- **CodeReview** / **CodeReviewMulti** \u2014 Reviews code changes for bugs, security, edge cases. CodeReviewMulti runs automatically after edits.
+- **ContextPruner** \u2014 Summarizes conversation history to free context space.
+
+## How to Orchestrate (use your judgment)
 
-**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.
+**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.
 
-**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.
+**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.
 
-**Do NOT skip delegation** just because you think you can do it faster. Sub-agents provide better results through specialization. The only exceptions are:
+**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:**
+- CodeReviewMulti runs automatically after edits \u2014 don't duplicate its work.
+- If the review finds issues, fix them and re-validate.
+
+## 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
 
-# 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.
+## 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.
 
-# Note
-A separate code reviewer runs automatically after edits (skipped in lite mode, multi-perspective in max mode).
+# 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.
 
 # Environment
 Working directory: ${PROJECT_ROOT}
@@ -32214,7 +32274,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 +32289,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 +32320,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: {
@@ -32300,6 +32360,59 @@ var require_tools = __commonJS((exports, module2) => {
           required: []
         }
       }
+    },
+    {
+      type: "function",
+      function: {
+        name: "ResearcherWeb",
+        description: "Search the web and synthesize results into a clear answer using 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.",
+        parameters: {
+          type: "object",
+          properties: {
+            prompt: { type: "string", description: "The question to research. Be specific for better results." },
+            domains: {
+              type: "array",
+              description: 'Optional list of domains to restrict search to (e.g. ["stackoverflow.com", "github.com"]).',
+              items: { type: "string" }
+            }
+          },
+          required: ["prompt"]
+        }
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: "ResearcherDocs",
+        description: "Search technical documentation for a library or framework and synthesize a precise answer with API details and code examples. Use when you need to verify API signatures, find usage patterns, or check library behavior.",
+        parameters: {
+          type: "object",
+          properties: {
+            prompt: { type: "string", description: "The documentation question. Include the library/framework name and version if relevant." },
+            library: { type: "string", description: 'The library or framework name (e.g. "React", "Express", "Prisma").' }
+          },
+          required: ["prompt"]
+        }
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: "GeneralAgent",
+        description: "Spawn an independent general-purpose agent that reads specified files and solves a problem. Use when you need deep independent analysis, complex reasoning with full file context, or a second opinion. More powerful than Thinker because it receives actual file contents.",
+        parameters: {
+          type: "object",
+          properties: {
+            prompt: { type: "string", description: "The problem to solve. Be specific about what analysis or output you need." },
+            filePaths: {
+              type: "array",
+              description: "File paths to read and provide as context. The agent will analyze these files to solve the problem.",
+              items: { type: "string" }
+            }
+          },
+          required: ["prompt"]
+        }
+      }
     }
   ];
   module2.exports = { toolDefs };
@@ -32325,13 +32438,17 @@ var require_toolExecutors = __commonJS((exports, module2) => {
     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,
     nvidiaClient,
     session,
     truncateOutput,
     resolvePath,
-    sleep,
-    getMode
+    sleep
   } = require_config();
   async function streamCompletion(params, onStream) {
     for (let attempt = 0;attempt <= 2; attempt++) {
@@ -32365,6 +32482,35 @@ var require_toolExecutors = __commonJS((exports, module2) => {
       }
     }
   }
+  function parseEditorOps(text) {
+    const ops = [];
+    const editRe = /---\s*EDIT:\s*(.+?)\s*---[\s\S]*?OLD:\s*\n```[^\n]*\n([\s\S]*?)\n```[\s\S]*?NEW:\s*\n```[^\n]*\n([\s\S]*?)\n```/g;
+    let m2;
+    while ((m2 = editRe.exec(text)) !== null) {
+      ops.push({ type: "edit", path: m2[1].trim(), old_str: m2[2], new_str: m2[3] });
+    }
+    const createRe = /---\s*CREATE:\s*(.+?)\s*---\s*\n```[^\n]*\n([\s\S]*?)\n```/g;
+    while ((m2 = createRe.exec(text)) !== null) {
+      const p = m2[1].trim();
+      if (!ops.some((o) => o.path === p && o.type === "edit")) {
+        ops.push({ type: "create", path: p, content: m2[2] });
+      }
+    }
+    return ops;
+  }
+  async function applyEditorOps(ops, executeFn) {
+    const results = [];
+    for (const op of ops) {
+      if (op.type === "edit") {
+        const r = await executeFn("Edit", { path: op.path, old_str: op.old_str, new_str: op.new_str });
+        results.push(r.startsWith("Error") ? `\u2717 Edit ${op.path}: ${r}` : `\u2713 Edit ${op.path}`);
+      } else if (op.type === "create") {
+        const r = await executeFn("Write", { path: op.path, content: op.content });
+        results.push(r.startsWith("Error") ? `\u2717 Create ${op.path}: ${r}` : `\u2713 Create ${op.path}`);
+      }
+    }
+    return results;
+  }
   async function executeTool(name, args, onStream) {
     try {
       switch (name) {
@@ -32873,10 +33019,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 +33100,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(`
@@ -33061,24 +33199,40 @@ Reason: ${reason}`;
             if (improvements)
               result += `
 Improvements to consider: ${improvements}`;
-            result += `
+            const ops = parseEditorOps(winning.result);
+            if (ops.length > 0) {
+              if (onStream)
+                onStream(truncateOutput(result + `
+
+Applying ${ops.length} change(s)...`));
+              const applyResults = await applyEditorOps(ops, executeTool);
+              result += `
+
+--- Applied Changes ---
+${applyResults.join(`
+`)}`;
+            } else {
+              result += `
 
 ${winning.result}`;
+            }
             if (onStream)
               onStream(truncateOutput(result));
             return truncateOutput(result);
           } catch (apiErr) {
-            const result = `${header}Selector failed, using Implementation A:
+            const fallbackOps = parseEditorOps(implementations[0].result);
+            if (fallbackOps.length > 0) {
+              const applyResults = await applyEditorOps(fallbackOps, executeTool);
+              return truncateOutput(`${header}Selector failed, applied Implementation A:
+${applyResults.join(`
+`)}`);
+            }
+            return truncateOutput(`${header}Selector failed, using Implementation A:
 
-${implementations[0].result}`;
-            return truncateOutput(result);
+${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",
@@ -33258,6 +33412,187 @@ ${summary}`;
             return `Error: Context pruning failed \u2014 ${apiErr.message}`;
           }
         }
+        case "ResearcherWeb": {
+          const header = `Web Research (${RESEARCHER_MODEL})
+${"\u2500".repeat(40)}
+`;
+          if (onStream)
+            onStream(header + "Searching the web...");
+          let searchResults = "";
+          const searchArgs = { query: args.prompt, num_results: 5 };
+          if (args.domains && args.domains.length)
+            searchArgs.include_domains = args.domains;
+          try {
+            searchResults = await executeTool("WebSearch", searchArgs);
+          } catch {
+            searchResults = "(Web search unavailable \u2014 answering from knowledge)";
+          }
+          if (searchResults.startsWith("Error")) {
+            searchResults = `(Web search failed: ${searchResults.slice(0, 200)})
+
+Please answer from your training data.`;
+          }
+          try {
+            const streamCb = onStream ? (text) => onStream(truncateOutput(header + text)) : null;
+            const result = await streamCompletion({
+              model: RESEARCHER_MODEL,
+              messages: [
+                { role: "system", content: RESEARCHER_WEB_SYSTEM_PROMPT },
+                { role: "user", content: `# Question
+${args.prompt}
+
+# Web Search Results
+${searchResults}` }
+              ],
+              max_tokens: 4096,
+              temperature: 0.3
+            }, streamCb) || "(No response from researcher)";
+            return truncateOutput(header + result);
+          } catch (apiErr) {
+            return `Error: ResearcherWeb failed \u2014 ${apiErr.message}`;
+          }
+        }
+        case "ResearcherDocs": {
+          const header = `Docs Research (${RESEARCHER_MODEL})
+${"\u2500".repeat(40)}
+`;
+          if (onStream)
+            onStream(header + "Searching documentation...");
+          const docDomains = [
+            "developer.mozilla.org",
+            "react.dev",
+            "nodejs.org",
+            "docs.python.org",
+            "doc.rust-lang.org",
+            "pkg.go.dev",
+            "learn.microsoft.com",
+            "typescriptlang.org",
+            "expressjs.com",
+            "nextjs.org",
+            "vuejs.org",
+            "angular.io",
+            "svelte.dev",
+            "docs.rs",
+            "rubydoc.info",
+            "docs.oracle.com",
+            "npmjs.com"
+          ];
+          const query = args.library ? `${args.library} ${args.prompt}` : args.prompt;
+          let searchResults = "";
+          try {
+            searchResults = await executeTool("WebSearch", {
+              query: `${query} documentation`,
+              num_results: 8,
+              include_domains: docDomains
+            });
+          } catch {
+            searchResults = "";
+          }
+          if (!searchResults || searchResults === "No results found.") {
+            try {
+              searchResults = await executeTool("WebSearch", {
+                query: `${query} documentation API reference`,
+                num_results: 5
+              });
+            } catch {
+              searchResults = "(Documentation search unavailable \u2014 answering from knowledge)";
+            }
+          }
+          if (!searchResults || searchResults.startsWith("Error")) {
+            searchResults = "(No documentation results found \u2014 answering from knowledge)";
+          }
+          try {
+            const streamCb = onStream ? (text) => onStream(truncateOutput(header + text)) : null;
+            const result = await streamCompletion({
+              model: RESEARCHER_MODEL,
+              messages: [
+                { role: "system", content: RESEARCHER_DOCS_SYSTEM_PROMPT },
+                {
+                  role: "user",
+                  content: `# Question
+${args.prompt}${args.library ? `
+Library: ${args.library}` : ""}
+
+# Documentation Search Results
+${searchResults}`
+                }
+              ],
+              max_tokens: 4096,
+              temperature: 0.2
+            }, streamCb) || "(No response from researcher)";
+            return truncateOutput(header + result);
+          } catch (apiErr) {
+            return `Error: ResearcherDocs failed \u2014 ${apiErr.message}`;
+          }
+        }
+        case "GeneralAgent": {
+          const header = `General Agent (${GENERAL_AGENT_MODEL})
+${"\u2500".repeat(40)}
+`;
+          if (onStream)
+            onStream(header + "Reading files and analyzing...");
+          const MAX_TOTAL_CHARS = 50000;
+          let totalChars = 0;
+          const fileContents = [];
+          for (const fp of args.filePaths || []) {
+            const absPath = resolvePath(fp);
+            const stat = fs2.statSync(absPath, { throwIfNoEntry: false });
+            if (!stat || stat.isDirectory()) {
+              fileContents.push(`--- ${fp} ---
+[Not found or is a directory]`);
+              continue;
+            }
+            if (stat.size > 256 * 1024) {
+              fileContents.push(`--- ${fp} ---
+[File too large: ${(stat.size / 1024).toFixed(0)}KB \u2014 skipped]`);
+              continue;
+            }
+            const content = fs2.readFileSync(absPath, "utf-8");
+            if (totalChars + content.length > MAX_TOTAL_CHARS) {
+              const remaining = MAX_TOTAL_CHARS - totalChars;
+              if (remaining > 500) {
+                fileContents.push(`--- ${fp} ---
+${content.slice(0, remaining)}
+[Truncated \u2014 context limit reached]`);
+              }
+              totalChars = MAX_TOTAL_CHARS;
+              break;
+            }
+            fileContents.push(`--- ${fp} ---
+${content}`);
+            totalChars += content.length;
+          }
+          const historyCtx = session.conversationHistory.slice(-8).map((m2) => `[${m2.role}]: ${(m2.content || "").slice(0, 400)}`).join(`
+`);
+          const userContent = [
+            `# Task
+${args.prompt}`,
+            fileContents.length > 0 ? `
+# Files (${fileContents.length})
+${fileContents.join(`
+
+`)}` : "",
+            historyCtx ? `
+# Recent conversation
+${historyCtx}` : ""
+          ].filter(Boolean).join(`
+`);
+          try {
+            const streamCb = onStream ? (text) => onStream(truncateOutput(header + text)) : null;
+            const result = await streamCompletion({
+              model: GENERAL_AGENT_MODEL,
+              messages: [
+                { role: "system", content: GENERAL_AGENT_SYSTEM_PROMPT },
+                { role: "user", content: userContent }
+              ],
+              max_tokens: 4096,
+              temperature: 0.4
+            }, streamCb) || "(No response from agent)";
+            return truncateOutput(header + result);
+          } catch (apiErr) {
+            return `Error: GeneralAgent failed \u2014 ${apiErr.message}`;
+          }
+        }
         default:
           return `Unknown tool: ${name}`;
       }
@@ -33314,6 +33649,16 @@ var require_utils3 = __commonJS((exports, module2) => {
         return args.prompt ? args.prompt.slice(0, 40) : "running commands";
       case "ContextPruner":
         return "pruning context";
+      case "ResearcherWeb":
+        return args.prompt ? args.prompt.slice(0, 40) : "web research";
+      case "ResearcherDocs":
+        return args.prompt ? `${args.library ? args.library + ": " : ""}${args.prompt.slice(0, 30)}` : "docs research";
+      case "GeneralAgent":
+        return args.prompt ? args.prompt.slice(0, 40) : "analyzing";
+      case "WebSearch":
+        return args.query ? args.query.slice(0, 40) : "searching";
+      case "TodoList":
+        return args.action || "";
       default:
         return JSON.stringify(args).slice(0, 60);
     }
@@ -33395,8 +33740,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 +33757,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 +34082,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 +34127,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 +34201,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 +34286,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 +34327,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 +34351,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 +53766,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 +56776,6 @@ class TextTableRenderable extends Renderable {
   _content;
   _wrapMode;
   _columnWidthMode;
-  _columnFitter;
   _cellPadding;
   _showBorders;
   _border;
@@ -56105,9 +56803,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 +56821,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 +56873,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 +57026,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 +57038,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 +57212,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 +57234,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 +57264,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 +57314,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 +57637,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 +57648,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 +59423,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 +59436,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 +59466,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 +60325,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 +60472,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 +60524,7 @@ class ScrollBoxRenderable extends BoxRenderable {
       onSizeChange: () => {
         this.recalculateBarProps();
       },
-      ...mergedContentOptions,
+      ...contentOptions,
       id: `scroll-box-content-${this.internalId}`
     });
     this.viewport.add(this.content);
@@ -60282,34 +60840,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 +61601,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 +61729,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 +62064,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 +62109,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 +62219,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 +62241,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 +62893,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" },