fix(core-tools): show ellipsis on multi-line edit snippets

packages/core/src/tools/edit.test.ts

@@ -84,7 +84,13 @@ describe('EditTool', () => {
 
   beforeEach(() => {
     vi.restoreAllMocks();
-    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'edit-tool-test-'));
+    // Tools resolve file paths via fs.realpathSync, so on macOS the temp dir
+    // under `/var/...` resolves to `/private/var/...`. Canonicalize the temp
+    // root up front so paths line up across config, mock workspace, and any
+    // sub-directories tests derive (e.g. project temp dir, plans dir).
+    tempDir = fs.realpathSync(
+      fs.mkdtempSync(path.join(os.tmpdir(), 'edit-tool-test-')),
+    );
     rootDir = path.join(tempDir, 'root');
     fs.mkdirSync(rootDir);
 
@@ -1409,4 +1415,112 @@ function doIt() {
       fs.rmSync(plansDir, { recursive: true, force: true });
     });
   });
+
+  describe('getDescription', () => {
+    const testFile = 'describe_me.txt';
+    let filePath: string;
+
+    beforeEach(() => {
+      filePath = path.join(rootDir, testFile);
+    });
+
+    it("returns 'Create <path>' when old_string is empty", () => {
+      const params: EditToolParams = {
+        file_path: filePath,
+        instruction: 'Create file',
+        old_string: '',
+        new_string: 'hello',
+      };
+      expect(tool.build(params).getDescription()).toBe(`Create ${testFile}`);
+    });
+
+    it('returns no-change message when old_string equals new_string', () => {
+      const params: EditToolParams = {
+        file_path: filePath,
+        instruction: 'No-op',
+        old_string: 'same',
+        new_string: 'same',
+      };
+      expect(tool.build(params).getDescription()).toBe(
+        `No file changes to ${testFile}`,
+      );
+    });
+
+    it('does not append ellipsis to single-line strings within the snippet limit', () => {
+      const params: EditToolParams = {
+        file_path: filePath,
+        instruction: 'Short replace',
+        old_string: 'short old',
+        new_string: 'short new',
+      };
+      expect(tool.build(params).getDescription()).toBe(
+        `${testFile}: short old => short new`,
+      );
+    });
+
+    it('does not append ellipsis when the first line is exactly the snippet limit', () => {
+      const exact = 'a'.repeat(30);
+      const params: EditToolParams = {
+        file_path: filePath,
+        instruction: 'Boundary replace',
+        old_string: exact,
+        new_string: exact + 'b',
+      };
+      expect(tool.build(params).getDescription()).toBe(
+        `${testFile}: ${exact} => ${exact}...`,
+      );
+    });
+
+    it('appends ellipsis when a single-line string exceeds the snippet limit', () => {
+      const longOld = 'a'.repeat(35);
+      const longNew = 'b'.repeat(40);
+      const params: EditToolParams = {
+        file_path: filePath,
+        instruction: 'Long replace',
+        old_string: longOld,
+        new_string: longNew,
+      };
+      expect(tool.build(params).getDescription()).toBe(
+        `${testFile}: ${'a'.repeat(30)}... => ${'b'.repeat(30)}...`,
+      );
+    });
+
+    // Regression for #28110 and #28109: when an edit spans multiple lines but the
+    // first line is short, the snippet should still signal hidden content with `...`.
+    it('appends ellipsis to multi-line edits whose first line is short', () => {
+      const oldStr = 'function foo() {\n  return 1;\n}';
+      const newStr = 'function foo() {\n  return 2;\n}';
+      const params: EditToolParams = {
+        file_path: filePath,
+        instruction: 'Multi-line replace with short first line',
+        old_string: oldStr,
+        new_string: newStr,
+      };
+      expect(tool.build(params).getDescription()).toBe(
+        `${testFile}: function foo() {... => function foo() {...`,
+      );
+    });
+
+    it('appends ellipsis to multi-line edits with very short first lines', () => {
+      const params: EditToolParams = {
+        file_path: filePath,
+        instruction: 'Tiny multi-line',
+        old_string: 'a\nb\nc',
+        new_string: 'x\ny\nz',
+      };
+      expect(tool.build(params).getDescription()).toBe(
+        `${testFile}: a... => x...`,
+      );
+    });
+
+    it('emits an empty snippet without ellipsis when deleting to empty', () => {
+      const params: EditToolParams = {
+        file_path: filePath,
+        instruction: 'Delete content',
+        old_string: 'a\nb\nc',
+        new_string: '',
+      };
+      expect(tool.build(params).getDescription()).toBe(`${testFile}: a... => `);
+    });
+  });
 });

packages/core/src/tools/edit.ts

@@ -837,12 +837,15 @@ class EditToolInvocation
       return `Create ${shortenPath(relativePath)}`;
     }
 
-    const oldStringSnippet =
-      this.params.old_string.split('\n')[0].substring(0, 30) +
-      (this.params.old_string.length > 30 ? '...' : '');
-    const newStringSnippet =
-      this.params.new_string.split('\n')[0].substring(0, 30) +
-      (this.params.new_string.length > 30 ? '...' : '');
+    // Append `...` when the snippet hides content from the user: the first
+    // line was truncated, or there are additional lines below it.
+    const snippet = (s: string) => {
+      const firstLine = s.split('\n')[0];
+      const hasHiddenContent = firstLine.length > 30 || s.includes('\n');
+      return firstLine.substring(0, 30) + (hasHiddenContent ? '...' : '');
+    };
+    const oldStringSnippet = snippet(this.params.old_string);
+    const newStringSnippet = snippet(this.params.new_string);
 
     if (this.params.old_string === this.params.new_string) {
       return `No file changes to ${shortenPath(relativePath)}`;