centaurus-cli 3.1.3 → 3.1.4

package/dist/cli-adapter.js

@@ -4,17 +4,19 @@ import { fileURLToPath } from "url";
 import { dirname } from "path";
 import * as shellUtils from "./utils/shell.js";
 import { sanitizeForContext } from "./utils/context-sanitizer.js";
+import { truncateToolOutput, cleanupOrphanedToolOutputs, cleanupStaleToolOutputs } from "./utils/output-truncation.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 import { ConfigManager } from "./config/manager.js";
 import { ToolRegistry } from "./tools/registry.js";
 import { viewFileTool, writeToFileTool, editFileTool, listDirTool, multiEditFileTool } from "./tools/file-ops.js";
-import { runCommandTool } from "./tools/command.js";
+import { runCommandTool, resolvePostCommandCwd } from "./tools/command.js";
 import { grepSearchTool } from "./tools/grep-search.js";
 import { findFilesTool } from "./tools/find-files.js";
 import { getDiffTool } from "./tools/get-diff.js";
 import { inspectSymbolTool } from "./tools/inspect-symbol.js";
-import { createPlanTool, markTaskCompleteTool, getCurrentPlan, clearPlan, approvePlan, getPhaseContextForPrompt, getCurrentPhase } from "./tools/plan-mode.js";
+import { createPlanTool, markTaskCompleteTool, planAskQuestionTool, getCurrentPlan, clearPlan, approvePlan, getPlanContextForPrompt } from "./tools/plan-mode.js";
+import { todoWriteTool, getTodoContextForPrompt } from "./tools/todo-list.js";
 import { webSearchTool, fetchUrlTool } from "./tools/web-search.js";
 import { taskCompleteTool } from "./tools/task-complete.js";
 import { readBinaryFileTool } from "./tools/read-binary-file.js";
@@ -52,6 +54,8 @@ import { workflowStorage } from "./services/workflow-storage.js";
 import { CheckpointManager } from "./services/checkpoint-manager.js";
 import { rulesStorage } from "./services/rules-storage.js";
 import { resolveRuleReferences } from "./utils/rule-reference-resolver.js";
