@qduc/term2 0.4.0 → 0.6.0

package/dist/tools/search-replace.test.js

@@ -35,68 +35,80 @@ function createTool(settingsService = createMockSettingsService(), editHealing)
         ...(editHealing ? { editHealing } : {}),
     });
 }
-test.serial('needsApproval auto-approves creation when search_content is empty and file is missing in edit mode', async (t) => {
+test.serial('needsApproval auto-approves creation when search_content is empty and file is missing', async (t) => {
     await withTempDir(async () => {
-        const tool = createTool(createMockSettingsService({ app: { editMode: true } }));
+        const tool = createTool(createMockSettingsService());
         const filePath = 'new-file.txt';
         const result = await tool.needsApproval({
             path: filePath,
-            search_content: '',
-            replace_content: 'initial content',
-            replace_all: false,
+            replacements: [
+                {
+                    search_content: '',
+                    replace_content: 'initial content',
+                },
+            ],
         });
         t.false(result);
     });
 });
-test.serial('needsApproval auto-approves a unique exact match in edit mode', async (t) => {
+test.serial('needsApproval auto-approves a unique exact match', async (t) => {
     await withTempDir(async (dir) => {
-        const tool = createTool(createMockSettingsService({ app: { editMode: true } }));
+        const tool = createTool(createMockSettingsService());
         const filePath = 'sample.txt';
         const absPath = path.join(dir, filePath);
         await fs.writeFile(absPath, 'hello world');
         const result = await tool.needsApproval({
             path: filePath,
-            search_content: 'hello',
-            replace_content: 'hi',
-            replace_all: false,
+            replacements: [
+                {
+                    search_content: 'hello',
+                    replace_content: 'hi',
+                },
+            ],
         });
         t.false(result);
     });
 });
-test.serial('needsApproval requires approval when multiple exact matches and replace_all is false', async (t) => {
+test.serial('needsApproval auto-approves when multiple exact matches are found', async (t) => {
     await withTempDir(async (dir) => {
-        const tool = createTool(createMockSettingsService({ app: { editMode: true } }));
+        const tool = createTool(createMockSettingsService());
         const filePath = 'sample.txt';
         const absPath = path.join(dir, filePath);
         await fs.writeFile(absPath, 'hello world hello');
         const result = await tool.needsApproval({
             path: filePath,
-            search_content: 'hello',
-            replace_content: 'hi',
-            replace_all: false,
+            replacements: [
+                {
+                    search_content: 'hello',
+                    replace_content: 'hi',
+                },
+            ],
         });
-        t.true(result);
+        t.false(result);
     });
 });
-test.serial('execute replaces only the first exact match when replace_all is false', async (t) => {
+test.serial('execute replaces only a unique exact match', async (t) => {
     await withTempDir(async (dir) => {
         const tool = createTool();
         const filePath = 'content.txt';
         const absPath = path.join(dir, filePath);
-        await fs.writeFile(absPath, 'target before target after');
+        await fs.writeFile(absPath, 'target before unique after');
         const result = await tool.execute({
             path: filePath,
-            search_content: 'target',
-            replace_content: 'done',
-            replace_all: false,
+            replacements: [
+                {
+                    search_content: 'target',
+                    replace_content: 'done',
+                },
+            ],
         });
         const parsed = JSON.parse(result);
         t.true(parsed.output[0].success);
         const updated = await fs.readFile(absPath, 'utf8');
-        t.is(updated, 'done before target after');
+        t.is(updated, 'done before unique after');
     });
 });
-test.serial('execute replaces all exact matches when replace_all is true', async (t) => {
+test.serial('execute fails when multiple exact matches are found', async (t) => {
     await withTempDir(async (dir) => {
         const tool = createTool();
         const filePath = 'content.txt';
@@ -104,14 +116,18 @@ test.serial('execute replaces all exact matches when replace_all is true', async
         await fs.writeFile(absPath, 'foo foo foo');
         const result = await tool.execute({
             path: filePath,
-            search_content: 'foo',
-            replace_content: 'bar',
-            replace_all: true,
+            replacements: [
+                {
+                    search_content: 'foo',
+                    replace_content: 'bar',
+                },
+            ],
         });
         const parsed = JSON.parse(result);
-        t.true(parsed.output[0].success);
+        t.false(parsed.output[0].success);
+        t.regex(parsed.output[0].error, /Found 3 exact matches/);
         const updated = await fs.readFile(absPath, 'utf8');
-        t.is(updated, 'bar bar bar');
+        t.is(updated, 'foo foo foo');
     });
 });
 test.serial('execute performs relaxed match replacement when exact match is not found', async (t) => {
@@ -122,9 +138,12 @@ test.serial('execute performs relaxed match replacement when exact match is not
         await fs.writeFile(absPath, '    line one\n\tline two\nremainder');
         const result = await tool.execute({
             path: filePath,
-            search_content: 'line one\nline two',
-            replace_content: 'new block\n',
-            replace_all: false,
+            replacements: [
+                {
+                    search_content: 'line one\nline two',
+                    replace_content: 'new block\n',
+                },
+            ],
         });
         const parsed = JSON.parse(result);
         t.true(parsed.output[0].success);
@@ -132,25 +151,7 @@ test.serial('execute performs relaxed match replacement when exact match is not
         t.is(updated, 'new block\nremainder');
     });
 });
-test.serial('execute replaces first of multiple exact matches when replace_all is false', async (t) => {
-    await withTempDir(async (dir) => {
-        const tool = createTool();
-        const filePath = 'content.txt';
-        const absPath = path.join(dir, filePath);
-        await fs.writeFile(absPath, 'foo\nbar\n---\nfoo\nbar\n');
-        const result = await tool.execute({
-            path: filePath,
-            search_content: 'foo\nbar',
-            replace_content: 'replacement',
-            replace_all: false,
-        });
-        const parsed = JSON.parse(result);
-        t.true(parsed.output[0].success);
-        const updated = await fs.readFile(absPath, 'utf8');
-        t.is(updated, 'replacement\n---\nfoo\nbar\n');
-    });
-});
-test.serial('execute rejects multiple relaxed matches when replace_all is false', async (t) => {
+test.serial('execute fails when multiple relaxed matches are found', async (t) => {
     await withTempDir(async (dir) => {
         const tool = createTool();
         const filePath = 'content.txt';
@@ -158,36 +159,20 @@ test.serial('execute rejects multiple relaxed matches when replace_all is false'
         await fs.writeFile(absPath, '  foo  \n\tbar\n---\n  foo  \n\tbar\n');
         const result = await tool.execute({
             path: filePath,
-            search_content: 'foo\nbar',
-            replace_content: 'replacement',
-            replace_all: false,
+            replacements: [
+                {
+                    search_content: 'foo\nbar',
+                    replace_content: 'replacement',
+                },
+            ],
         });
         const parsed = JSON.parse(result);
         t.false(parsed.output[0].success);
-        t.true(parsed.output[0].error.includes('relaxed matches'));
+        t.true(parsed.output[0].error.includes('relaxed matches') || parsed.output[0].error.includes('Found 2 relaxed matches'));
         const unchanged = await fs.readFile(absPath, 'utf8');
         t.is(unchanged, '  foo  \n\tbar\n---\n  foo  \n\tbar\n');
     });
 });
-test.serial('execute replaces all relaxed matches when replace_all is true', async (t) => {
-    await withTempDir(async (dir) => {
-        const tool = createTool(createMockSettingsService({ 'tools.enableEditHealing': false }));
-        const filePath = 'content.txt';
-        const absPath = path.join(dir, filePath);
-        await fs.writeFile(absPath, '  foo  \n\tbar\n---\n  foo  \n\tbar\n');
-        const result = await tool.execute({
-            path: filePath,
-            search_content: 'foo\nbar',
-            replace_content: 'replacement',
-            replace_all: true,
-        });
-        const parsed = JSON.parse(result);
-        t.true(parsed.output[0].success);
-        t.true(parsed.output[0].message.includes('relaxed'));
-        const updated = await fs.readFile(absPath, 'utf8');
-        t.is(updated, 'replacement---\nreplacement');
-    });
-});
 test.serial('execute creates a new file when search_content is empty and file is missing', async (t) => {
     await withTempDir(async (dir) => {
         const tool = createTool();
@@ -195,9 +180,12 @@ test.serial('execute creates a new file when search_content is empty and file is
         const absPath = path.join(dir, filePath);
         const result = await tool.execute({
             path: filePath,
-            search_content: '',
-            replace_content: 'new content',
-            replace_all: false,
+            replacements: [
+                {
+                    search_content: '',
+                    replace_content: 'new content',
+                },
+            ],
         });
         const parsed = JSON.parse(result);
         t.true(parsed.output[0].success);
@@ -210,13 +198,16 @@ test.serial('execute preserves parallel edits to different regions of the same f
         const tool = createTool(createMockSettingsService({ 'tools.enableEditHealing': false }));
         const filePath = 'parallel.txt';
         const absPath = path.join(dir, filePath);
-        const tokens = Array.from({ length: 20 }, (_, index) => `token_${index}`);
+        const tokens = Array.from({ length: 20 }, (_, index) => `token_${String(index).padStart(2, '0')}`);
         await fs.writeFile(absPath, tokens.join('\n'));
         const results = await Promise.all(tokens.map((token, index) => tool.execute({
             path: filePath,
-            search_content: token,
-            replace_content: `done_${index}`,
-            replace_all: false,
+            replacements: [
+                {
+                    search_content: token,
+                    replace_content: `done_${index}`,
+                },
+            ],
         })));
         for (const result of results) {
             const parsed = JSON.parse(result);
@@ -233,18 +224,15 @@ test.serial('execute applies batched replacements to one file with a single resu
         const absPath = path.join(dir, filePath);
         await fs.writeFile(absPath, 'alpha\nbeta\ngamma\n');
         const result = await tool.execute({
+            path: filePath,
             replacements: [
                 {
-                    path: filePath,
                     search_content: 'alpha',
                     replace_content: 'ALPHA',
-                    replace_all: false,
                 },
                 {
-                    path: filePath,
                     search_content: 'gamma',
                     replace_content: 'GAMMA',
-                    replace_all: false,
                 },
             ],
         });
@@ -263,24 +251,19 @@ test.serial('execute keeps successful batched replacements when another replacem
         const originalContent = 'alpha\nbeta\ngamma\n';
         await fs.writeFile(absPath, originalContent);
         const result = await tool.execute({
+            path: filePath,
             replacements: [
                 {
-                    path: filePath,
                     search_content: 'alpha',
                     replace_content: 'ALPHA',
-                    replace_all: false,
                 },
                 {
-                    path: filePath,
                     search_content: 'missing',
                     replace_content: 'MISSING',
-                    replace_all: false,
                 },
                 {
-                    path: filePath,
                     search_content: 'gamma',
                     replace_content: 'GAMMA',
-                    replace_all: false,
                 },
             ],
         });
@@ -301,9 +284,12 @@ test.serial('execute reports failure when search string is not found', async (t)
         await fs.writeFile(absPath, originalContent);
         const result = await tool.execute({
             path: filePath,
-            search_content: 'nonexistent',
-            replace_content: 'replacement',
-            replace_all: false,
+            replacements: [
+                {
+                    search_content: 'nonexistent',
+                    replace_content: 'replacement',
+                },
+            ],
         });
         const parsed = JSON.parse(result);
         t.false(parsed.output[0].success);
@@ -326,9 +312,12 @@ test.serial('execute heals search content when no match is found', async (t) =>
         }));
         const result = await tool.execute({
             path: filePath,
-            search_content: 'const foo = 2;\n',
-            replace_content: 'const foo = 3;\n',
-            replace_all: false,
+            replacements: [
+                {
+                    search_content: 'const foo = 2;\n',
+                    replace_content: 'const foo = 3;\n',
+                },
+            ],
         });
         const parsed = JSON.parse(result);
         t.true(parsed.output[0].success);
@@ -350,9 +339,12 @@ test.serial('execute includes auto-healing failure reason when healing does not
         }));
         const result = await tool.execute({
             path: filePath,
-            search_content: 'const foo = 2;\n',
-            replace_content: 'const foo = 3;\n',
-            replace_all: false,
+            replacements: [
+                {
+                    search_content: 'const foo = 2;\n',
+                    replace_content: 'const foo = 3;\n',
+                },
+            ],
         });
         const parsed = JSON.parse(result);
         t.false(parsed.output[0].success);
@@ -369,9 +361,12 @@ test.serial('execute treats special regex characters literally', async (t) => {
         await fs.writeFile(absPath, originalContent);
         const result = await tool.execute({
             path: filePath,
-            search_content: '[1, 2, 3]',
-            replace_content: '[4, 5, 6]',
-            replace_all: false,
+            replacements: [
+                {
+                    search_content: '[1, 2, 3]',
+                    replace_content: '[4, 5, 6]',
+                },
+            ],
         });
         const parsed = JSON.parse(result);
         t.true(parsed.output[0].success);
@@ -387,9 +382,12 @@ test.serial('execute deletes content when replacement is empty string', async (t
         await fs.writeFile(absPath, 'before DELETE_ME after');
         const result = await tool.execute({
             path: filePath,
-            search_content: 'DELETE_ME ',
-            replace_content: '',
-            replace_all: false,
+            replacements: [
+                {
+                    search_content: 'DELETE_ME ',
+                    replace_content: '',
+                },
+            ],
         });
         const parsed = JSON.parse(result);
         t.true(parsed.output[0].success);
@@ -405,9 +403,12 @@ test.serial('execute performs exact multi-line match without whitespace normaliz
         await fs.writeFile(absPath, 'line one\nline two\nline three');
         const result = await tool.execute({
             path: filePath,
-            search_content: 'line one\nline two',
-            replace_content: 'new content',
-            replace_all: false,
+            replacements: [
+                {
+                    search_content: 'line one\nline two',
+                    replace_content: 'new content',
+                },
+            ],
         });
         const parsed = JSON.parse(result);
         t.true(parsed.output[0].success);
@@ -423,9 +424,12 @@ test.serial('execute handles leading/trailing whitespace differences in relaxed
         await fs.writeFile(absPath, '  foo  \nbar');
         const result = await tool.execute({
             path: filePath,
-            search_content: 'foo\nbar',
-            replace_content: 'replaced',
-            replace_all: false,
+            replacements: [
+                {
+                    search_content: 'foo\nbar',
+                    replace_content: 'replaced',
+                },
+            ],
         });
         const parsed = JSON.parse(result);
         t.true(parsed.output[0].success);
@@ -441,9 +445,12 @@ test.serial('execute performs normalized whitespace match across line breaks', a
         await fs.writeFile(absPath, 'const foo = 1;\nconst bar = 2;\nconst baz = 3;\n');
         const result = await tool.execute({
             path: filePath,
-            search_content: 'const foo = 1; const bar = 2;',
-            replace_content: 'const foo = 1;\nconst bar = 42;',
-            replace_all: false,
+            replacements: [
+                {
+                    search_content: 'const foo = 1; const bar = 2;',
+                    replace_content: 'const foo = 1;\nconst bar = 42;',
+                },
+            ],
         });
         const parsed = JSON.parse(result);
         t.true(parsed.output[0].success);
@@ -451,7 +458,7 @@ test.serial('execute performs normalized whitespace match across line breaks', a
         t.is(updated, 'const foo = 1;\nconst bar = 42;\nconst baz = 3;\n');
     });
 });
-test.serial('execute rejects multiple normalized matches when replace_all is false', async (t) => {
+test.serial('execute rejects multiple normalized matches', async (t) => {
     await withTempDir(async (dir) => {
         const tool = createTool(createMockSettingsService({ 'tools.enableEditHealing': false }));
         const filePath = 'normalized-multi.txt';
@@ -459,9 +466,12 @@ test.serial('execute rejects multiple normalized matches when replace_all is fal
         await fs.writeFile(absPath, 'const foo = 1;\n   const bar = 2;\n---\nconst foo = 1;\tconst bar = 2;\n');
         const result = await tool.execute({
             path: filePath,
-            search_content: 'const foo = 1; const bar = 2;',
-            replace_content: 'const foo = 9; const bar = 9;',
-            replace_all: false,
+            replacements: [
+                {
+                    search_content: 'const foo = 1; const bar = 2;',
+                    replace_content: 'const foo = 9; const bar = 9;',
+                },
+            ],
         });
         const parsed = JSON.parse(result);
         t.false(parsed.output[0].success);
@@ -477,14 +487,14 @@ test.serial('execute does not match substrings in relaxed mode', async (t) => {
         const absPath = path.join(dir, filePath);
         const originalContent = '  formatted text  ';
         await fs.writeFile(absPath, originalContent);
-        // Search for "format" with different whitespace to trigger relaxed mode
-        // Relaxed mode should NOT match because it compares entire trimmed lines,
-        // and "format" (trimmed) !== "formatted text" (trimmed)
         const result = await tool.execute({
             path: filePath,
-            search_content: '    format    ',
-            replace_content: 'replacement',
-            replace_all: false,
+            replacements: [
+                {
+                    search_content: '    format    ',
+                    replace_content: 'replacement',
+                },
+            ],
         });
         const parsed = JSON.parse(result);
         t.false(parsed.output[0].success);
@@ -492,22 +502,20 @@ test.serial('execute does not match substrings in relaxed mode', async (t) => {
         t.is(unchanged, originalContent);
     });
 });
-// ============================================================================
-// EOL Normalization Tests
-// ============================================================================
 test.serial('execute normalizes CRLF search content to match LF file', async (t) => {
     await withTempDir(async (dir) => {
         const tool = createTool();
         const filePath = 'lf-file.txt';
         const absPath = path.join(dir, filePath);
-        // File has LF line endings
         await fs.writeFile(absPath, 'line one\nline two\nline three');
-        // Search content has CRLF line endings
         const result = await tool.execute({
             path: filePath,
-            search_content: 'line one\r\nline two',
-            replace_content: 'replaced',
-            replace_all: false,
+            replacements: [
+                {
+                    search_content: 'line one\r\nline two',
+                    replace_content: 'replaced',
+                },
+            ],
         });
         const parsed = JSON.parse(result);
         t.true(parsed.output[0].success);
@@ -520,19 +528,19 @@ test.serial('execute normalizes LF search content to match CRLF file', async (t)
         const tool = createTool();
         const filePath = 'crlf-file.txt';
         const absPath = path.join(dir, filePath);
-        // File has CRLF line endings
         await fs.writeFile(absPath, 'line one\r\nline two\r\nline three');
-        // Search content has LF line endings
         const result = await tool.execute({
             path: filePath,
-            search_content: 'line one\nline two',
-            replace_content: 'replaced',
-            replace_all: false,
+            replacements: [
+                {
+                    search_content: 'line one\nline two',
+                    replace_content: 'replaced',
+                },
+            ],
         });
         const parsed = JSON.parse(result);
         t.true(parsed.output[0].success);
         const updated = await fs.readFile(absPath, 'utf8');
-        // Result should preserve the file's CRLF style
         t.is(updated, 'replaced\r\nline three');
     });
 });
@@ -541,36 +549,36 @@ test.serial('execute preserves CRLF in replacement content when file uses CRLF',
         const tool = createTool();
         const filePath = 'crlf-file.txt';
         const absPath = path.join(dir, filePath);
-        // File has CRLF line endings
         await fs.writeFile(absPath, 'hello\r\nworld');
         const result = await tool.execute({
             path: filePath,
-            search_content: 'hello',
-            replace_content: 'new\nline', // LF in replacement
-            replace_all: false,
+            replacements: [
+                {
+                    search_content: 'hello',
+                    replace_content: 'new\nline',
+                },
+            ],
         });
         const parsed = JSON.parse(result);
         t.true(parsed.output[0].success);
         const updated = await fs.readFile(absPath, 'utf8');
-        // Replacement should use file's CRLF style
         t.is(updated, 'new\r\nline\r\nworld');
     });
 });
-// ============================================================================
-// Leading Filepath Comment Stripping Tests
-// ============================================================================
 test.serial('execute strips leading filepath comment from search content', async (t) => {
     await withTempDir(async (dir) => {
         const tool = createTool();
         const filePath = 'sample.ts';
         const absPath = path.join(dir, filePath);
         await fs.writeFile(absPath, 'const x = 1;\nconst y = 2;');
-        // Search content has a leading filepath comment (common model behavior)
         const result = await tool.execute({
             path: filePath,
-            search_content: '// sample.ts\nconst x = 1;',
-            replace_content: 'const x = 42;',
-            replace_all: false,
+            replacements: [
+                {
+                    search_content: '// sample.ts\nconst x = 1;',
+                    replace_content: 'const x = 42;',
+                },
+            ],
         });
         const parsed = JSON.parse(result);
         t.true(parsed.output[0].success);
@@ -586,9 +594,12 @@ test.serial('execute strips leading hash filepath comment from search content',
         await fs.writeFile(absPath, 'x = 1\ny = 2');
         const result = await tool.execute({
             path: filePath,
-            search_content: '# script.py\nx = 1',
-            replace_content: 'x = 42',
-            replace_all: false,
+            replacements: [
+                {
+                    search_content: '# script.py\nx = 1',
+                    replace_content: 'x = 42',
+                },
+            ],
         });
         const parsed = JSON.parse(result);
         t.true(parsed.output[0].success);
@@ -602,12 +613,14 @@ test.serial('execute does not strip non-filepath leading comments', async (t) =>
         const filePath = 'code.ts';
         const absPath = path.join(dir, filePath);
         await fs.writeFile(absPath, '// TODO: fix this\nconst x = 1;');
-        // This comment is not a filepath, so it should NOT be stripped
         const result = await tool.execute({
             path: filePath,
-            search_content: '// TODO: fix this\nconst x = 1;',
-            replace_content: 'const x = 42;',
-            replace_all: false,
+            replacements: [
+                {
+                    search_content: '// TODO: fix this\nconst x = 1;',
+                    replace_content: 'const x = 42;',
+                },
+            ],
         });
         const parsed = JSON.parse(result);
         t.true(parsed.output[0].success);
@@ -615,9 +628,6 @@ test.serial('execute does not strip non-filepath leading comments', async (t) =>
         t.is(updated, 'const x = 42;');
     });
 });
-// ============================================================================
-// Summarization Marker Detection Tests
-// ============================================================================
 test.serial('execute rejects search content with "Lines X-Y omitted" marker', async (t) => {
     await withTempDir(async (dir) => {
         const tool = createTool();
@@ -626,9 +636,12 @@ test.serial('execute rejects search content with "Lines X-Y omitted" marker', as
         await fs.writeFile(absPath, 'line 1\nline 2\nline 3');
         const result = await tool.execute({
             path: filePath,
-            search_content: 'line 1\nLines 2-50 omitted\nline 3',
-            replace_content: 'replaced',
-            replace_all: false,
+            replacements: [
+                {
+                    search_content: 'line 1\nLines 2-50 omitted\nline 3',
+                    replace_content: 'replaced',
+                },
+            ],
         });
         const parsed = JSON.parse(result);
         t.false(parsed.output[0].success);
@@ -643,9 +656,12 @@ test.serial('execute rejects search content with ellipsis marker {…}', async (
         await fs.writeFile(absPath, 'function foo() { /* code */ }');
         const result = await tool.execute({
             path: filePath,
-            search_content: 'function foo() {…}',
-            replace_content: 'replaced',
-            replace_all: false,
+            replacements: [
+                {
+                    search_content: 'function foo() {…}',
+                    replace_content: 'replaced',
+                },
+            ],
         });
         const parsed = JSON.parse(result);
         t.false(parsed.output[0].success);
@@ -660,9 +676,12 @@ test.serial('execute rejects search content with /*...*/ marker', async (t) => {
         await fs.writeFile(absPath, 'function foo() { return 1; }');
         const result = await tool.execute({
             path: filePath,
-            search_content: 'function foo() { /*...*/ }',
-            replace_content: 'replaced',
-            replace_all: false,
+            replacements: [
+                {
+                    search_content: 'function foo() { /*...*/ }',
+                    replace_content: 'replaced',
+                },
+            ],
         });
         const parsed = JSON.parse(result);
         t.false(parsed.output[0].success);
@@ -677,18 +696,56 @@ test.serial('execute rejects search content with // ... marker', async (t) => {
         await fs.writeFile(absPath, 'const a = 1;\nconst b = 2;\nconst c = 3;');
         const result = await tool.execute({
             path: filePath,
-            search_content: 'const a = 1;\n// ...\nconst c = 3;',
-            replace_content: 'replaced',
-            replace_all: false,
+            replacements: [
+                {
+                    search_content: 'const a = 1;\n// ...\nconst c = 3;',
+                    replace_content: 'replaced',
+                },
+            ],
         });
         const parsed = JSON.parse(result);
         t.false(parsed.output[0].success);
         t.true(parsed.output[0].error.includes('// ...'));
     });
 });
-// ============================================================================
-// Gap Matching Tests (<...> marker)
-// ============================================================================
+test.serial('execute rejects search content when search and replace content are identical', async (t) => {
+    await withTempDir(async (dir) => {
+        const tool = createTool();
+        const filePath = 'content.txt';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, 'hello world');
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'hello',
+                    replace_content: 'hello',
+                },
+            ],
+        });
+        const parsed = JSON.parse(result);
+        t.false(parsed.output[0].success);
+        t.regex(parsed.output[0].error, /identical/i);
+    });
+});
+test.serial('needsApproval auto-approves when search and replace content are identical', async (t) => {
+    await withTempDir(async (dir) => {
+        const tool = createTool();
+        const filePath = 'content.txt';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, 'hello world');
+        const result = await tool.needsApproval({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'hello',
+                    replace_content: 'hello',
+                },
+            ],
+        });
+        t.false(result);
+    });
+});
 test.serial('execute performs gap match: head <...> tail replaces entire region', async (t) => {
     await withTempDir(async (dir) => {
         const tool = createTool(createMockSettingsService({ 'tools.enableEditHealing': false }));
@@ -697,9 +754,12 @@ test.serial('execute performs gap match: head <...> tail replaces entire region'
         await fs.writeFile(absPath, 'function foo() {\n  const x = 1;\n  const y = 2;\n  const z = 3;\n  return x + y + z;\n}\n');
         const result = await tool.execute({
             path: filePath,
-            search_content: 'function foo() {\n  const x = 1;\n<...>\n  return x + y + z;\n}',
-            replace_content: 'function foo() {\n  return 6;\n}\n',
-            replace_all: false,
+            replacements: [
+                {
+                    search_content: 'function foo() {\n  const x = 1;\n<...>\n  return x + y + z;\n}',
+                    replace_content: 'function foo() {\n  return 6;\n}\n',
+                },
+            ],
         });
         const parsed = JSON.parse(result);
         t.true(parsed.output[0].success);
@@ -716,9 +776,12 @@ test.serial('execute performs gap match with single-line head and tail', async (
         await fs.writeFile(absPath, 'start\nmiddle1\nmiddle2\nend\nafter');
         const result = await tool.execute({
             path: filePath,
-            search_content: 'start\n<...>\nend',
-            replace_content: 'replaced\n',
-            replace_all: false,
+            replacements: [
+                {
+                    search_content: 'start\n<...>\nend',
+                    replace_content: 'replaced\n',
+                },
+            ],
         });
         const parsed = JSON.parse(result);
         t.true(parsed.output[0].success);
@@ -734,9 +797,12 @@ test.serial('execute performs gap match with adjacent head and tail (no actual g
         await fs.writeFile(absPath, 'line1\nline2\nline3');
         const result = await tool.execute({
             path: filePath,
-            search_content: 'line1\n<...>\nline2',
-            replace_content: 'replaced\n',
-            replace_all: false,
+            replacements: [
+                {
+                    search_content: 'line1\n<...>\nline2',
+                    replace_content: 'replaced\n',
+                },
+            ],
         });
         const parsed = JSON.parse(result);
         t.true(parsed.output[0].success);
@@ -752,9 +818,12 @@ test.serial('execute performs gap match with multiple <...> markers', async (t)
         await fs.writeFile(absPath, 'function a() {\n  body1;\n}\nfunction b() {\n  body2;\n}\nfunction c() {\n  body3;\n}\n');
         const result = await tool.execute({
             path: filePath,
-            search_content: 'function a() {\n<...>\nfunction b() {\n<...>\nfunction c() {\n  body3;\n}',
-            replace_content: 'function abc() {\n  combined;\n}\n',
-            replace_all: false,
+            replacements: [
+                {
+                    search_content: 'function a() {\n<...>\nfunction b() {\n<...>\nfunction c() {\n  body3;\n}',
+                    replace_content: 'function abc() {\n  combined;\n}\n',
+                },
+            ],
         });
         const parsed = JSON.parse(result);
         t.true(parsed.output[0].success);
@@ -770,9 +839,12 @@ test.serial('execute gap match fails when head is not found', async (t) => {
         await fs.writeFile(absPath, 'line1\nline2\nline3');
         const result = await tool.execute({
             path: filePath,
-            search_content: 'nonexistent\n<...>\nline3',
-            replace_content: 'replaced',
-            replace_all: false,
+            replacements: [
+                {
+                    search_content: 'nonexistent\n<...>\nline3',
+                    replace_content: 'replaced',
+                },
+            ],
         });
         const parsed = JSON.parse(result);
         t.false(parsed.output[0].success);
@@ -786,32 +858,66 @@ test.serial('execute gap match fails when tail is not found after head', async (
         await fs.writeFile(absPath, 'line1\nline2\nline3');
         const result = await tool.execute({
             path: filePath,
-            search_content: 'line1\n<...>\nnonexistent',
-            replace_content: 'replaced',
-            replace_all: false,
+            replacements: [
+                {
+                    search_content: 'line1\n<...>\nnonexistent',
+                    replace_content: 'replaced',
+                },
+            ],
         });
         const parsed = JSON.parse(result);
         t.false(parsed.output[0].success);
     });
 });
-test.serial('execute gap match rejects multiple matches when replace_all is false', async (t) => {
+test.serial('execute does not invoke healing for a failed gap pattern and reports a head-anchor diagnostic', async (t) => {
     await withTempDir(async (dir) => {
-        const tool = createTool(createMockSettingsService({ 'tools.enableEditHealing': false }));
+        let healingCalls = 0;
+        const tool = createTool(createMockSettingsService({ 'tools.enableEditHealing': true }), async (params) => {
+            healingCalls++;
+            return { params, wasModified: false, confidence: 0 };
+        });
         const filePath = 'content.txt';
-        const absPath = path.join(dir, filePath);
-        await fs.writeFile(absPath, 'start\nmiddle1\nend\nstart\nmiddle2\nend\n');
+        await fs.writeFile(path.join(dir, filePath), 'line1\nline2\nline3');
         const result = await tool.execute({
             path: filePath,
-            search_content: 'start\n<...>\nend',
-            replace_content: 'replaced',
-            replace_all: false,
+            replacements: [
+                {
+                    search_content: 'nonexistent\n<...>\nline3',
+                    replace_content: 'replaced',
+                },
+            ],
         });
         const parsed = JSON.parse(result);
         t.false(parsed.output[0].success);
-        t.true(parsed.output[0].error.includes('gap'));
+        t.is(healingCalls, 0);
+        t.regex(parsed.output[0].error, /head anchor/i);
+        t.regex(parsed.output[0].error, /not auto-healed/i);
     });
 });
-test.serial('execute gap match replaces all when replace_all is true', async (t) => {
+test.serial('execute gap diagnostic identifies the anchor that failed after the head matched', async (t) => {
+    await withTempDir(async (dir) => {
+        const tool = createTool(createMockSettingsService({ 'tools.enableEditHealing': true }), async (params) => ({
+            params,
+            wasModified: false,
+            confidence: 0,
+        }));
+        const filePath = 'content.txt';
+        await fs.writeFile(path.join(dir, filePath), 'line1\nline2\nline3');
+        const result = await tool.execute({
+            path: filePath,
+            replacements: [
+                {
+                    search_content: 'line1\n<...>\nnonexistent',
+                    replace_content: 'replaced',
+                },
+            ],
+        });
+        const parsed = JSON.parse(result);
+        t.false(parsed.output[0].success);
+        t.regex(parsed.output[0].error, /not found after/i);
+    });
+});
+test.serial('execute gap match rejects multiple matches', async (t) => {
     await withTempDir(async (dir) => {
         const tool = createTool(createMockSettingsService({ 'tools.enableEditHealing': false }));
         const filePath = 'content.txt';
@@ -819,14 +925,16 @@ test.serial('execute gap match replaces all when replace_all is true', async (t)
         await fs.writeFile(absPath, 'start\nmiddle1\nend\nstart\nmiddle2\nend\n');
         const result = await tool.execute({
             path: filePath,
-            search_content: 'start\n<...>\nend',
-            replace_content: 'replaced\n',
-            replace_all: true,
+            replacements: [
+                {
+                    search_content: 'start\n<...>\nend',
+                    replace_content: 'replaced',
+                },
+            ],
         });
         const parsed = JSON.parse(result);
-        t.true(parsed.output[0].success);
-        const updated = await fs.readFile(absPath, 'utf8');
-        t.is(updated, 'replaced\nreplaced\n');
+        t.false(parsed.output[0].success);
+        t.true(parsed.output[0].error.includes('gap'));
     });
 });
 test.serial('execute gap match works with relaxed whitespace matching in segments', async (t) => {
@@ -837,9 +945,12 @@ test.serial('execute gap match works with relaxed whitespace matching in segment
         await fs.writeFile(absPath, '  function foo() {\n  const x = 1;\n  const y = 2;\n  return x;\n  }\n');
         const result = await tool.execute({
             path: filePath,
-            search_content: 'function foo() {\n<...>\nreturn x;\n}',
-            replace_content: 'function foo() {\n  return 42;\n}\n',
-            replace_all: false,
+            replacements: [
+                {
+                    search_content: 'function foo() {\n<...>\nreturn x;\n}',
+                    replace_content: 'function foo() {\n  return 42;\n}\n',
+                },
+            ],
         });
         const parsed = JSON.parse(result);
         t.true(parsed.output[0].success);
@@ -847,19 +958,21 @@ test.serial('execute gap match works with relaxed whitespace matching in segment
         t.is(updated, 'function foo() {\n  return 42;\n}\n');
     });
 });
-test.serial('needsApproval handles gap match in edit mode', async (t) => {
+test.serial('needsApproval handles gap match', async (t) => {
     await withTempDir(async (dir) => {
-        const tool = createTool(createMockSettingsService({ app: { editMode: true } }));
+        const tool = createTool(createMockSettingsService());
         const filePath = 'content.txt';
         const absPath = path.join(dir, filePath);
         await fs.writeFile(absPath, 'start\nmiddle\nend\n');
         const result = await tool.needsApproval({
             path: filePath,
-            search_content: 'start\n<...>\nend',
-            replace_content: 'replaced',
-            replace_all: false,
+            replacements: [
+                {
+                    search_content: 'start\n<...>\nend',
+                    replace_content: 'replaced',
+                },
+            ],
         });
-        // In edit mode with a unique gap match, should auto-approve
         t.false(result);
     });
 });