lonny-agent 0.1.9 → 0.2.2

package/src/config/__tests__/context-window.test.ts

@@ -0,0 +1,94 @@
+import { describe, expect, test } from 'vitest'
+import { getContextWindowForModel } from '../index.js'
+
+describe('getContextWindowForModel', () => {
+  // 精确匹配测试
+  test('exact match with known model names', () => {
+    expect(getContextWindowForModel('doubao-seed-2.0-code')).toBe(256_000)
+    expect(getContextWindowForModel('deepseek-v4-pro')).toBe(1_000_000)
+    expect(getContextWindowForModel('qwen3.6-plus')).toBe(1_000_000)
+    expect(getContextWindowForModel('claude-sonnet-4.6')).toBe(1_000_000)
+    expect(getContextWindowForModel('gpt-5.5')).toBe(1_000_000)
+  })
+
+  // 大小写不敏感测试
+  test('case insensitive matching', () => {
+    expect(getContextWindowForModel('DOUBAO-SEED-2.0-CODE')).toBe(256_000)
+    expect(getContextWindowForModel('DeepSeek-V4-Pro')).toBe(1_000_000)
+    expect(getContextWindowForModel('QWEN3.6-PLUS')).toBe(1_000_000)
+  })
+
+  // 模糊匹配 - 含空格的变体
+  test('fuzzy match with space variants', () => {
+    expect(getContextWindowForModel('doubao seed 2.0 code')).toBe(256_000)
+    expect(getContextWindowForModel('deepseek v4 pro')).toBe(1_000_000)
+    expect(getContextWindowForModel('qwen 3.6 plus')).toBe(1_000_000)
+  })
+
+  // 模糊匹配 - 下划线与连字符变体
+  test('fuzzy match with underscore and hyphen variants', () => {
+    expect(getContextWindowForModel('doubao_seed_2.0_code')).toBe(256_000)
+    expect(getContextWindowForModel('deepseek_v4_pro')).toBe(1_000_000)
+  })
+
+  // 模糊匹配 - 含前缀和后缀的模型名
+  test('fuzzy match with prefixed and suffixed model names', () => {
+    expect(getContextWindowForModel('my-doubao-seed-2.0-code')).toBe(256_000)
+    expect(getContextWindowForModel('deepseek-v4-pro-variant')).toBe(1_000_000)
+    expect(getContextWindowForModel('qwen3.6-plus-prod')).toBe(1_000_000)
+  })
+
+  // 模糊匹配 - 关键词匹配（不完整的模型名）
+  test('fuzzy match with keyword matching (partial model names)', () => {
+    // 百万上下文模型
+    expect(getContextWindowForModel('deepseek-v4')).toBe(1_000_000)
+    expect(getContextWindowForModel('qwen3.6')).toBe(1_000_000)
+    expect(getContextWindowForModel('qwen3.7')).toBe(1_000_000)
+    expect(getContextWindowForModel('claude opus 4.7')).toBe(1_000_000)
+    expect(getContextWindowForModel('gemini 2.5')).toBe(1_000_000)
+
+    // 256K 上下文模型
+    expect(getContextWindowForModel('doubao-seed-2.0')).toBe(256_000)
+    expect(getContextWindowForModel('kimi-k2.5')).toBe(262_144) // 实际值
+    expect(getContextWindowForModel('kimi-k2.6')).toBe(262_144) // 实际值
+
+    // 200K 上下文模型
+    expect(getContextWindowForModel('minimax')).toBe(200_000)
+    expect(getContextWindowForModel('glm-5')).toBe(200_000)
+    expect(getContextWindowForModel('glm-5.1')).toBe(200_000)
+    expect(getContextWindowForModel('claude-haiku')).toBe(200_000)
+
+    // 160K 上下文模型
+    expect(getContextWindowForModel('deepseek-v3')).toBe(160_000)
+    expect(getContextWindowForModel('deepseek-v3.2')).toBe(160_000)
+
+    // 128K 上下文模型
+    expect(getContextWindowForModel('gpt-4o')).toBe(128_000)
+    expect(getContextWindowForModel('gpt-4')).toBe(128_000)
+    expect(getContextWindowForModel('llama-3')).toBe(128_000)
+  })
+
+  // 未知模型名 - 兜底默认值
+  test('unknown model names return default 128K', () => {
+    expect(getContextWindowForModel('unknown-model')).toBe(128_000)
+    expect(getContextWindowForModel('random-model-name')).toBe(128_000)
+  })
+
+  // 用户配置中常用的模型名
+  test('common model names from user configs', () => {
+    // 豆包模型
+    expect(getContextWindowForModel('Doubao-Seed-2.0-Code')).toBe(256_000)
+
+    // DeepSeek 模型
+    expect(getContextWindowForModel('deepseek-chat')).toBe(128_000)
+    expect(getContextWindowForModel('deepseek-reasoner')).toBe(128_000)
+
+    // Kimi 模型
+    expect(getContextWindowForModel('kimi-k2.5')).toBe(262_144) // 实际值
+    expect(getContextWindowForModel('kimi-k2.6')).toBe(262_144) // 实际值
+
+    // 通义千问
+    expect(getContextWindowForModel('qwen3.6-plus')).toBe(1_000_000)
+    expect(getContextWindowForModel('qwen3.7-max')).toBe(1_000_000)
+  })
+})