+import { THEME_PALETTE, setGlobalAccentColor } from "./ui/theme.js";
+import { skillStorage } from "./services/skill-storage.js";
 class CentaurusCLI {
   configManager;
   toolRegistry;
@@ -84,9 +88,13 @@ class CentaurusCLI {
   onPlanModeChange;
   onPlanApprovalRequest;
   onPlanCreated;
+  onPlanQuestionRequest;
   onTaskCompleted;
+  onTodoListUpdate;
   onPasswordRequest;
   currentInteractiveProcess;
+  tunnelOutputBuffer = "";
+  // Accumulated PTY output for custom tunnel capture
   conversationStarted = false;
   contextManager;
   commandDetector;
@@ -144,6 +152,14 @@ class CentaurusCLI {
   // Callback to show the rules editor
   onAiAutoSuggestChange;
   // Callback for AI auto-suggest setting changes
+  onLimitChatHistoryChange;
+  onThemeColorChange = null;
+  customTunnelCommand = null;
+  // Active custom tunnel command (e.g. "minicom")
+  onSubAgentListScreenSetup = null;
+  onSubAgentViewScreenSetup = null;
+  onSubAgentTerminateScreenSetup = null;
+  onSkillEditorScreenSetup = null;
   onRevertToCheckpointCallback;
   // Callback for revert UI update
   static AUTO_COMPACTION_TRIGGER_PERCENT = 80;
@@ -243,9 +259,15 @@ class CentaurusCLI {
   setOnPlanCreated(callback) {
     this.onPlanCreated = callback;
   }
+  setOnPlanQuestionRequest(callback) {
+    this.onPlanQuestionRequest = callback;
+  }
   setOnTaskCompleted(callback) {
     this.onTaskCompleted = callback;
   }
+  setOnTodoListUpdate(callback) {
+    this.onTodoListUpdate = callback;
+  }
   setOnCommandModeChange(callback) {
     this.onCommandModeChange = callback;
   }
@@ -307,6 +329,82 @@ class CentaurusCLI {
   setOnAiAutoSuggestChange(callback) {
     this.onAiAutoSuggestChange = callback;
   }
+  setOnLimitChatHistoryChange(callback) {
+    this.onLimitChatHistoryChange = callback;
+  }
+  setOnThemeColorChange(callback) {
+    this.onThemeColorChange = callback;
+  }
+  setCustomTunnelCommand(command) {
+    this.customTunnelCommand = command;
+    if (command) {
+      this.tunnelOutputBuffer = "";
+    }
+    quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [CLI] Custom tunnel state: ${command || "none"}
+`);
+  }
+  isCustomTunnelActive() {
+    return this.customTunnelCommand !== null;
+  }
+  getCustomTunnelCommand() {
+    return this.customTunnelCommand;
+  }
+  setOnSubAgentListScreenSetup(callback) {
+    this.onSubAgentListScreenSetup = callback;
+  }
+  setOnSubAgentViewScreenSetup(callback) {
+    this.onSubAgentViewScreenSetup = callback;
+  }
+  setOnSubAgentTerminateScreenSetup(callback) {
+    this.onSubAgentTerminateScreenSetup = callback;
+  }
+  setOnSkillEditorScreenSetup(callback) {
+    this.onSkillEditorScreenSetup = callback;
+  }
+  saveSkill(skill, previousName) {
+    return skillStorage.save(skill, previousName);
+  }
+  /** Execute a skill by name with user-provided parameters. Called from the UI when user types #skill-name. */
+  async executeSkill(skillName, params) {
+    const skill = skillStorage.load(skillName);
+    if (!skill) {
+      return `\u274C Skill "${skillName}" not found.`;
+    }
+    const cwd = this.cwd;
+    const result = await SubAgentManager.spawnSubAgent({
+      prompt: `${skill.prompt}
+
+User parameters: ${params || "(none)"}
+
+IMPORTANT: Your working directory is ${cwd}. Create all files and perform all operations ONLY within this directory. Do NOT use any other directory.`,
+      context: `This agent was invoked via the #${skill.name} skill.
+Working directory: ${cwd}`,
+      workingDirectory: cwd,
+      complexity: 5,
+      allowedTools: skill.allowedTools,
+      modelOverride: skill.model || void 0
+    });
+    if (result.success) {
+      const msg = `\u{1F680} **Skill "${skill.name}" started**
+
+**Agent ID:** ${result.agentId}
+**Access:** ${skill.accessLevel}${skill.model ? `
+**Model:** ${skill.model}` : ""}
+**Parameters:** ${params || "(none)"}
+
+The skill is running as a sub-agent. Use \`/sub-agent list\` to monitor.`;
+      if (this.onResponseCallback) {
+        this.onResponseCallback(msg);
+      }
+      return msg;
+    } else {
+      const msg = `\u274C Failed to start skill "${skill.name}": ${result.error}`;
+      if (this.onResponseCallback) {
+        this.onResponseCallback(msg);
+      }
+      return msg;
+    }
+  }
   setOnRevertToCheckpoint(callback) {
     this.onRevertToCheckpointCallback = callback;
   }
@@ -588,6 +686,11 @@ Begin executing now, starting with Step 1.`;
       this.onCwdChange(this.cwd);
     }
     this.saveCurrentChat();
+    if (this.customTunnelCommand) {
+      quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [ExitRemoteSession] Clearing custom tunnel: ${this.customTunnelCommand}
+`);
+      this.customTunnelCommand = null;
+    }
     if (this.onConnectionStatusUpdate) {
       if (newContext.type === "local") {
         this.onConnectionStatusUpdate({
@@ -628,6 +731,11 @@ Begin executing now, starting with Step 1.`;
       this.onCwdChange(this.cwd);
     }
     this.saveCurrentChat();
+    if (this.customTunnelCommand) {
+      quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [CLI] Clearing custom tunnel on remote disconnect: ${this.customTunnelCommand}
+`);
+      this.customTunnelCommand = null;
+    }
     if (this.onConnectionStatusUpdate) {
       if (currentContext.type === "local") {
         this.onConnectionStatusUpdate({
@@ -1033,18 +1141,22 @@ Begin executing now, starting with Step 1.`;
     });
   }
   /**
-   * Truncate large results for AI consumption
+   * Truncate large results for AI consumption.
+   * Uses head+tail truncation and saves full output to a file for AI retrieval.
+   * Detects remote sessions (SSH/Docker/WSL) to add Environment="local" hints
+   * in the truncation message so the AI can read the locally-saved output file.
    */
-  truncateResult(result, maxLength = 5e5) {
-    const resultStr = typeof result === "string" ? result : JSON.stringify(result);
-    if (resultStr.length > maxLength) {
-      const truncated = resultStr.substring(0, maxLength);
-      const linesRemoved = (resultStr.match(/\n/g) || []).length - (truncated.match(/\n/g) || []).length;
-      return truncated + `
-
-[... truncated ${resultStr.length - maxLength} characters, ~${linesRemoved} lines removed for brevity ...]`;
-    }
-    return result;
+  truncateResult(result, toolName) {
+    const currentContext = this.contextManager.getCurrentContext();
+    const isRemote = currentContext.type !== "local";
+    return truncateToolOutput(
+      toolName || "unknown",
+      result,
+      this.currentChatId,
+      void 0,
+      // use default threshold
+      isRemote
+    );
   }
   calculateUsagePercent(tokenCount, maxTokens) {
     if (!Number.isFinite(maxTokens) || maxTokens <= 0) {
@@ -1276,7 +1388,68 @@ ${CentaurusCLI.TERMINAL_COMPACTION_NOTICE}`;
       };
     }
   }
+  /**
+   * Force-compact ALL eligible candidates (read_file results, terminal outputs, shell outputs)
+   * without any usage threshold or target limit. Called when user runs /compact manually.
+   */
+  async forceCompactContext() {
+    try {
+      const model = this.configManager.get("modelName") || "gemini-2.5-flash";
+      const { getModelContextWindowSync } = await import("./config/models.js");
+      const maxTokens = getModelContextWindowSync(model);
+      let tokenCount = await this.countTokensForMessages(model, this.conversationHistory);
+      this.applyTokenCount(tokenCount);
+      const beforeUsagePercent = this.calculateUsagePercent(tokenCount, maxTokens);
+      this.notifyToolStatus(
+        CentaurusCLI.AUTO_COMPACTION_TOOL_NAME,
+        "executing",
+        { usagePercent: Number(beforeUsagePercent.toFixed(2)), manual: true }
+      );
+      const candidates = this.getAutoCompactionCandidates();
+      let compactedCount = 0;
+      for (const candidate of candidates) {
+        const changed = this.applyAutoCompactionCandidate(candidate);
+        if (changed) {
+          compactedCount += 1;
+        }
+      }
+      if (compactedCount > 0) {
+        this.appendAutoCompactionNoticeForAgent();
+      }
+      tokenCount = await this.countTokensForMessages(model, this.conversationHistory);
+      this.applyTokenCount(tokenCount);
+      const afterUsagePercent = this.calculateUsagePercent(tokenCount, maxTokens);
+      const summary = compactedCount > 0 ? `Compacted ${compactedCount} item(s) (file reads and terminal outputs).
+Usage: ${beforeUsagePercent.toFixed(1)}% \u2192 ${afterUsagePercent.toFixed(1)}%` : `No eligible file reads or terminal outputs found in the conversation.
+Current usage: ${beforeUsagePercent.toFixed(1)}%`;
+      this.notifyToolStatus(
+        CentaurusCLI.AUTO_COMPACTION_TOOL_NAME,
+        "completed",
+        {
+          compactedCount,
+          beforeUsagePercent: Number(beforeUsagePercent.toFixed(2)),
+          afterUsagePercent: Number(afterUsagePercent.toFixed(2)),
+          manual: true
+        },
+        summary
+      );
+      quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [ManualCompaction] Compacted ${compactedCount} item(s), usage ${beforeUsagePercent.toFixed(1)}% -> ${afterUsagePercent.toFixed(1)}%
+`);
+      return summary;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.notifyToolStatus(
+        CentaurusCLI.AUTO_COMPACTION_TOOL_NAME,
+        "error",
+        void 0,
+        void 0,
+        `Manual compaction failed: ${errorMessage}`
+      );
+      return `\u274C Compaction failed: ${errorMessage}`;
+    }
+  }
   async initialize() {
+    cleanupStaleToolOutputs();
     this.toolRegistry.register(viewFileTool);
     this.toolRegistry.register(writeToFileTool);
     this.toolRegistry.register(editFileTool);
@@ -1289,6 +1462,7 @@ ${CentaurusCLI.TERMINAL_COMPACTION_NOTICE}`;
     this.toolRegistry.register(inspectSymbolTool);
     this.toolRegistry.register(createPlanTool);
     this.toolRegistry.register(markTaskCompleteTool);
+    this.toolRegistry.register(planAskQuestionTool);
     this.toolRegistry.register(webSearchTool);
     this.toolRegistry.register(fetchUrlTool);
     this.toolRegistry.register(taskCompleteTool);
@@ -1300,6 +1474,7 @@ ${CentaurusCLI.TERMINAL_COMPACTION_NOTICE}`;
     this.toolRegistry.register(workflowTool);
     this.toolRegistry.register(fastContextTool);
     this.toolRegistry.register(addMcpTool);
+    this.toolRegistry.register(todoWriteTool);
     SubAgentManager.initialize(this.toolRegistry);
     SubAgentManager.setOnSubAgentCountChange((count) => {
       if (this.onSubAgentCountChange) {
@@ -1383,13 +1558,34 @@ Press Enter to continue...
     return config.modelName || config.model || "gemini-2.5-flash";
   }
   /**
-   * Cancel the current AI request
+   * Cancel the current AI request.
+   * If there are queued interrupt messages, dispatch the next one after a short
+   * delay so the "Operation cancelled" message appears in the UI first.
    */
   cancelCurrentRequest() {
     if (this.currentAbortController) {
       this.requestIntentionallyAborted = true;
       this.currentAbortController.abort();
       this.currentAbortController = void 0;
+      if (this.interruptQueue.length > 0) {
+        const nextInterrupt = this.interruptQueue.shift();
+        if (this.onInterruptQueueUpdateCallback) {
+          this.onInterruptQueueUpdateCallback(this.interruptQueue);
+        }
+        quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [cancelCurrentRequest] Will dispatch queued interrupt after ESC.
+`);
+        const wrappedMessage = `${CentaurusCLI.INTERRUPT_SYSTEM_NOTE_PREFIX}
+
+${nextInterrupt}`;
+        setTimeout(() => {
+          if (this.onQueuedMessageDispatchedCallback) {
+            this.onQueuedMessageDispatchedCallback(nextInterrupt);
+          }
+          this.handleMessage(wrappedMessage, { interruptCleanText: nextInterrupt }).catch((err) => {
+            conversationLogger.logError("Queued interrupt handleMessage (from cancel)", err);
+          });
+        }, 150);
+      }
     }
   }
   /**
@@ -1592,7 +1788,8 @@ Press Enter to continue...
 `
       );
     }
-    const resolvedMessage = augmentedPrompt.replace(/@([^\s@]+)/g, (match, relPath) => {
+    const resolvedMessage = augmentedPrompt.replace(/@"([^"]+)"|@([^\s@]+)/g, (match, quotedPath, unquotedPath) => {
+      const relPath = quotedPath || unquotedPath;
       if (relPath.startsWith("rules:")) return match;
       const absPath = path.resolve(this.cwd, relPath);
       if (fs.existsSync(absPath)) return absPath;
@@ -1663,17 +1860,21 @@ Use /session-limits to check your quota status.`;
     }
     let userMessageContent = resolvedMessage;
     if (this.planMode && !getCurrentPlan()?.isActive) {
-      const planModePrefix = `[PLAN MODE ACTIVE - You MUST call create_plan first before any implementation tools]
+      const planModePrefix = `[PLAN MODE ACTIVE - You MUST call create_plan to submit a detailed plan document]
 
 User Request: ${resolvedMessage}
 
 CRITICAL INSTRUCTIONS:
 1. You are in PLANNING MODE - DO NOT implement anything directly
-2. First explore the codebase using view_file, list_dir, grep_search to understand the context
-3. Then call create_plan with a detailed plan including:
-   - designSummary: Your understanding of the codebase
-   - tasks: Hierarchical tasks with subtasks
-4. Wait for user approval before implementing
+2. If the request is ambiguous or missing important details, use plan_ask_question to ask 1-2 clarifying questions FIRST
+3. Explore the codebase using view_file, list_dir, grep_search to understand the context
+4. Then call create_plan with:
+   - title: A clear plan title
+   - document: A comprehensive markdown plan document with analysis, tables, and numbered implementation steps
+   - implementation_steps: Array of step descriptions extracted from the document
+5. Wait for user approval before implementing
+
+The plan document should include: Overview, Current State Analysis, Proposed Changes (with tables if applicable), Implementation Steps (numbered sequentially), and Verification notes.
 
 DO NOT use write_to_file, edit_file, or execute_command until the plan is approved.`;
       userMessageContent = planModePrefix;
@@ -1788,7 +1989,22 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
       }
     }
     try {
-      const tools = this.toolRegistry.getSchemas();
+      let tools = this.toolRegistry.getSchemas();
+      const TUNNEL_ALLOWED_TOOLS = /* @__PURE__ */ new Set([
+        "execute_command",
+        // auto-routed to shell_input for the tunnel
+        "task_complete",
+        // always needed to finish tasks
+        "todo_write",
+        // task tracking still useful
+        "web_search",
+        // web search is independent of the tunnel
+        "fetch_url"
+        // fetching URLs is independent of the tunnel
+      ]);
+      if (this.customTunnelCommand) {
+        tools = tools.filter((t) => TUNNEL_ALLOWED_TOOLS.has(t.name));
+      }
       const context = {
         cwd: this.cwd,
         contextManager: this.contextManager,
@@ -1810,6 +2026,9 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
           return true;
         },
         onStreamingOutput: (chunk, type, toolName) => {
+          if (this.customTunnelCommand && (toolName === "execute_command" || !toolName)) {
+            this.tunnelOutputBuffer += chunk;
+          }
           if (this.onToolStreamingOutput) {
             this.onToolStreamingOutput({ toolName: toolName || "execute_command", chunk, type });
           }
@@ -1827,6 +2046,19 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
       messages = this.aiContextInjector.injectSubshellContext(messages, currentContext);
       const connectedMcpServers = this.getConnectedMCPServerNames();
       messages = this.aiContextInjector.injectMCPContext(messages, connectedMcpServers);
+      messages = this.aiContextInjector.injectTodoContext(messages, getTodoContextForPrompt());
+      if (this.customTunnelCommand) {
+        const tunnelParentCtx = this.contextManager.getCurrentContext();
+        let parentInfo;
+        if (tunnelParentCtx.type === "ssh" && tunnelParentCtx.metadata) {
+          parentInfo = `${tunnelParentCtx.metadata.username || "user"}@${tunnelParentCtx.metadata.hostname || "remote"}`;
+        } else if (tunnelParentCtx.type === "wsl" && tunnelParentCtx.metadata) {
+          parentInfo = tunnelParentCtx.metadata.distroName || "WSL";
+        } else if (tunnelParentCtx.type === "docker" && tunnelParentCtx.metadata) {
+          parentInfo = tunnelParentCtx.metadata.containerId?.substring(0, 12) || "container";
+        }
+        messages = this.aiContextInjector.injectCustomTunnelContext(messages, this.customTunnelCommand, tunnelParentCtx.type, parentInfo);
+      }
       let environmentContext = this.getEnvironmentContext();
       const mode = this.getMode();
       let finalAssistantMessage = "";
@@ -1999,7 +2231,7 @@ Use /session-limits to check your quota status.`;
               thoughtContent = "";
             }
             toolCalls.push(chunk.toolCall);
-            const SPECIAL_TOOLS = ["task_complete", "create_plan", "mark_task_complete"];
+            const SPECIAL_TOOLS = ["task_complete", "create_plan", "mark_task_complete", "plan_ask_question"];
             if (SPECIAL_TOOLS.includes(toolCall.name)) {
               if (this.onToolExecutionUpdate) {
                 this.onToolExecutionUpdate({
@@ -2013,6 +2245,62 @@ Use /session-limits to check your quota status.`;
             isToolExecuting = true;
             toolsExecutedInStream = true;
             try {
+              if (this.customTunnelCommand && toolCall.name === "execute_command" && !toolCall.arguments?.shell_input) {
+                const tunnelCmd = toolCall.arguments?.CommandLine || toolCall.arguments?.commandLine || toolCall.arguments?.command;
+                if (tunnelCmd && this.currentInteractiveProcess) {
+                  quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [CLI] Executing in custom tunnel (in-stream): ${tunnelCmd}
+`);
+                  const rText = toolCall.arguments.reason_text;
+                  if (rText && this.onResponseStreamCallback) {
+                    this.onResponseStreamCallback(rText + "\n\n");
+                  }
+                  toolCall.arguments._customTunnelExec = true;
+                  this.notifyToolStatus(toolCall.name, "executing", toolCall.arguments);
+                  conversationLogger.logToolExecutionStart(toolCall.name, toolCall.id);
+                  const outputBefore = this.tunnelOutputBuffer.length;
+                  const inputWithEnter = tunnelCmd.endsWith("\n") || tunnelCmd.endsWith("\r") ? tunnelCmd : tunnelCmd + "\r";
+                  this.currentInteractiveProcess.write(inputWithEnter);
+                  let lastLen = outputBefore;
+                  const maxWaitMs = 5e3;
+                  const pollMs = 300;
+                  const stabilityMs = 800;
+                  let stableTime = 0;
+                  const waitStart = Date.now();
+                  while (Date.now() - waitStart < maxWaitMs) {
+                    await new Promise((r) => setTimeout(r, pollMs));
+                    const currentLen = this.tunnelOutputBuffer.length;
+                    if (currentLen > lastLen) {
+                      lastLen = currentLen;
+                      stableTime = 0;
+                    } else {
+                      stableTime += pollMs;
+                      if (stableTime >= stabilityMs) break;
+                    }
+                  }
+                  const capturedOutput = this.tunnelOutputBuffer.substring(outputBefore);
+                  const { processTerminalOutput } = await import("./utils/terminal-output.js");
+                  const processedOutput = processTerminalOutput(capturedOutput).trim() || "(no output)";
+                  this.notifyToolStatus(toolCall.name, "completed", toolCall.arguments, processedOutput);
+                  conversationLogger.logToolResult(toolCall.name, toolCall.id, processedOutput, true);
+                  const sanitizedResult = sanitizeForContext(toolCall.name, processedOutput, toolCall.arguments);
+                  inStreamToolResults.push({
+                    tool_call_id: toolCall.id,
+                    name: toolCall.name,
+                    result: this.truncateResult(sanitizedResult, toolCall.name)
+                  });
+                  inStreamHandledIds.add(toolCall.id);
+                  isToolExecuting = false;
+                  if (pendingTextBuffer && this.onResponseStreamCallback) {
+                    this.onResponseStreamCallback(pendingTextBuffer);
+                    pendingTextBuffer = "";
+                  }
+                  continue;
+                } else if (tunnelCmd && !this.currentInteractiveProcess) {
+                  quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [CLI] Custom tunnel process exited, running execute_command normally (in-stream): ${tunnelCmd}
+`);
+                  this.customTunnelCommand = null;
+                }
+              }
               const reasonText = toolCall.arguments.reason_text;
               const isShellInput = toolCall.name === "execute_command" && toolCall.arguments.shell_input;
               if (reasonText && !isShellInput && this.onResponseStreamCallback) {
@@ -2037,6 +2325,33 @@ Use /session-limits to check your quota status.`;
               if (result.success) {
                 conversationLogger.logToolResult(toolCall.name, toolCall.id, result.result, true);
                 this.notifyToolStatus(toolCall.name, "completed", toolCall.arguments, result.result);
+                if (toolCall.name === "todo_write" && typeof result.result === "string" && result.result.startsWith("TODO_UPDATED:")) {
+                  try {
+                    const todoData = JSON.parse(result.result.substring("TODO_UPDATED:".length));
+                    if (this.onTodoListUpdate) {
+                      this.onTodoListUpdate(todoData.todos, todoData.completedCount, todoData.totalCount);
+                    }
+                    inStreamToolResults.push({
+                      tool_call_id: toolCall.id,
+                      name: toolCall.name,
+                      result: todoData.summary
+                    });
+                  } catch (parseError) {
+                    logWarning(`Failed to parse todo list update: ${parseError?.message || parseError}`);
+                    inStreamToolResults.push({
+                      tool_call_id: toolCall.id,
+                      name: toolCall.name,
+                      result: result.result
+                    });
+                  }
+                  inStreamHandledIds.add(toolCall.id);
+                  isToolExecuting = false;
+                  if (pendingTextBuffer && this.onResponseStreamCallback) {
+                    this.onResponseStreamCallback(pendingTextBuffer);
+                    pendingTextBuffer = "";
+                  }
+                  continue;
+                }
                 if (["write_to_file", "edit_file", "multi_edit_file"].includes(toolCall.name)) {
                   this.updateFileChangeSummary();
                 }
@@ -2053,7 +2368,7 @@ Use /session-limits to check your quota status.`;
                 inStreamToolResults.push({
                   tool_call_id: toolCall.id,
                   name: toolCall.name,
-                  result: this.truncateResult(sanitizedResult)
+                  result: this.truncateResult(sanitizedResult, toolCall.name)
                 });
               } else {
                 conversationLogger.logToolResult(toolCall.name, toolCall.id, null, false, result.error);
@@ -2152,6 +2467,50 @@ Use /session-limits to check your quota status.`;
                 clearPlan();
                 break;
               }
+              if (toolCall.name === "plan_ask_question") {
+                const execResult = await this.toolRegistry.execute(toolCall.name, toolCall.arguments, context);
+                const result2 = execResult.success ? String(execResult.result) : `Error: ${execResult.error}`;
+                if (typeof result2 === "string" && result2.startsWith("ASK_QUESTION:")) {
+                  const questionJson = result2.substring("ASK_QUESTION:".length);
+                  try {
+                    const { question, options: options2 } = JSON.parse(questionJson);
+                    let userAnswer;
+                    if (this.onPlanQuestionRequest) {
+                      userAnswer = await this.onPlanQuestionRequest(question, options2);
+                    } else {
+                      userAnswer = "[User skipped this question. Proceed with the most appropriate approach.]";
+                    }
+                    const questionAssistantMsg = {
+                      role: "assistant",
+                      content: "",
+                      tool_calls: [toolCall]
+                    };
+                    if (currentTurnThinking) {
+                      questionAssistantMsg.thinking = currentTurnThinking;
+                    }
+                    if (currentTurnThinkingSignature) {
+                      questionAssistantMsg.thinkingSignature = currentTurnThinkingSignature;
+                    }
+                    this.conversationHistory.push(questionAssistantMsg);
+                    this.conversationHistory.push({
+                      role: "tool",
+                      tool_call_id: toolCall.id,
+                      content: `User's answer: ${userAnswer}`
+                    });
+                    handledToolCallIds.add(toolCall.id);
+                    messages = getMessagesForContext();
+                    continue;
+                  } catch (parseError) {
+                    logWarning(`Failed to parse plan question: ${parseError?.message || parseError}`);
+                  }
+                }
+                toolResults.push({
+                  tool_call_id: toolCall.id,
+                  name: toolCall.name,
+                  result: result2 || "Question could not be displayed to user."
+                });
+                continue;
+              }
               if (toolCall.name === "create_plan") {
                 const execResult = await this.toolRegistry.execute(toolCall.name, toolCall.arguments, context);
                 const result2 = execResult.success ? String(execResult.result) : `Error: ${execResult.error}`;
@@ -2189,13 +2548,22 @@ Use /session-limits to check your quota status.`;
                           content: "Plan approved by user. Now switching to execution mode."
                         });
                         handledToolCallIds.add(toolCall.id);
-                        const phaseContext = getPhaseContextForPrompt();
+                        const planContext = getPlanContextForPrompt();
                         const originalRequest = this.pendingPlanRequest || message;
-                        const executionPrompt = `${phaseContext}
+                        const executionPrompt = `The user has approved your plan. Now implement it step by step.
+
+${planContext}
+
+## Full Plan Document (for reference):
+${plan.document}
 
 Original Request: ${originalRequest}
 
-Complete the current task. After finishing each subtask, call mark_task_complete with the subtask number (e.g., "1.1"). When all subtasks are done, the main task will automatically complete and you'll receive the next task.`;
+INSTRUCTIONS:
+- Implement each step one at a time, in order
+- After completing each step, call mark_task_complete with step_number=N (e.g., step_number=1, step_number=2)
+- When all steps are complete, output your summary then call task_complete to end the session
+- Start with step 1 now.`;
                         this.conversationHistory.push({
                           role: "user",
                           content: executionPrompt
@@ -2225,7 +2593,7 @@ Complete the current task. After finishing each subtask, call mark_task_complete
                       this.conversationHistory.push({
                         role: "tool",
                         tool_call_id: toolCall.id,
-                        content: `Plan created: "${plan.title}" with ${plan.steps.length} tasks. Waiting for user approval.`
+                        content: `Plan created: "${plan.title}" with ${plan.implementationSteps.length} steps. Waiting for user approval.`
                       });
                       handledToolCallIds.add(toolCall.id);
                       messages = [...this.conversationHistory];
@@ -2285,74 +2653,27 @@ Complete the current task. After finishing each subtask, call mark_task_complete
                   const completionJson = result2.substring("TASK_COMPLETED:".length);
                   try {
                     const completion = JSON.parse(completionJson);
-                    const currentPlanData = getCurrentPlan();
-                    if (currentPlanData && this.onTaskCompleted) {
-                      const taskNumParts = String(completion.taskNumber).split(".");
-                      const mainTaskNum = parseInt(taskNumParts[0], 10) - 1;
-                      const task = currentPlanData.steps[mainTaskNum];
-                      if (task) {
-                        this.onTaskCompleted(
-                          task,
-                          completion.taskNumber,
-                          completion.totalCount,
-                          completion.completionNote,
-                          completion.taskDescription
-                          // Pass the actual task/subtask description
-                        );
-                      }
+                    if (this.onTaskCompleted) {
+                      this.onTaskCompleted(
+                        completion.stepNumber,
+                        completion.stepDescription,
+                        completion.completedCount,
+                        completion.totalCount,
+                        completion.completionNote,
+                        completion.allSteps
+                      );
                     }
-                    const displayType = completion.type === "subtask" ? "Subtask" : "Task";
                     this.notifyToolStatus(
                       toolCall.name,
                       "completed",
                       toolCall.arguments,
-                      `${displayType} ${completion.taskNumber} of ${completion.totalCount} completed: ${completion.taskDescription}`
+                      `Step ${completion.stepNumber} of ${completion.totalCount} completed: ${completion.stepDescription}`
                     );
-                    if (completion.mainTaskComplete || completion.type === "task") {
-                      const nextPhase = getCurrentPhase();
-                      if (nextPhase && !completion.allComplete) {
-                        const phaseContext = getPhaseContextForPrompt();
-                        toolResults.push({
-                          tool_call_id: toolCall.id,
-                          name: toolCall.name,
-                          result: `Task completed. Moving to Task ${nextPhase.taskNumber}: ${nextPhase.task.description}`
-                        });
-                        const nextPhaseAssistantMsg = {
-                          role: "assistant",
-                          content: "",
-                          tool_calls: [toolCall]
-                        };
-                        if (currentTurnThinking) {
-                          nextPhaseAssistantMsg.thinking = currentTurnThinking;
-                        }
-                        if (currentTurnThinkingSignature) {
-                          nextPhaseAssistantMsg.thinkingSignature = currentTurnThinkingSignature;
-                        }
-                        this.conversationHistory.push(nextPhaseAssistantMsg);
-                        this.conversationHistory.push({
-                          role: "tool",
-                          tool_call_id: toolCall.id,
-                          content: `Task completed. Now starting Task ${nextPhase.taskNumber}.`
-                        });
-                        this.conversationHistory.push({
-                          role: "user",
-                          content: `${phaseContext}
-
-Continue with the next task. Complete each subtask and call mark_task_complete for each one.`
-                        });
-                        handledToolCallIds.add(toolCall.id);
-                        messages = getMessagesForContext();
-                        continue;
-                      }
-                    }
                     toolResults.push({
                       tool_call_id: toolCall.id,
                       name: toolCall.name,
-                      result: completion.allComplete ? "All tasks completed! Output your summary of what was accomplished, then call task_complete()." : completion.nextSubtask ? `Subtask ${completion.taskNumber} completed. Next subtask: ${completion.nextSubtask}` : completion.nextTask ? `Task ${completion.taskNumber} completed. Next: ${completion.nextTask}` : `Task ${completion.taskNumber} completed.`
+                      result: completion.allComplete ? "All steps in the plan are now completed! Output your summary of what was accomplished, then call task_complete()." : completion.nextStep ? `Step ${completion.stepNumber} completed (${completion.completedCount}/${completion.totalCount}). Next step ${completion.nextStepNumber}: ${completion.nextStep}` : `Step ${completion.stepNumber} completed.`
                     });
-                    if (completion.allComplete) {
-                      toolResults[toolResults.length - 1].result = "All tasks in the plan are now completed! Output your summary of what was accomplished, then call task_complete().";
-                    }
                   } catch (parseError) {
                     logWarning(`Failed to parse task completion: ${parseError?.message || parseError}`);
                   }
@@ -2388,6 +2709,41 @@ The system has stopped to prevent an infinite loop.
               }
               const currentCtx = this.contextManager.getCurrentContext();
               const effectiveCwd = currentCtx.type !== "local" ? currentCtx.metadata?.workingDirectory || "~" : this.cwd;
+              if (this.customTunnelCommand && toolCall.name === "execute_command" && !toolCall.arguments?.shell_input && !toolCall.arguments?._customTunnelExec) {
+                const tunnelCommandLine = toolCall.arguments?.CommandLine || toolCall.arguments?.commandLine || toolCall.arguments?.command;
+                if (tunnelCommandLine && this.currentInteractiveProcess) {
+                  quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [CLI] Executing in custom tunnel (post-stream fallback): ${tunnelCommandLine}
+`);
+                  toolCall.arguments._customTunnelExec = true;
+                  const outputBefore = this.tunnelOutputBuffer.length;
+                  const inputWithEnter = tunnelCommandLine.endsWith("\n") || tunnelCommandLine.endsWith("\r") ? tunnelCommandLine : tunnelCommandLine + "\r";
+                  this.currentInteractiveProcess.write(inputWithEnter);
+                  let lastLen2 = outputBefore;
+                  let stableTime2 = 0;
+                  const waitStart2 = Date.now();
+                  while (Date.now() - waitStart2 < 5e3) {
+                    await new Promise((r) => setTimeout(r, 300));
+                    const curLen = this.tunnelOutputBuffer.length;
+                    if (curLen > lastLen2) {
+                      lastLen2 = curLen;
+                      stableTime2 = 0;
+                    } else {
+                      stableTime2 += 300;
+                      if (stableTime2 >= 800) break;
+                    }
+                  }
+                  const captured = this.tunnelOutputBuffer.substring(outputBefore);
+                  const { processTerminalOutput: pTO } = await import("./utils/terminal-output.js");
+                  const processed = pTO(captured).trim() || "(no output)";
+                  this.notifyToolStatus(toolCall.name, "completed", toolCall.arguments, processed);
+                  conversationLogger.logToolResult(toolCall.name, toolCall.id, processed, true);
+                  const sanitized = sanitizeForContext(toolCall.name, processed, toolCall.arguments);
+                  toolResults.push({ tool_call_id: toolCall.id, name: toolCall.name, result: this.truncateResult(sanitized, toolCall.name) });
+                  continue;
+                } else if (tunnelCommandLine && !this.currentInteractiveProcess) {
+                  this.customTunnelCommand = null;
+                }
+              }
               let remoteContext;
               if (currentCtx.type !== "local") {
                 const metadata = currentCtx.metadata;
@@ -2461,7 +2817,7 @@ The system has stopped to prevent an infinite loop.
                 }
                 const sanitizedResult = sanitizeForContext(toolCall.name, parsedResult, toolCall.arguments);
                 conversationLogger.logToolResult(`${toolCall.name} (SANITIZED_CONTEXT)`, toolCall.id, sanitizedResult, true);
