v1.7.22: Fix append_to_file UI integration, stuck detector, overflow tool stripping, dropped tool status display, HTML escaping in chat

Fix 1: Rewrite _appendToFile() with full UI integration - IPC events (files-changed, agent-file-modified), undo backup, projectPath guard. Add append_to_file to isFileOp and open-file lists in sendToolExecutionEvents.

Fix 2: Change STUCK_THRESHOLD from 2 to 3. Fix paramsHash to include p.content (not just p.text) so append_to_file calls with different content produce different hashes. Apply to both local and cloud paths.

Fix 3: Overflow Step 3 no longer strips ALL tools. Replace buildStaticPrompt('chat') (which returned empty tool list) with preamble + getCompactToolHint('general', {minimal:true}) providing 7 core tools.

Fix 4: Dropped tool calls (write_file with no content) now show 'Skipped - no content provided' instead of false 'Completed OK' checkmark. Applied in both persisted message and inline segment renderers.

Fix 5: Escape HTML tags in markdownInlineToHTML() before markdown processing. Model-generated raw HTML no longer renders as DOM elements in chat.

Author: Brendan Gray

main/agenticChat.js

@@ -108,7 +108,7 @@ function register(ctx) {
   ipcMain.handle('ai-chat', async (_, message, context) => {
     const mainWindow = ctx.getMainWindow();
     const MAX_AGENTIC_ITERATIONS = context?.maxIterations || _readConfig()?.userSettings?.maxAgenticIterations || 100; // Default 100; overridable via Settings UI
-    const STUCK_THRESHOLD = 2; // Same tool+params repeated this many times = stuck
+    const STUCK_THRESHOLD = 3; // Same tool+params repeated this many times = stuck
     const CYCLE_MIN_REPEATS = 3; // A 2-4 tool cycle must repeat this many times to be flagged
     let _completenessCheckedFiles = null; // One-shot guard for post-write completeness checks
 
@@ -518,7 +518,7 @@ function register(ctx) {
             // Enable via Settings → enableLoopDetection: true.
             for (const tr of iterationToolResults) {
               const p = tr.params || {};
-              const paramsHash = `${p.filePath || p.url || p.ref || p.query || p.command || p.selector || ''}:${p.text || ''}`.substring(0, 200);
+              const paramsHash = `${p.filePath || p.dirPath || p.url || p.ref || p.query || p.command || p.selector || ''}:${(p.text || p.content || '').substring(0, 80)}`.substring(0, 200);
               recentCloudToolCalls.push({ tool: tr.tool, paramsHash });
             }
             if (recentCloudToolCalls.length > 20) recentCloudToolCalls = recentCloudToolCalls.slice(-20);
@@ -1182,19 +1182,23 @@ function register(ctx) {
               _ftRetryText = (currentPrompt.systemContext || '') + (currentPrompt.userMessage || '');
               _ftRetryTokens = estimateTokens(_ftRetryText);
             }
-            // Step 3: If still tight after stripping dynamic context, strip tool
-            // descriptions from the static prompt. Better to respond without tools than
-            // to overflow and truncate mid-tool-call.
+            // Step 3: If still tight after stripping dynamic context, use a minimal
+            // tool hint instead of the full tool prompt. The model keeps essential file
+            // tools (write_file, append_to_file, read_file, edit_file, list_directory,
+            // run_command, web_search) but skips browser/memory/planning tools.
             if (totalCtx - _ftRetryTokens < Math.floor(totalCtx * 0.15)) {
+              const minimalToolHint = mcpToolServer.getCompactToolHint('general', { minimal: true });
+              // Build preamble without tools, then append minimal hint
               _staticPromptCache.clear();
+              const preambleOnly = buildStaticPrompt('chat'); // preamble + project instructions, no tools
               currentPrompt = {
-                systemContext: buildStaticPrompt('chat'), // 'chat' skips tool injection
+                systemContext: preambleOnly + '\n' + minimalToolHint + '\n',
                 userMessage: message
               };
               _ftRetryText = (currentPrompt.systemContext || '') + (currentPrompt.userMessage || '');
               _ftRetryTokens = estimateTokens(_ftRetryText);
-              _staticPromptCache.clear(); // Clear so subsequent iterations get tools back
-              console.log(`[AI Chat] Overflow step 3: stripped tools from static prompt, now ~${_ftRetryTokens} tokens`);
+              _staticPromptCache.clear(); // Clear so subsequent iterations get full tools back
+              console.log(`[AI Chat] Overflow step 3: using minimal tool hint, now ~${_ftRetryTokens} tokens`);
             }
             if (totalCtx - _ftRetryTokens < 128) {
               // Still too tight — cap effectiveMaxTokens to whatever room remains
@@ -2459,7 +2463,7 @@ function register(ctx) {
         // STUCK_THRESHOLD=3 consecutive identical calls = stuck.
         for (const tr of toolResults.results) {
           const p = tr.params || {};
-          const paramsHash = `${p.filePath || p.dirPath || p.url || p.ref || p.query || p.command || p.selector || ''}:${p.text || ''}`.substring(0, 200);
+          const paramsHash = `${p.filePath || p.dirPath || p.url || p.ref || p.query || p.command || p.selector || ''}:${(p.text || p.content || '').substring(0, 80)}`.substring(0, 200);
           recentToolCalls.push({ tool: tr.tool, paramsHash });
         }
         if (recentToolCalls.length > 20) recentToolCalls = recentToolCalls.slice(-20);

main/agenticChatHelpers.js

@@ -158,11 +158,11 @@ function sendToolExecutionEvents(mainWindow, toolResults, playwrightBrowser, opt
     if (tr.tool?.startsWith('browser_') && !playwrightBrowser?.isLaunched) {
       mainWindow.webContents.send('show-browser', { url: tr.params?.url || '' });
     }
-    const isFileOp = ['write_file', 'create_directory', 'edit_file', 'delete_file', 'rename_file'].includes(tr.tool);
+    const isFileOp = ['write_file', 'append_to_file', 'create_directory', 'edit_file', 'delete_file', 'rename_file'].includes(tr.tool);
     const passed = checkSuccess ? tr.result?.success : true;
     if (isFileOp && passed) {
       filesChanged = true;
-      if (['write_file', 'edit_file'].includes(tr.tool) && tr.params?.filePath) {
+      if (['write_file', 'append_to_file', 'edit_file'].includes(tr.tool) && tr.params?.filePath) {
         mainWindow.webContents.send('open-file', tr.params.filePath);
       }
     }

main/mcpToolServer.js

@@ -1929,11 +1929,43 @@ class MCPToolServer {
   }
 
   async _appendToFile(filePath, content) {
-    const fullPath = path.isAbsolute(filePath) ? filePath : path.join(this.projectPath || '', filePath);
+    if (!this.projectPath) {
+      return {
+        success: false,
+        error: 'No project folder is open. Please open a folder first (File > Open Folder or Ctrl+K Ctrl+O), then retry.',
+      };
+    }
+    const fullPath = path.isAbsolute(filePath) ? filePath : path.join(this.projectPath, filePath);
     try {
+      // Backup existing content for undo (before append)
+      let isNew = true;
+      try {
+        const existingContent = await fs.readFile(fullPath, 'utf8');
+        this._setFileBackup(fullPath, { original: existingContent, timestamp: Date.now(), tool: 'append_to_file', isNew: false });
+        isNew = false;
+      } catch {
+        this._setFileBackup(fullPath, { original: null, timestamp: Date.now(), tool: 'append_to_file', isNew: true });
+      }
+
       await fs.mkdir(path.dirname(fullPath), { recursive: true });
       await fs.appendFile(fullPath, content, 'utf8');
-      return { success: true, path: fullPath, message: `Appended ${content.length} chars to ${path.basename(fullPath)}` };
+
+      // Read full file content after append for UI notification
+      let fullContent = content;
+      try { fullContent = await fs.readFile(fullPath, 'utf8'); } catch { /* use appended content */ }
+
+      // Notify renderer so file tree refreshes and editor shows changes
+      if (this.browserManager?.parentWindow) {
+        this.browserManager.parentWindow.webContents.send('files-changed');
+        this.browserManager.parentWindow.webContents.send('agent-file-modified', {
+          filePath: fullPath,
+          newContent: fullContent,
+          isNew,
+          tool: 'append_to_file',
+        });
+      }
+
+      return { success: true, path: fullPath, isNew, message: `Appended ${content.length} chars to ${path.basename(fullPath)}` };
     } catch (error) {
       return { success: false, error: error.message };
     }

src/components/Chat/ChatPanel.tsx

@@ -1569,6 +1569,14 @@ ${e.message}`,
                 <CodeBlock code={writeContent} language={writeLang} onApply={() => onApplyCode(currentFile, writeContent)} isToolCall={true} />
               </div>
             );
+          } else if (isWriteTool && !writeContent && !result) {
+            // Write tool was in the response text but had no content and no execution result
+            // — it was dropped by repair (e.g., empty content). Show as skipped, not completed.
+            allToolElements.push(
+              <CollapsibleToolBlock key={`t-${i}`} label={getToolLabel(toolCall, 'fail')} icon="✗">
+                <div className="text-[11px] text-[#858585]">Skipped — no content provided</div>
+              </CollapsibleToolBlock>
+            );
           } else if (result) {
             allToolElements.push(
               <CollapsibleToolBlock key={`t-${i}`} label={getToolLabel(toolCall, result.isOk ? 'ok' : 'fail')} icon={result.isOk ? '✓' : '✗'}>
@@ -1711,6 +1719,12 @@ ${e.message}`,
                     <CodeBlock code={inlineWriteContent} language={inlineWriteLang} onApply={() => onApplyCode(currentFile, inlineWriteContent)} isToolCall={true} />
                   </div>
                 );
+              } else if (isInlineWriteTool && !inlineWriteContent && !result) {
+                allToolElements.push(
+                  <CollapsibleToolBlock key={`inline-${i}-${j}-${allToolElements.length}`} label={getToolLabel(seg.toolCall, 'fail')} icon="✗">
+                    <div className="text-[11px] text-[#858585]">Skipped — no content provided</div>
+                  </CollapsibleToolBlock>
+                );
               } else if (result) {
                 allToolElements.push(
                   <CollapsibleToolBlock key={`inline-${i}-${j}-${allToolElements.length}`} label={getToolLabel(seg.toolCall, result.isOk ? 'ok' : 'fail')} icon={result.isOk ? '✓' : '✗'}>

src/utils/sanitize.ts

@@ -66,7 +66,11 @@ export function markdownInlineToHTML(text: string): string {
   const output: string[] = [];
   let inList = false;
 
-  for (const line of lines) {
+  for (let line of lines) {
+    // Escape raw HTML tags so model output doesn't render as actual DOM elements.
+    // This runs BEFORE markdown processing, so markdown-generated HTML (from
+    // applyInlineMarkdown) is unaffected. Only raw model-output HTML is escaped.
+    line = line.replace(/</g, '&lt;').replace(/>/g, '&gt;');
     if (/^#{4} /.test(line)) {
       if (inList) { output.push('</ul>'); inList = false; }
       output.push(`<h4>${applyInlineMarkdown(line.slice(5))}</h4>`);