🤖 fix: prevent double newlines in file_edit_insert tool (#480)

## Problem

The `file_edit_insert` tool was adding an extra newline when content
already ended with `\n`, causing failures on simple tasks like
terminal-bench's `hello-world` where file content precision matters.

**Example failure:**
- Task: Create `hello.txt` with `"Hello, world!\n"`
- Agent: `file_edit_insert(content="Hello, world!\n")`
- Result: File contains `"Hello, world!\n\n"` (double newline!)
- Test: ❌ FAILED - Expected exactly one newline

## Root Cause

The tool's implementation (lines 96-97):
```typescript
const newLines = [...lines.slice(0, line_offset), content, ...lines.slice(line_offset)];
const newContent = newLines.join("\n");
```

When content is inserted as an array element and joined with `"\n"`, it
always gets a trailing newline. When content already includes `"\n"`,
this produces double newlines.

The tool was **designed** to add a trailing newline, but this behavior
was:
1. Undocumented in the tool description
2. Unexpected by the agent (naturally includes `\n` when instructed to
"make sure it ends in a newline")
3. Causing subtle bugs where exact file content matters

## Solution

**Smart newline detection** - If content already ends with `\n`, strip
it before joining to prevent doubling:

```typescript
const contentEndsWithNewline = content.endsWith("\n");
const normalizedContent = contentEndsWithNewline ? content.slice(0, -1) : content;
```

This matches the agent's natural expectation - if they explicitly add
`\n`, it should be preserved as-is without doubling.

## Testing

Added 2 regression tests:
- ✅ Content with trailing newline (the hello-world case)
- ✅ Multiline content with trailing newline

All 14 tests pass (12 existing + 2 new).

## Impact

**Estimated:** +5-10% accuracy on terminal-bench tasks

**Direct fixes:**
- hello-world task (was failing 1/2 tests, now should pass both)
- Likely fixes other tasks where exact file content matters

**Indirect improvements:**
- Agent won't avoid tool after encountering unexpected behavior
- Fewer edge case bugs in config files, data formats, etc.

## Analysis Source

Full analysis:
[terminal-bench-results/analysis_run_18894357631.md](https://github.com/coder/cmux/blob/tb-baseline/terminal-bench-results/analysis_run_18894357631.md)

From run 18894357631:
- 40% accuracy (16/40 tasks)
- This bug identified as Priority 1 critical issue
- Several other tasks showed partial failures (5/7 tests, 4/5 tests)
that may also benefit from this fix

_Generated with `cmux`_

Author: ammar-agent

src/services/tools/file_edit_insert.test.ts

@@ -329,4 +329,77 @@ describe("file_edit_insert tool", () => {
       expect(result.error).toContain("beyond file length");
     }
   });
+
+  it("should handle content with trailing newline correctly (no double newlines)", async () => {
+    // This test verifies the fix for the terminal-bench "hello-world" bug
+    // where content with \n at the end was getting an extra newline added
+    using testEnv = createTestFileEditInsertTool({ cwd: testDir });
+    const tool = testEnv.tool;
+    const args: FileEditInsertToolArgs = {
+      file_path: "newfile.txt",
+      line_offset: 0,
+      content: "Hello, world!\n", // Content already has trailing newline
+      create: true,
+    };
+
+    // Execute
+    const result = (await tool.execute!(args, mockToolCallOptions)) as FileEditInsertToolResult;
+
+    // Assert
+    expect(result.success).toBe(true);
+
+    const fileContent = await fs.readFile(path.join(testDir, "newfile.txt"), "utf-8");
+    // Should NOT have double newline - the trailing \n in content should be preserved as-is
+    expect(fileContent).toBe("Hello, world!\n");
+    expect(fileContent).not.toBe("Hello, world!\n\n");
+  });
+
+  it("should handle multiline content with trailing newline", async () => {
+    // Setup
+    const initialContent = "line1\nline2";
+    await fs.writeFile(testFilePath, initialContent);
+
+    using testEnv = createTestFileEditInsertTool({ cwd: testDir });
+    const tool = testEnv.tool;
+    const args: FileEditInsertToolArgs = {
+      file_path: "test.txt",
+      line_offset: 1,
+      content: "INSERTED1\nINSERTED2\n", // Multiline with trailing newline
+    };
+
+    // Execute
+    const result = (await tool.execute!(args, mockToolCallOptions)) as FileEditInsertToolResult;
+
+    // Assert
+    expect(result.success).toBe(true);
+
+    const updatedContent = await fs.readFile(testFilePath, "utf-8");
+    // Should respect the trailing newline in content
+    expect(updatedContent).toBe("line1\nINSERTED1\nINSERTED2\nline2");
+  });
+
+  it("should preserve trailing newline when appending to file without trailing newline", async () => {
+    // Regression test for Codex feedback: when inserting at EOF with content ending in \n,
+    // the newline should be preserved even if the original file doesn't end with one
+    const initialContent = "line1\nline2"; // No trailing newline
+    await fs.writeFile(testFilePath, initialContent);
+
+    using testEnv = createTestFileEditInsertTool({ cwd: testDir });
+    const tool = testEnv.tool;
+    const args: FileEditInsertToolArgs = {
+      file_path: "test.txt",
+      line_offset: 2, // Append at end
+      content: "line3\n", // With trailing newline
+    };
+
+    // Execute
+    const result = (await tool.execute!(args, mockToolCallOptions)) as FileEditInsertToolResult;
+
+    // Assert
+    expect(result.success).toBe(true);
+
+    const updatedContent = await fs.readFile(testFilePath, "utf-8");
+    // Should preserve the trailing newline from content even at EOF
+    expect(updatedContent).toBe("line1\nline2\nline3\n");
+  });
 });

src/services/tools/file_edit_insert.ts

@@ -93,7 +93,20 @@ export const createFileEditInsertTool: ToolFactory = (config: ToolConfiguration)
               };
             }
 
-            const newLines = [...lines.slice(0, line_offset), content, ...lines.slice(line_offset)];
+            // Handle newline behavior:
+            // - If content ends with \n and we're not at EOF, strip it (join will add it back)
+            // - If content ends with \n and we're at EOF, keep it (join won't add trailing newline)
+            // - If content doesn't end with \n, keep as-is (join will add newlines between lines)
+            const contentEndsWithNewline = content.endsWith("\n");
+            const insertingAtEnd = line_offset === lines.length;
+            const shouldStripTrailingNewline = contentEndsWithNewline && !insertingAtEnd;
+            const normalizedContent = shouldStripTrailingNewline ? content.slice(0, -1) : content;
+
+            const newLines = [
+              ...lines.slice(0, line_offset),
+              normalizedContent,
+              ...lines.slice(line_offset),
+            ];
             const newContent = newLines.join("\n");
 
             return {