-                const truncatedResult = this.truncateResult(sanitizedResult);
+                const truncatedResult = this.truncateResult(sanitizedResult, toolCall.name);
                 toolResults.push({
                   tool_call_id: toolCall.id,
                   name: toolCall.name,
@@ -2847,13 +3203,11 @@ ${nextInterrupt}`;
 /sync       - Sync data to/from cloud (upload/restore)
 /config     - View current configuration
 /model      - Select from available Google models
-/plan       - Toggle plan mode for complex implementations
+/plan       - Toggle plan mode for complex implementations (or Ctrl+P)
 /mcp        - Manage configured MCP servers and tools
 /docs       - Open Centaurus documentation in browser
 /copy-chat-context - Copy chat as readable text to clipboard
 /session-limits - View session quota usage and limits
-/quality    - Toggle enhanced quality features (thinking protocol, validation)
-/autonomous - Toggle autonomous mode (Silent Operator with task_complete)
 /sign-in    - Sign in with Google (if not already signed in)
 /logout     - Sign out, clear session, and exit CLI
 /exit       - Exit the application
@@ -3107,18 +3461,6 @@ Exiting CLI anyway...`;
           this.onPlanModeChange(this.planMode);
         }
         return;
-      case "quality":
-        const currentQuality = this.configManager.get("enhancedQuality");
-        const newQuality = currentQuality === false;
-        this.configManager.set("enhancedQuality", newQuality);
-        responseMessage = newQuality ? "\u2705 Enhanced quality features enabled\n\nThe AI will now use:\n\u2022 Structured thinking protocol before actions\n\u2022 Enhanced command execution hygiene\n\u2022 Intelligent file editing validation\n\u2022 Professional SRE/Architect persona" : "\u26A0\uFE0F  Enhanced quality features disabled\n\nThe AI will use the basic system prompt without:\n\u2022 Thinking protocol\n\u2022 Advanced validation\n\u2022 Enhanced tool descriptions";
-        break;
-      case "autonomous":
-        const currentAutonomous = this.configManager.get("autonomousMode");
-        const newAutonomous = !currentAutonomous;
-        this.configManager.set("autonomousMode", newAutonomous);
-        responseMessage = newAutonomous ? "\u2705 Autonomous Mode enabled (Silent Operator)\n\nThe AI will now:\n\u2022 Work silently without narrating actions\n\u2022 Use Touch-First safety (never guess file paths)\n\u2022 Apply surgical precision to file edits\n\u2022 Output summary text, then call task_complete() when done\n\u2022 Inject intelligent error recovery hints\n\nThis is the industry-standard autonomous agent mode." : "\u26A0\uFE0F  Autonomous Mode disabled\n\nThe AI will use the standard enhanced prompt with:\n\u2022 Verbose communication after each action\n\u2022 Standard tool descriptions\n\u2022 Manual completion detection";
-        break;
       case "clear":
         const clearCancelMsg = this.cancelWorkflowLearning("Clearing chat session");
         if (clearCancelMsg && this.onDirectMessageCallback) {
@@ -3144,17 +3486,9 @@ Usage: /config set <key> <value>`;
             } catch (error) {
               responseMessage = `\u274C Failed to update configuration: ${error.message}`;
             }
-          } else if (configKey === "enhancedQuality" || configKey === "autonomousMode") {
-            const boolValue = configValue.toLowerCase() === "true" || configValue === "1";
-            try {
-              this.configManager.set(configKey, boolValue);
-              responseMessage = `\u2705 Configuration updated: ${configKey} = ${boolValue}`;
-            } catch (error) {
-              responseMessage = `\u274C Failed to update configuration: ${error.message}`;
-            }
           } else {
             responseMessage = `\u274C Error: Unknown config key: ${configKey}
-Valid keys: model, enhancedQuality, autonomousMode`;
+Valid keys: model`;
           }
         } else {
           const config = this.configManager.load();
@@ -3165,6 +3499,7 @@ Valid keys: model, enhancedQuality, autonomousMode`;
 Version: ${currentVersion}
 Model: ${config.model || "gemini-2.5-flash (default)"}
 AI Auto-Suggest: ${config.aiAutoSuggest === true ? "\u2705 Enabled" : "\u274C Disabled"}
+Limit Chat History: ${config.limitChatHistory !== false ? "\u2705 Enabled" : "\u274C Disabled"}
 Authentication: ${apiClient.isAuthenticated() ? "\u2705 Signed in" : "\u274C Not signed in"}`;
         }
         break;