package/src/config/index.ts

@@ -8,6 +8,7 @@ export interface Config {
   mode: 'code' | 'plan' | 'ask'
   provider: 'openai' | 'anthropic' | 'google' | 'ollama'
   model: string
+  contextWindow: number
   cwd: string
   autoApprove: boolean
   thinking?: boolean
@@ -19,6 +20,243 @@ export interface Config {
   tavilyApiKey?: string
 }
 
+/**
+ * 模型上下文窗口大小映射表（基于 2026 年最新数据）
+ * 单位：tokens
+ */
+const MODEL_CONTEXT_WINDOWS: Record<string, number> = {
+  // Doubao 系列
+  'doubao-seed-2.0-code': 256_000,
+  'doubao-seed-2.0-pro': 256_000,
+  'doubao-seed-2.0-lite': 256_000,
+  'doubao-seed-2.0-mini': 256_000,
+  'doubao-seed-2.0-code-preview-260215': 256_000,
+  'doubao-seed-1.8': 256_000,
+  'doubao-seed-1.6': 256_000,
+
+  // DeepSeek 系列
+  'deepseek-v4-pro': 1_000_000,
+  'deepseek-v4-flash': 256_000,
+  'deepseek-v3.2': 160_000,
+  'deepseek-r1': 128_000,
+  'deepseek-chat': 128_000,
+  'deepseek-reasoner': 128_000,
+
+  // Kimi 系列
+  'kimi-k2.5': 262_144,
+  'kimi-k2.6': 262_144,
+  'kimi-k2-thinking': 256_000,
+
+  // MiniMax 系列
+  'minimax-m2.5': 200_000,
+  'minimax-m2.7': 200_000,
+  'minimax-m2': 205_000,
+
+  // GLM 系列
+  'glm-5': 200_000,
+  'glm-5.1': 200_000,
+  'glm-4.7-flashx': 200_000,
+  'glm-4-flash': 128_000,
+  'glm-4': 128_000,
+
+  // Qwen 系列
+  'qwen3.6-plus': 1_000_000,
+  'qwen3.7-max': 1_000_000,
+  'qwen3-max': 256_000,
+  'qwen3.5-plus': 1_000_000,
+  'qwen-flash': 1_000_000,
+
+  // Claude 系列
+  'claude-opus-4.7': 1_000_000,
+  'claude-opus-4.6': 1_000_000,
+  'claude-sonnet-4.6': 1_000_000,
+  'claude-haiku-4.5': 200_000,
+
+  // GPT 系列
+  'gpt-5.5': 1_000_000,
+  'gpt-5.4': 1_000_000,
+  'gpt-5.1': 1_000_000,
+  'gpt-5.2-codex': 512_000,
+  'gpt-4.1': 1_000_000,
+  'gpt-4.1-mini': 1_000_000,
+  'gpt-4o': 128_000,
+  'gpt-4': 128_000,
+
+  // Gemini 系列
+  'gemini-2.5-pro': 1_000_000,
+  'gemini-2.5-flash': 1_000_000,
+  'gemini-3.1-pro': 1_000_000,
+  'gemini-3.1-flash': 1_000_000,
+
+  // Llama 系列
+  'llama-4-maverick': 1_000_000,
+  'llama-4-scout': 10_000_000,
+  'llama-3.1': 128_000,
+  'llama-3': 128_000,
+
+  // Mistral 系列
+  'mistral-small-3.1': 128_000,
+  'mistral-small-3.2': 128_000,
+}
+
+/**
+ * 模糊匹配规则
+ */
+interface FuzzyMatchRule {
+  keywords: string[]
+  windowSize: number
+}
+
+/**
+ * 模糊匹配规则列表（从高优先级到低优先级）
+ */
+const fuzzyMatchRules: FuzzyMatchRule[] = [
+  // 首先匹配 128K 模型（防止 gpt-4 匹配到 gpt-5 规则）
+  {
+    keywords: [
+      'gpt-4o',
+      'gpt 4o',
+      'gpt-4',
+      'gpt 4',
+      'llama-3',
+      'llama 3',
+      'mistral-small',
+      'mistral small',
+      'glm-4-flash',
+      'glm 4 flash',
+      'glm-4',
+    ],
+    windowSize: 128_000,
+  },
+  // 百万上下文模型 - 更高优先级（更精确的关键词）
+  {
+    keywords: [
+      'deepseek-v4',
+      'deepseek v4',
+      'qwen3.6',
+      'qwen 3.6',
+      'qwen3.7',
+      'qwen 3.7',
+      'qwen3.5',
+      'qwen 3.5',
+      'qwen-flash',
+      'qwen flash',
+    ],
+    windowSize: 1_000_000,
+  },
+  {
+    keywords: [
+      'claude-opus',
+      'claude sonnet',
+      'claude-sonnet',
+      'gpt-5.',
+      'gpt 5',
+      'gpt-4.1',
+      'gpt 4.1',
+      'gemini-2.5',
+      'gemini 2.5',
+      'gemini-3.1',
+      'gemini 3.1',
+      'llama-4',
+      'llama 4',
+    ],
+    windowSize: 1_000_000,
+  },
+  // 256K 上下文模型
+  {
+    keywords: [
+      'doubao-seed-2.0',
+      'doubao seed 2.0',
+      'doubao-seed-1',
+      'doubao seed 1',
+      'kimi-k2',
+      'kimi k2',
+      'kimi-k2.5',
+      'kimi k2.5',
+      'kimi-k2.6',
+      'kimi k2.6',
+      'qwen3',
+      'qwen 3',
+      'qwen3-max',
+      'qwen3 max',
+    ],
+    windowSize: 256_000,
+  },
+  // 200K 上下文模型
+  {
+    keywords: [
+      'minimax',
+      'glm-5',
+      'glm 5',
+      'glm-5.1',
+      'glm 5.1',
+      'glm-4.7',
+      'glm 4.7',
+      'claude-haiku',
+      'claude haiku',
+    ],
+    windowSize: 200_000,
+  },
+  // 160K 上下文模型
+  {
+    keywords: ['deepseek-v3', 'deepseek v3', 'deepseek-v3.2', 'deepseek v3.2'],
+    windowSize: 160_000,
+  },
+  // 最后匹配通用关键词（deepseek）
+  {
+    keywords: ['deepseek'],
+    windowSize: 128_000,
+  },
+]
+
+/**
+ * 根据模型名称获取上下文窗口大小（改进的模糊匹配）
+ * @param modelName 模型名称（不区分大小写）
+ * @returns 上下文窗口大小（tokens）
+ */
+export function getContextWindowForModel(modelName: string): number {
+  // 处理空字符串
+  if (!modelName) {
+    return 128_000
+  }
+
+  const normalizedModelName = modelName.toLowerCase().replace(/[-_]/g, ' ')
+
+  // 1. 精确匹配（原始键名）
+  if (MODEL_CONTEXT_WINDOWS[modelName]) {
+    return MODEL_CONTEXT_WINDOWS[modelName]
+  }
+
+  // 2. 精确匹配（小写键名）
+  if (MODEL_CONTEXT_WINDOWS[modelName.toLowerCase()]) {
+    return MODEL_CONTEXT_WINDOWS[modelName.toLowerCase()]
+  }
+
+  // 3. 前缀匹配（支持部分匹配）
+  for (const [pattern, size] of Object.entries(MODEL_CONTEXT_WINDOWS)) {
+    const normalizedPattern = pattern.toLowerCase().replace(/[-_]/g, ' ')
+    if (
+      normalizedModelName.includes(normalizedPattern) ||
+      normalizedPattern.includes(normalizedModelName)
+    ) {
+      return size
+    }
+  }
+
+  // 4. 模糊匹配（关键词匹配）- 按照规则顺序（优先级）处理
+  for (const rule of fuzzyMatchRules) {
+    for (const keyword of rule.keywords) {
+      const normalizedKeyword = keyword.toLowerCase().replace(/[-_]/g, ' ')
+      if (normalizedModelName.includes(normalizedKeyword)) {
+        return rule.windowSize
+      }
+    }
+  }
+
+  // 5. 兜底默认值
+  return 128_000
+}
+
 interface JsonConfig {
   apiKey?: string
   baseUrl?: string
@@ -29,6 +267,7 @@ interface JsonConfig {
   autoApprove?: boolean
   enableCache?: boolean
   strictTools?: boolean
+  contextWindow?: number
   temperature?: number
   maxTokens?: number
   tavilyApiKey?: string
@@ -69,6 +308,9 @@ export function loadConfig(options?: {
   // Auto-enable cache for DeepSeek models unless explicitly disabled
   const enableCache = jsonConfig.enableCache ?? (isDeepSeekModel(model, baseUrl) || undefined)
 
+  // 根据模型名称获取上下文窗口大小，如果配置中有则优先使用配置值
+  const contextWindow = jsonConfig.contextWindow || getContextWindowForModel(model)
+
   return {
     apiKey: jsonConfig.apiKey || '',
     baseUrl,
@@ -79,6 +321,7 @@ export function loadConfig(options?: {
       | 'ollama',
     mode: options?.mode || 'code',
     model,
+    contextWindow,
     cwd: options?.cwd || process.cwd(),
     autoApprove: options?.autoApprove ?? jsonConfig.autoApprove ?? false,
     thinking: jsonConfig.thinking,

package/src/pi-tui/tui.ts

@@ -1351,26 +1351,20 @@ export class TUI extends Container {
     const targetRow = Math.max(0, Math.min(cursorPos.row, totalLines - 1))
     const targetCol = Math.max(0, cursorPos.col)
 
-    // Move cursor from current position to target
-    const rowDelta = targetRow - this.hardwareCursorRow
-    let buffer = ''
-    if (rowDelta > 0) {
-      buffer += `\x1b[${rowDelta}B` // Move down
-    } else if (rowDelta < 0) {
-      buffer += `\x1b[${-rowDelta}A` // Move up
+    // Use absolute cursor positioning (CUP) to avoid scroll artifacts.
+    // Relative movement (\x1b[NB/\x1b[NA) with a stale baseline can
+    // cause the terminal to scroll, inserting blank lines, especially
+    // when the editor overlay cursor is far from the rendered content.
+    let buffer = `\x1b[${targetRow + 1};${targetCol + 1}H`
+
+    if (this.showHardwareCursor) {
+      buffer += '\x1b[?25h'
     }
-    // Move to absolute column (1-indexed)
-    buffer += `\x1b[${targetCol + 1}G`
 
     if (buffer) {
       this.terminal.write(buffer)
     }
 
     this.hardwareCursorRow = targetRow
-    if (this.showHardwareCursor) {
-      this.terminal.showCursor()
-    } else {
-      this.terminal.hideCursor()
-    }
   }
 }

package/src/tools/__tests__/edit.test.ts

@@ -86,6 +86,134 @@ describe('edit tool', () => {
     })
   })
 
+  describe('validation', () => {
+    beforeAll(() => {
+      fs.writeFileSync(path.join(tmpDir, 'a.txt'), 'test content\n')
+    })
+
+    it('rejects edit missing old_string', async () => {
+      const r = await tool().execute({
+        edits: [{ file_path: 'a.txt', new_string: 'replacement' }],
+      })
+      expect(r.success).toBe(false)
+      expect(r.error).toContain('missing')
+      expect(r.error).toContain('old_string')
+    })
+
+    it('rejects edit missing new_string', async () => {
+      const r = await tool().execute({
+        edits: [{ file_path: 'a.txt', old_string: 'original' }],
+      })
+      expect(r.success).toBe(false)
+      expect(r.error).toContain('missing')
+      expect(r.error).toContain('new_string')
+    })
+
+    it('rejects edit missing file_path', async () => {
+      const r = await tool().execute({
+        edits: [{ old_string: 'a', new_string: 'b' }],
+      })
+      expect(r.success).toBe(false)
+      expect(r.error).toContain('missing')
+      expect(r.error).toContain('file_path')
+    })
+
+    it('reports all missing fields in one error', async () => {
+      const r = await tool().execute({
+        edits: [
+          { file_path: 'a.txt', old_string: 'a', new_string: 'b' },
+          { file_path: 'a.txt', new_string: 'c' },
+          { file_path: 'a.txt', old_string: 'd' },
+        ],
+      })
+      expect(r.success).toBe(false)
+      // Should report BOTH errors, not just the first
+      expect(r.error).toContain('2 of 3')
+      expect(r.error).toContain('edit #2')
+      expect(r.error).toContain('edit #3')
+      // Should mention not to split across edits
+      expect(r.error).toContain('COMPLETE')
+    })
+
+    it('reports which fields each malformed edit has', async () => {
+      const r = await tool().execute({
+        edits: [{ file_path: 'a.txt', new_string: 'c' }],
+      })
+      expect(r.success).toBe(false)
+      expect(r.error).toContain('has: file_path, new_string')
+    })
+
+    it('includes rawInput in the error message', async () => {
+      const r = await tool().execute({
+        edits: [{ file_path: 'a.txt', new_string: 'c' }],
+      })
+      expect(r.success).toBe(false)
+      expect(r.error).toContain('a.txt')
+      expect(r.error).toContain('new_string')
+    })
+  })
+
+  describe('auto-correction', () => {
+    it('wraps top-level file_path/old_string/new_string into edits array', async () => {
+      const r = await tool().execute({
+        file_path: 'nonexistent.ts',
+        old_string: 'x',
+        new_string: 'y',
+      })
+      // Should be auto-corrected so the error is about file not found, not about missing edits
+      expect(r.success).toBe(false)
+      expect(r.error).toContain('not found')
+    })
+
+    it('wraps flat file_path + old_string (missing new_string) with default empty new_string', async () => {
+      const r = await tool().execute({
+        file_path: path.join(tmpDir, 'new.txt'),
+        old_string: '',
+      })
+      // Auto-corrected to { edits: [{ file_path, old_string: '', new_string: '' }] }
+      // This creates a file with empty content
+      expect(r.success).toBe(true)
+      expect(fs.existsSync(path.join(tmpDir, 'new.txt'))).toBe(true)
+      expect(fs.readFileSync(path.join(tmpDir, 'new.txt'), 'utf8')).toBe('')
+      fs.unlinkSync(path.join(tmpDir, 'new.txt'))
+    })
+
+    it('handles edits passed directly as an array (not wrapped)', async () => {
+      // @ts-expect-error — runtime accepts array, TS expects object
+      const r = await tool().execute([
+        { file_path: 'a.txt', old_string: 'test', new_string: 'TEST' },
+      ])
+      expect(r.success).toBe(true)
+    })
+
+    it('handles file_path + new_string (no old_string) at top level as create', async () => {
+      const r = await tool().execute({
+        file_path: path.join(tmpDir, 'auto-create.txt'),
+        new_string: 'auto created',
+      })
+      expect(r.success).toBe(true)
+      expect(fs.readFileSync(path.join(tmpDir, 'auto-create.txt'), 'utf8')).toBe('auto created')
+      fs.unlinkSync(path.join(tmpDir, 'auto-create.txt'))
+    })
+
+    it('handles only file_path at top level as empty file creation', async () => {
+      const r = await tool().execute({
+        file_path: path.join(tmpDir, 'empty-file.txt'),
+      })
+      expect(r.success).toBe(true)
+      expect(fs.existsSync(path.join(tmpDir, 'empty-file.txt'))).toBe(true)
+      expect(fs.readFileSync(path.join(tmpDir, 'empty-file.txt'), 'utf8')).toBe('')
+      fs.unlinkSync(path.join(tmpDir, 'empty-file.txt'))
+    })
+
+    it('rejects nonsensical top-level keys with helpful error', async () => {
+      const r = await tool().execute({ foo: 'bar' })
+      expect(r.success).toBe(false)
+      expect(r.error).toContain('edits')
+      expect(r.error).toContain('array')
+    })
+  })
+
   describe('batch mode', () => {
     beforeAll(() => {
       fs.writeFileSync(path.join(tmpDir, 'a.txt'), 'one\ntwo\nthree\nfour\n')
@@ -305,4 +433,159 @@ describe('edit tool', () => {
       expect(fs.existsSync(path.join(createdDir(), 'rollback-1.ts'))).toBe(false)
     })
   })
+
+  describe('whitespace tolerance', () => {
+    const wsDir = () => path.join(tmpDir, 'ws-test')
+    const f = (name: string) => path.join(wsDir(), name)
+
+    beforeAll(() => {
+      fs.mkdirSync(wsDir(), { recursive: true })
+    })
+
+    const tool = () => createEditTool(applier, wsDir())
+
+    it('handles trailing space in file (AI omits trailing space)', async () => {
+      fs.writeFileSync(f('trailing.txt'), 'hello \nworld\n')
+      const r = await tool().execute({
+        edits: [
+          { file_path: 'trailing.txt', old_string: 'hello\nworld', new_string: 'HELLO\nWORLD' },
+        ],
+      })
+      expect(r.success).toBe(true)
+      expect(fs.readFileSync(f('trailing.txt'), 'utf8')).toBe('HELLO\nWORLD\n')
+      // Should indicate whitespace-normalized in output
+      expect(r.output).toContain('whitespace-normalized')
+    })
+
+    it('handles trailing space in old_string (AI adds extra trailing space)', async () => {
+      fs.writeFileSync(f('trailing.txt'), 'hello \nworld\n')
+      const r = await tool().execute({
+        edits: [
+          { file_path: 'trailing.txt', old_string: 'hello \nworld', new_string: 'HELLO\nWORLD' },
+        ],
+      })
+      expect(r.success).toBe(true)
+      expect(fs.readFileSync(f('trailing.txt'), 'utf8')).toBe('HELLO\nWORLD\n')
+    })
+
+    it('handles leading space in file (AI omits leading indent)', async () => {
+      fs.writeFileSync(f('leading.txt'), '  hello\nworld\n')
+      const r = await tool().execute({
+        edits: [
+          { file_path: 'leading.txt', old_string: 'hello\nworld', new_string: 'HELLO\nWORLD' },
+        ],
+      })
+      expect(r.success).toBe(true)
+      // Leading spaces in the original file become part of the matched block
+      // and are preserved in the result
+      expect(fs.readFileSync(f('leading.txt'), 'utf8')).toBe('  HELLO\nWORLD\n')
+    })
+
+    it('handles leading space in old_string (AI adds extra indent)', async () => {
+      fs.writeFileSync(f('leading.txt'), '  hello\nworld\n')
+      const r = await tool().execute({
+        edits: [
+          { file_path: 'leading.txt', old_string: '    hello\nworld', new_string: 'HELLO\nWORLD' },
+        ],
+      })
+      expect(r.success).toBe(true)
+      // The file's leading spaces are part of the matched block, so they
+      // get replaced along with the rest of the matched text
+      expect(fs.readFileSync(f('leading.txt'), 'utf8')).toBe('HELLO\nWORLD\n')
+    })
+
+    it('handles extra internal spaces in file (AI sends single space)', async () => {
+      fs.writeFileSync(f('internal.txt'), 'foo  bar\nbaz\n')
+      const r = await tool().execute({
+        edits: [
+          { file_path: 'internal.txt', old_string: 'foo bar\nbaz', new_string: 'FOO BAR\nBAZ' },
+        ],
+      })
+      expect(r.success).toBe(true)
+      expect(fs.readFileSync(f('internal.txt'), 'utf8')).toBe('FOO BAR\nBAZ\n')
+    })
+
+    it('handles extra internal spaces in old_string (AI adds double space)', async () => {
+      fs.writeFileSync(f('internal.txt'), 'foo  bar\nbaz\n')
+      const r = await tool().execute({
+        edits: [
+          { file_path: 'internal.txt', old_string: 'foo  bar\nbaz', new_string: 'FOO BAR\nBAZ' },
+        ],
+      })
+      expect(r.success).toBe(true)
+      expect(fs.readFileSync(f('internal.txt'), 'utf8')).toBe('FOO BAR\nBAZ\n')
+    })
+
+    it('handles blank line with spaces matching empty blank line', async () => {
+      fs.writeFileSync(f('blank.txt'), 'foo\n   \nbar\n')
+      const r = await tool().execute({
+        edits: [{ file_path: 'blank.txt', old_string: 'foo\n\nbar', new_string: 'FOO\n\nBAR' }],
+      })
+      expect(r.success).toBe(true)
+      // The blank line with spaces is part of the matched block and gets
+      // replaced entirely by the new_string's blank line
+      expect(fs.readFileSync(f('blank.txt'), 'utf8')).toBe('FOO\n\nBAR\n')
+    })
+
+    it('handles mixed whitespace across multiple lines', async () => {
+      fs.writeFileSync(f('mixed.txt'), '  a  \nb \nc\n')
+      const r = await tool().execute({
+        edits: [{ file_path: 'mixed.txt', old_string: 'a\nb\nc', new_string: 'A\nB\nC' }],
+      })
+      expect(r.success).toBe(true)
+      expect(fs.readFileSync(f('mixed.txt'), 'utf8')).toBe('A\nB\nC\n')
+    })
+
+    it('still fails when text content differs (not just whitespace)', async () => {
+      fs.writeFileSync(f('trailing.txt'), 'hello \nworld\n')
+      const r = await tool().execute({
+        edits: [{ file_path: 'trailing.txt', old_string: 'hello\nmundo', new_string: 'x\ny' }],
+      })
+      expect(r.success).toBe(false)
+      expect(r.error).toContain('not found')
+    })
+
+    it('still fails for completely wrong old_string', async () => {
+      fs.writeFileSync(f('trailing.txt'), 'hello \nworld\n')
+      const r = await tool().execute({
+        edits: [{ file_path: 'trailing.txt', old_string: 'zzz\nzzz', new_string: 'x\ny' }],
+      })
+      expect(r.success).toBe(false)
+      expect(r.error).toContain('not found')
+    })
+
+    it('reports duplicate in whitespace-normalized mode', async () => {
+      fs.writeFileSync(f('duplicate.txt'), 'a  \nb\na  \nb\n')
+      const r = await tool().execute({
+        edits: [{ file_path: 'duplicate.txt', old_string: 'a\nb', new_string: 'X\nY' }],
+      })
+      expect(r.success).toBe(false)
+      expect(r.error).toContain('MULTIPLE times')
+      expect(r.error).toContain('whitespace-normalized')
+    })
+
+    it('prefers exact match when available', async () => {
+      fs.writeFileSync(f('exact-prefer.txt'), 'hello\nworld\n')
+      const r = await tool().execute({
+        edits: [
+          { file_path: 'exact-prefer.txt', old_string: 'hello\nworld', new_string: 'HELLO\nWORLD' },
+        ],
+      })
+      expect(r.success).toBe(true)
+      expect(fs.readFileSync(f('exact-prefer.txt'), 'utf8')).toBe('HELLO\nWORLD\n')
+      // Exact match should NOT have the whitespace-normalized note
+      expect(r.output).not.toContain('whitespace-normalized')
+    })
+
+    it('provides context snippet when old_string not found', async () => {
+      fs.writeFileSync(f('trailing.txt'), 'hello \nworld\n')
+      const r = await tool().execute({
+        edits: [{ file_path: 'trailing.txt', old_string: 'nonexistent_line_xyz', new_string: 'x' }],
+      })
+      expect(r.success).toBe(false)
+      expect(r.error).toContain('not found')
+      // Should contain a snippet with the file's actual content
+      expect(r.error).toContain('hello')
+    })
+  })
 })