@@ -3186,8 +3521,84 @@ Authentication: ${apiClient.isAuthenticated() ? "\u2705 Signed in" : "\u274C Not
           } else {
             responseMessage = "\u274C Invalid option. Usage: `/settings auto-suggest on` or `/settings auto-suggest off`";
           }
+        } else if (args.length >= 2 && args[0].toLowerCase() === "limit-chat-history") {
+          const value = args[1].toLowerCase();
+          if (value === "on") {
+            this.configManager.set("limitChatHistory", true);
+            if (this.onLimitChatHistoryChange) {
+              this.onLimitChatHistoryChange(true);
+            }
+            responseMessage = "\u2705 **Chat History Limit Enabled**\n\nThe chat UI will now keep a recent window of rendered chat lines on screen, adjusted to your terminal width and available memory for a cleaner, more compact view.\n\nUse `/settings limit-chat-history off` to show the full UI history again.";
+          } else if (value === "off") {
+            this.configManager.set("limitChatHistory", false);
+            if (this.onLimitChatHistoryChange) {
+              this.onLimitChatHistoryChange(false);
+            }
+            responseMessage = "\u2705 **Chat History Limit Disabled**\n\nThe chat UI will now show the full conversation history on screen.";
+          } else {
+            responseMessage = "\u274C Invalid option. Usage: `/settings limit-chat-history on` or `/settings limit-chat-history off`";
+          }
+        } else if (args.length >= 1 && args[0].toLowerCase() === "add-tunnel-command") {
+          const { TunnelCommandsManager } = await import("./utils/tunnel-commands-manager.js");
+          const tunnelCommandsManager = TunnelCommandsManager.getInstance();
+          await tunnelCommandsManager.initialize();
+          const subArg = args[1]?.toLowerCase();
+          if (!subArg || subArg === "list") {
+            const commands = tunnelCommandsManager.listCommands();
+            if (commands.length === 0) {
+              responseMessage = "\u{1F4CB} No tunnel commands configured.\n\nAdd one with: `/settings add-tunnel-command <command>`\nExample: `/settings add-tunnel-command minicom`\nExample: `/settings add-tunnel-command source .venv/bin/activate`";
+            } else {
+              responseMessage = `\u{1F4CB} Custom Tunnel Commands (${commands.length}):
+
+` + commands.map((cmd2) => `  \u2022 ${cmd2}`).join("\n") + "\n\nUsage:\n  /settings add-tunnel-command <command>\n  /settings add-tunnel-command delete <command>\n  /settings add-tunnel-command list";
+            }
+          } else if (subArg === "delete" || subArg === "remove") {
+            const cmdToDelete = args.slice(2).join(" ").trim();
+            if (!cmdToDelete) {
+              responseMessage = "\u274C Please specify a tunnel command to delete.\n\nUsage: `/settings add-tunnel-command delete <command>`";
+            } else {
+              const result = await tunnelCommandsManager.deleteCommand(cmdToDelete);
+              responseMessage = result.success ? `\u2705 ${result.message}` : `\u274C ${result.message}`;
+            }
+          } else {
+            const commandToAdd = args[1]?.toLowerCase() === "add" ? args.slice(2).join(" ").trim() : args.slice(1).join(" ").trim();
+            if (!commandToAdd) {
+              responseMessage = "\u274C Please specify a tunnel command to add.\n\nUsage: `/settings add-tunnel-command <command>`";
+            } else {
+              const result = await tunnelCommandsManager.addCommand(commandToAdd);
+              if (result.success) {
+                responseMessage = `\u2705 ${result.message}
+
+Run the command in focus mode and press Alt+E (Cmd+E on macOS) to route plain chat input into that running process.`;
+              } else {
+                responseMessage = `\u274C ${result.message}`;
+              }
+            }
+          }
+        } else if (args.length >= 2 && args[0].toLowerCase() === "theme") {
+          const colorName = args[1].toLowerCase();
+          const themeOption = THEME_PALETTE.find((t) => t.name === colorName);
+          if (themeOption) {
+            this.configManager.set("themeColor", themeOption.value);
+            setGlobalAccentColor(themeOption.value);
+            if (this.onThemeColorChange) {
+              this.onThemeColorChange(themeOption.value);
+            }
+            responseMessage = `\u2705 **Theme Updated**
+
+Accent color changed to **${themeOption.label.replace("\u2588\u2588\u2588\u2588  ", "")}** (${themeOption.value}).
+
+The new theme will apply across the UI.`;
+          } else {
+            const validNames = THEME_PALETTE.map((t) => t.name).join(", ");
+            responseMessage = `\u274C Unknown theme color: "${args[1]}"
+
+Available themes: ${validNames}
+
+Usage: \`/settings theme <color>\``;
+          }
         } else {
-          responseMessage = "\u274C Invalid command format.\n\nUsage:\n- `/settings auto-suggest on`\n- `/settings auto-suggest off`";
+          responseMessage = "\u274C Invalid settings command.\n\nAvailable settings:\n\u2022 `/settings auto-suggest on/off`\n\u2022 `/settings limit-chat-history on/off`\n\u2022 `/settings theme <color>`\n\u2022 `/settings add-tunnel-command <command>`";
         }
         break;
       case "model":
@@ -3253,19 +3664,14 @@ Then try /models local again.`;
           if (this.onShowPickerCallback) {
             const config = this.configManager.load();
             const currentModelName = config.modelName || "";
-            const isCurrentCloud = config.isLocalModel !== true;
             const modelsConfig = await fetchModelsConfig();
             this.onShowPickerCallback({
               message: "Select Cloud Model",
               type: "model",
-              choices: modelsConfig.models.map((modelConfig, index) => {
-                const isCurrent = isCurrentCloud && currentModelName === modelConfig.name;
-                return {
-                  label: `${modelConfig.name} - ${modelConfig.description}${isCurrent ? " [CURRENT]" : ""}`,
-                  value: `${index}`
-                  // Use index as unique identifier
-                };
-              })
+              choices: [],
+              // Not used - ModelPicker reads modelConfigs directly
+              modelConfigs: modelsConfig.models,
+              currentModelName
             });
             return;
           }
@@ -3559,6 +3965,109 @@ Restored ${result.restored} files, removed ${result.removed} files.`;
         }
         break;
       }
+      case "sub-agent":
+      case "subagent":
+        if (args.length >= 1 && args[0].toLowerCase() === "list") {
+          const allAgents = SubAgentManager.getAllSubAgents();
+          if (allAgents.length === 0) {
+            responseMessage = "\u{1F4ED} No sub-agents found.\n\nSub-agents are spawned by the AI when working on complex tasks.";
+          } else if (this.onSubAgentListScreenSetup) {
+            const agentList = allAgents.map((a) => ({
+              id: a.id,
+              status: a.status,
+              prompt: a.prompt,
+              model: a.model,
+              startTime: a.startTime,
+              turnCount: a.turnCount,
+              fileOpsCount: a.fileOperations.length
+            }));
+            this.onSubAgentListScreenSetup(agentList);
+            return;
+          }
+        } else if (args.length >= 1 && args[0].toLowerCase() === "terminate") {
+          const runningAgents = SubAgentManager.getRunningSubAgents();
+          if (runningAgents.length === 0) {
+            responseMessage = "\u{1F4ED} No running sub-agents to terminate.";
+          } else if (this.onSubAgentTerminateScreenSetup) {
+            const agentList = runningAgents.map((a) => ({
+              id: a.id,
+              status: a.status,
+              prompt: a.prompt,
+              model: a.model,
+              startTime: a.startTime
+            }));
+            this.onSubAgentTerminateScreenSetup(agentList);
+            return;
+          }
+        } else {
+          responseMessage = "\u274C Invalid sub-agent command.\n\nAvailable commands:\n\u2022 `/sub-agent list` \u2014 View all sub-agents\n\u2022 `/sub-agent terminate` \u2014 Terminate a running sub-agent";
+        }
+        break;
+      case "skill": {
+        const subCmd = args[0]?.toLowerCase();
+        if (!subCmd) {
+          responseMessage = "\u{1F4DA} **Skills**\n\nAvailable commands:\n\u2022 `/skill new` \u2014 Create a new skill\n\u2022 `/skill list` \u2014 List saved skills\n\u2022 `/skill edit <name>` \u2014 Edit a skill\n\u2022 `/skill delete <name>` \u2014 Delete a skill\n\nInvoke a skill: `#<skill-name> <parameters>`";
+          break;
+        }
+        if (subCmd === "new" || subCmd === "add" || subCmd === "create") {
+          if (this.onSkillEditorScreenSetup) {
+            this.onSkillEditorScreenSetup({ mode: "add" });
+            return;
+          }
+          responseMessage = "\u274C Skill editor not available.";
+        } else if (subCmd === "list" || subCmd === "ls") {
+          const skills = skillStorage.list();
+          if (skills.length === 0) {
+            responseMessage = "\u{1F4ED} No skills saved yet.\n\nUse `/skill new` to create your first skill.";
+          } else {
+            const lines = skills.map((s) => {
+              const date = new Date(s.updatedAt).toLocaleDateString("en-US", { month: "short", day: "numeric" });
+              return `\u2022 **${s.name}** (${s.accessLevel}) \u2014 ${s.promptPreview}  _${date}_
+  Invoke: \`#${s.name} <parameters>\``;
+            });
+            responseMessage = `\u{1F4DA} **Saved Skills (${skills.length})**
+
+${lines.join("\n\n")}`;
+          }
+        } else if (subCmd === "edit") {
+          const skillName = args.slice(1).join(" ").trim();
+          if (!skillName) {
+            responseMessage = "\u274C Usage: `/skill edit <name>`";
+            break;
+          }
+          const skill = skillStorage.load(skillName);
+          if (!skill) {
+            responseMessage = `\u274C Skill "${skillName}" not found.
+
+Use \`/skill list\` to see available skills.`;
+            break;
+          }
+          if (this.onSkillEditorScreenSetup) {
+            this.onSkillEditorScreenSetup({ mode: "edit", initialSkill: skill });
+            return;
+          }
+          responseMessage = "\u274C Skill editor not available.";
+        } else if (subCmd === "delete" || subCmd === "rm" || subCmd === "remove") {
+          const skillName = args.slice(1).join(" ").trim();
+          if (!skillName) {
+            responseMessage = "\u274C Usage: `/skill delete <name>`";
+            break;
+          }
+          const result = skillStorage.delete(skillName);
+          if (result.success) {
+            responseMessage = `\u2705 Skill "${skillName}" deleted.`;
+          } else {
+            responseMessage = `\u274C ${result.error}`;
+          }
+        } else {
+          responseMessage = "\u274C Unknown skill subcommand.\n\nUse: `/skill new`, `/skill list`, `/skill edit <name>`, `/skill delete <name>`";
+        }
+        break;
+      }
+      case "compact":
+        await this.forceCompactContext();
+        return;
+      // Don't send a response message — the tool UI element is sufficient
       case "add-command":
       case "add-command-auto-detect":
         const { CustomCommandsManager } = await import("./utils/custom-commands-manager.js");
@@ -3901,9 +4410,7 @@ Usage:
               exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
               config: {
                 model: config.model,
-                modelName: config.modelName,
-                enhancedQuality: config.enhancedQuality,
-                autonomousMode: config.autonomousMode
+                modelName: config.modelName
               },
               chats: fullChats,
               metadata: {
@@ -3950,12 +4457,6 @@ Please try again later.`;
               if (syncData.config.modelName) {
                 currentConfig.modelName = syncData.config.modelName;
               }
-              if (typeof syncData.config.enhancedQuality === "boolean") {
-                currentConfig.enhancedQuality = syncData.config.enhancedQuality;
-              }
-              if (typeof syncData.config.autonomousMode === "boolean") {
-                currentConfig.autonomousMode = syncData.config.autonomousMode;
-              }
               this.configManager.save(currentConfig);
             }
             let restoredChats = 0;
@@ -4339,17 +4840,20 @@ Use /background-task list to see running tasks.`);
   }
   /**
    * Record a user shell command and its output to conversation history
-   * This allows the AI to see what commands the user ran in command mode
+   * This allows the AI to see what commands the user ran in command mode.
+   * Large outputs are truncated using the same head+tail logic as AI tool
+   * outputs, preventing context bloat from user-run commands.
    */
   recordShellCommandToHistory(command, output, cwd, exitCode) {
+    const truncatedOutput = this.truncateResult(output, "user_shell_command");
     const shellCommandInfo = exitCode !== void 0 && exitCode !== 0 ? `[User ran shell command in ${cwd}]
 Command: ${command}
 Exit Code: ${exitCode}
 Output:
-${output}` : `[User ran shell command in ${cwd}]
+${truncatedOutput}` : `[User ran shell command in ${cwd}]
 Command: ${command}
 Output:
-${output || "(no output)"}`;
+${truncatedOutput || "(no output)"}`;
     this.conversationHistory.push({
       role: "user",
       content: shellCommandInfo
@@ -4394,6 +4898,7 @@ ${output || "(no output)"}`;
       thinkingDuration: msg.thinkingDuration,
       taskCompletion: msg.taskCompletion,
       planAccepted: msg.planAccepted,
+      planQuestion: msg.planQuestion,
       connectionStatus: msg.connectionStatus
       // For SSH/WSL/Docker connection status boxes
     }));
@@ -4479,6 +4984,7 @@ ${output || "(no output)"}`;
         thinkingDuration: msg.thinkingDuration,
         taskCompletion: msg.taskCompletion,
         planAccepted: msg.planAccepted,
+        planQuestion: msg.planQuestion,
         connectionStatus: msg.connectionStatus
       }));
     }
@@ -4560,6 +5066,7 @@ ${output || "(no output)"}`;
         thinkingDuration: msg.thinkingDuration,
         taskCompletion: msg.taskCompletion,
         planAccepted: msg.planAccepted,
+        planQuestion: msg.planQuestion,
         connectionStatus: msg.connectionStatus
         // For SSH/WSL/Docker connection status boxes
       }));
@@ -4772,6 +5279,7 @@ You have ${chat.messageCount} messages in AI context. Continue your conversation
     if (this.checkpointManager) {
       this.checkpointManager.setCurrentChatId(null);
     }
+    cleanupOrphanedToolOutputs();
     if (currentContext.type === "local") {
       this.cwdStack = [];
       this.connectionCommandStack = [];
@@ -4842,36 +5350,47 @@ You have ${chat.messageCount} messages in AI context. Continue your conversation
 You are currently in PLAN MODE. In this mode, you MUST:
 
 1. **DO NOT execute any implementation tools** (no write_to_file, edit_file, execute_command, etc.)
-2. **Call the \`create_plan\` tool** to present a structured plan to the user FIRST
-
-### How to Create a Plan:
+2. If the request is ambiguous, use \`plan_ask_question\` to ask 1-2 clarifying questions first
+3. **Call the \`create_plan\` tool** to submit a detailed plan document
 
-Analyze the user's request, then call \`create_plan\` with:
-- A clear title describing what will be accomplished
-- A brief summary of the approach
-- An ordered list of specific, actionable tasks
+### Asking Clarifying Questions:
 
-Example:
+If you need clarification before planning, call \`plan_ask_question\`:
 \`\`\`
-create_plan(
-  title: "Create Python CSV Filter Script",
-  summary: "Build a Python script that reads a CSV file, filters rows based on criteria, and writes output",
-  tasks: [
-    { description: "Create sample input.csv with test data", complexity: "low" },
-    { description: "Write csv_filter.py with read/filter/write logic", complexity: "medium" },
-    { description: "Execute and verify the script works correctly", complexity: "low" }
-  ]
+plan_ask_question(
+  question: "Which authentication approach do you prefer?",
+  options: ["JWT tokens with refresh", "Session-based with Redis", "OAuth2 with third-party provider"]
 )
 \`\`\`
+The user can pick an option, type a custom answer, or skip. Only ask when it would significantly change the plan.
+
+### How to Create a Plan:
+
+Analyze the user's request, explore the codebase, then call \`create_plan\` with:
+- A clear title for the plan
+- A comprehensive markdown document with analysis, tables, and numbered implementation steps
+- An array of implementation step descriptions extracted from the document
 
 ### After Plan Approval:
 
 Once the user approves the plan:
-1. Execute each task in order
-2. After completing each task, call \`mark_task_complete(task_number: N)\`
-3. After all tasks are done, call \`task_complete\` with a summary
+1. Execute each step in order
+2. After completing each step, call \`mark_task_complete(step_number: N)\`
+3. After all steps are done, call \`task_complete\` with a summary
 
-**CRITICAL: In plan mode, ALWAYS call create_plan FIRST before any other tools.**`;
+**CRITICAL: In plan mode, ALWAYS call create_plan FIRST before any implementation tools.**`;
+  }
+  /**
+   * Toggle plan mode on/off (called by Ctrl+P shortcut)
+   */
+  togglePlanMode() {
+    if (this.commandMode) {
+      return;
+    }
+    this.planMode = !this.planMode;
+    if (this.onPlanModeChange) {
+      this.onPlanModeChange(this.planMode);
+    }
   }
   /**
    * Toggle command mode on/off
@@ -5035,6 +5554,7 @@ Once the user approves the plan:
             this.cwd,
             (data) => {
               output += data;
+              if (this.customTunnelCommand) this.tunnelOutputBuffer += data;
               if (this.onToolStreamingOutput) {
                 this.onToolStreamingOutput({ toolName: "execute_command", chunk: data, type: "stdout" });
               }
@@ -5056,6 +5576,14 @@ Once the user approves the plan:
                     result: output || "Command executed successfully",
                     arguments: { command, cwd: this.cwd, remoteContext, commandModeExecution: true }
                   });
+                  const newCwd = resolvePostCommandCwd(this.cwd, command);
+                  if (newCwd && newCwd !== this.cwd) {
+                    this.cwd = newCwd;
+                    this.contextManager.updateWorkingDirectory(newCwd);
+                    if (this.onCwdChange) {
+                      this.onCwdChange(newCwd);
+                    }
+                  }
                 }
               }
               this.recordShellCommandToHistory(command, output, this.cwd, exitCode);
@@ -5075,6 +5603,7 @@ Once the user approves the plan:
             remoteCwd,
             (data) => {
               output += data;
+              if (this.customTunnelCommand) this.tunnelOutputBuffer += data;
               if (this.onToolStreamingOutput) {
                 this.onToolStreamingOutput({ toolName: "execute_command", chunk: data, type: "stdout" });
               }
@@ -5139,6 +5668,7 @@ Once the user approves the plan:
               parentContext.metadata.workingDirectory || "~",
               (data) => {
                 output += data;
+                if (this.customTunnelCommand) this.tunnelOutputBuffer += data;
                 if (this.onToolStreamingOutput) {
                   this.onToolStreamingOutput({ toolName: "execute_command", chunk: data, type: "stdout" });
                 }
@@ -5192,6 +5722,7 @@ Once the user approves the plan:
               remoteCwd,
               (data) => {
                 output += data;
+                if (this.customTunnelCommand) this.tunnelOutputBuffer += data;
                 if (this.onToolStreamingOutput) {
                   this.onToolStreamingOutput({ toolName: "execute_command", chunk: data, type: "stdout" });
                 }
@@ -5252,6 +5783,7 @@ Once the user approves the plan:
             remoteCwd,
             (data) => {
               output += data;
+              if (this.customTunnelCommand) this.tunnelOutputBuffer += data;
               if (this.onToolStreamingOutput) {
                 this.onToolStreamingOutput({ toolName: "execute_command", chunk: data, type: "stdout" });
               }