@namzu/sdk 14.0.6 → 15.0.0

package/src/tools/builtins/__tests__/bash.proc-test.ts

@@ -1,142 +0,0 @@
-import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { afterEach, describe, expect, it } from 'vitest'
-
-import type { ToolContext } from '../../../types/tool/index.js'
-import { BashTool } from '../bash.js'
-
-/**
- * What a shell command actually tells the model, measured by running one.
- *
- * The only builtin that runs a shell had no test at all, and what that cost
- * is visible in the code it shipped: the host path called `exec` with no
- * `catch`, and `exec` REJECTS on a non-zero exit. So the two things an agent
- * runs a shell for most — a test run and a build — both threw, and the
- * registry turned the throw into "the tool failed" with none of the stdout,
- * stderr or exit code that explains why. The sandbox path beside it reported
- * all three, so the same command told the model two different amounts
- * depending on where it happened to run.
- *
- * These spawn real processes, so they live in the `proc-test` suite rather
- * than the unit one — measured, running them beside 2594 unit tests flaked
- * four unrelated timing-sensitive tests. The assertions that need no shell
- * stayed behind in `bash.test.ts`.
- *
- * Commands are written to behave identically under `cmd.exe` and `sh`,
- * because `exec` picks the platform shell and a test that only passes on one
- * of them is a test that fails for whoever is on the other.
- */
-
-const dirs: string[] = []
-afterEach(() => {
-	for (const dir of dirs) {
-		// A killed child can still hold its working directory for a moment —
-		// on Windows that surfaces as EBUSY, and it failed the timeout test
-		// from the cleanup rather than the assertion, which is the most
-		// misleading way for a test to go red. Retry, then let it go: a temp
-		// directory that outlives the run is the operating system's problem,
-		// not a result worth reporting.
-		try {
-			rmSync(dir, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 })
-		} catch {
-			// Deliberately swallowed. See above.
-		}
-	}
-	dirs.length = 0
-})
-
-function ctx(): ToolContext {
-	const workingDirectory = mkdtempSync(join(tmpdir(), 'namzu-bash-'))
-	dirs.push(workingDirectory)
-	return { workingDirectory } as ToolContext
-}
-
-async function run(
-	input: Record<string, unknown>,
-	context: ToolContext = ctx(),
-): Promise<{ success: boolean; output: string; error?: string; data?: Record<string, unknown> }> {
-	const parsed = BashTool.inputSchema.parse(input)
-	return (await BashTool.execute(parsed as never, context)) as never
-}
-
-describe('a command that succeeds', () => {
-	it('returns its stdout', async () => {
-		const result = await run({ command: 'echo hello' })
-
-		expect(result.success).toBe(true)
-		expect(result.output).toContain('hello')
-		expect(result.data?.exitCode).toBe(0)
-	})
-
-	it('runs in the working directory it was given', async () => {
-		const context = ctx()
-		writeFileSync(join(context.workingDirectory, 'marker.txt'), 'x')
-
-		const result = await run(
-			{ command: `node -e "console.log(require('fs').readdirSync('.'))"` },
-			context,
-		)
-
-		expect(result.output).toContain('marker.txt')
-	})
-
-	it('says so rather than returning an empty string', async () => {
-		const result = await run({ command: 'node -e ""' })
-
-		expect(result.output).toBe('(no output)')
-	})
-})
-
-describe('a command that fails still says what happened', () => {
-	it('reports the exit code instead of throwing', async () => {
-		// The whole defect: this used to reject out of `execute`.
-		const result = await run({ command: 'node -e "process.exit(3)"' })
-
-		expect(result.success).toBe(false)
-		expect(result.data?.exitCode).toBe(3)
-		expect(result.error).toContain('exited with code 3')
-	})
-
-	it('keeps the output a failing command produced', async () => {
-		// The reason a model runs a shell at all: a failing test prints WHY it
-		// failed, on stdout, before exiting non-zero.
-		const result = await run({
-			command: `node -e "console.log('3 tests failed'); process.exit(1)"`,
-		})
-
-		expect(result.success).toBe(false)
-		expect(result.output, 'the failure output was discarded').toContain('3 tests failed')
-	})
-
-	it('keeps stderr too', async () => {
-		const result = await run({
-			command: `node -e "console.error('compiler said no'); process.exit(2)"`,
-		})
-
-		expect(result.output).toContain('compiler said no')
-		expect(result.data?.exitCode).toBe(2)
-	})
-
-	it('reports a missing command as a failure, not as success', async () => {
-		const result = await run({ command: 'definitely-not-a-real-command-xyz' })
-
-		expect(result.success).toBe(false)
-		expect(result.error).toBeTruthy()
-	})
-})
-
-describe('a command that runs out of time', () => {
-	it('says it timed out rather than that it exited', async () => {
-		// "Ran out of time" and "exited 1" are different diagnoses and lead to
-		// different next moves, so the message has to distinguish them.
-		const result = await run({
-			command: `node -e "setTimeout(() => {}, 10000)"`,
-			timeout: 300,
-		})
-
-		expect(result.success).toBe(false)
-		expect(result.data?.timedOut).toBe(true)
-		expect(result.error).toContain('timed out')
-	}, 20_000)
-})

package/src/tools/builtins/__tests__/bash.test.ts

@@ -1,79 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { BashTool } from '../bash.js'
-
-/**
- * What `bash` promises before it runs anything.
- *
- * These need no shell, so they stay in the unit suite. The ones that actually
- * execute a command live in `bash.proc-test.ts` — spawning real processes
- * beside 2594 unit tests flaked four unrelated timing-sensitive ones, so the
- * process suite is separate and has its own CI step.
- */
-
-describe('the two clocks agree', () => {
-	it('declares a deadline of its own', () => {
-		// The executor reads a tool's `timeoutMs` before falling back to its
-		// generic default. With none declared, `bash` inherited that default —
-		// the same two minutes as its OWN default — so the two agreed by
-		// coincidence and diverged the moment a model asked for longer because
-		// it knew a build was slow. It got two minutes, from a clock it had not
-		// been told about, reported as an abandoned tool rather than as a
-		// command that ran out of time.
-		expect(BashTool.timeoutMs).toBeDefined()
-	})
-
-	it('puts that deadline above the longest the model may request', () => {
-		// So this tool's own clock is the one that fires, and the executor's is
-		// a backstop rather than a second clock racing it.
-		const accepted = BashTool.inputSchema.safeParse({ command: 'true', timeout: 10 * 60 * 1000 })
-
-		expect(accepted.success).toBe(true)
-		expect(BashTool.timeoutMs as number).toBeGreaterThan(10 * 60 * 1000)
-	})
-
-	it('refuses an over-long request rather than silently shortening it', () => {
-		// Refuse, do not degrade. A number the model was not told had changed
-		// is how it learns to distrust its own arguments.
-		const overCeiling = BashTool.inputSchema.safeParse({
-			command: 'true',
-			timeout: 60 * 60 * 1000,
-		})
-
-		expect(overCeiling.success, 'the ceiling is not enforced').toBe(false)
-	})
-
-	it('refuses a nonsensical deadline', () => {
-		expect(BashTool.inputSchema.safeParse({ command: 'true', timeout: 0 }).success).toBe(false)
-		expect(BashTool.inputSchema.safeParse({ command: 'true', timeout: -1 }).success).toBe(false)
-	})
-
-	it('applies its default when none is given', () => {
-		const parsed = BashTool.inputSchema.parse({ command: 'true' })
-
-		expect(parsed.timeout).toBeGreaterThan(0)
-	})
-})
-
-describe('the input is closed before a shell ever sees it', () => {
-	it('refuses an empty command', () => {
-		expect(BashTool.inputSchema.safeParse({ command: '' }).success).toBe(false)
-	})
-
-	it('accepts a numeric timeout sent as a string', () => {
-		// Providers do this, and the coercion is deliberate.
-		const parsed = BashTool.inputSchema.parse({ command: 'true', timeout: '5000' })
-
-		expect(parsed.timeout).toBe(5000)
-	})
-})
-
-describe('the danger flag reads the command', () => {
-	it('marks a destructive command destructive', () => {
-		expect(BashTool.isDestructive?.({ command: 'rm -rf /', timeout: 1000 } as never)).toBe(true)
-	})
-
-	it('leaves an ordinary command alone', () => {
-		expect(BashTool.isDestructive?.({ command: 'ls -la', timeout: 1000 } as never)).toBe(false)
-	})
-})

package/src/tools/builtins/__tests__/computer-use.test.ts

@@ -1,201 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import type {
-	ComputerUseAction,
-	ComputerUseCapabilities,
-	ComputerUseHost,
-	ComputerUseResult,
-	DisplayGeometry,
-} from '../../../types/computer-use/index.js'
-import type { ToolContext } from '../../../types/tool/index.js'
-import { COMPUTER_USE_TOOL_NAME, createComputerUseTool } from '../computer-use.js'
-
-function makeHost(overrides: Partial<ComputerUseCapabilities> = {}): {
-	host: ComputerUseHost
-	calls: ComputerUseAction[]
-} {
-	const calls: ComputerUseAction[] = []
-	const capabilities: ComputerUseCapabilities = {
-		displayServer: 'darwin',
-		screenshot: true,
-		mouse: true,
-		keyboard: true,
-		cursorPosition: true,
-		clipboard: true,
-		...overrides,
-	}
-	const host: ComputerUseHost = {
-		id: 'mock-host',
-		capabilities,
-		async getDisplayGeometry(): Promise<DisplayGeometry> {
-			return { width: 1920, height: 1080, scaleFactor: 2 }
-		},
-		async execute(action: ComputerUseAction): Promise<ComputerUseResult> {
-			calls.push(action)
-			switch (action.type) {
-				case 'screenshot':
-					return {
-						type: 'screenshot',
-						result: {
-							data: Buffer.from([0x89, 0x50, 0x4e, 0x47]),
-							mimeType: 'image/png',
-							width: 1920,
-							height: 1080,
-						},
-					}
-				case 'cursor_position':
-					return { type: 'cursor_position', point: { x: 10, y: 20 } }
-				default:
-					return { type: 'ok' }
-			}
-		},
-	}
-	return { host, calls }
-}
-
-function makeContext(): ToolContext {
-	return {
-		runId: 'run_test' as never,
-		workingDirectory: '/tmp',
-		abortSignal: new AbortController().signal,
-		env: {},
-		log: () => {},
-	}
-}
-
-describe('createComputerUseTool', () => {
-	it('exposes the canonical tool name', () => {
-		expect(COMPUTER_USE_TOOL_NAME).toBe('computer_use')
-		const { host } = makeHost()
-		const tool = createComputerUseTool(host)
-		expect(tool.name).toBe('computer_use')
-	})
-
-	it('surfaces host capabilities in the description', () => {
-		const { host } = makeHost({ keyboard: false, mouse: false, cursorPosition: false })
-		const tool = createComputerUseTool(host)
-		expect(tool.description).toContain('darwin')
-		expect(tool.description.toLowerCase()).toContain('unavailable')
-		expect(tool.description).toContain('keyboard')
-	})
-
-	it('marks click/type/key/drag/scroll as destructive and screenshot/move as not', () => {
-		const { host } = makeHost()
-		const tool = createComputerUseTool(host)
-		expect(tool.isDestructive?.({ type: 'screenshot' } as never)).toBe(false)
-		expect(tool.isDestructive?.({ type: 'cursor_position' } as never)).toBe(false)
-		expect(tool.isDestructive?.({ type: 'mouse_move', to: { x: 0, y: 0 } } as never)).toBe(false)
-		expect(
-			tool.isDestructive?.({
-				type: 'mouse_click',
-				at: { x: 0, y: 0 },
-				button: 'left',
-			} as never),
-		).toBe(true)
-		expect(
-			tool.isDestructive?.({
-				type: 'mouse_drag',
-				from: { x: 0, y: 0 },
-				to: { x: 10, y: 10 },
-				button: 'left',
-			} as never),
-		).toBe(true)
-		expect(
-			tool.isDestructive?.({
-				type: 'scroll',
-				at: { x: 0, y: 0 },
-				direction: 'down',
-				amount: 3,
-			} as never),
-		).toBe(true)
-		expect(tool.isDestructive?.({ type: 'type_text', text: 'hi' } as never)).toBe(true)
-		expect(tool.isDestructive?.({ type: 'key', keys: 'ctrl+c' } as never)).toBe(true)
-	})
-
-	it('rejects actions whose required capability is missing', async () => {
-		const { host, calls } = makeHost({ keyboard: false })
-		const tool = createComputerUseTool(host)
-
-		const result = await tool.execute({ type: 'type_text', text: 'hi' }, makeContext())
-
-		expect(result.success).toBe(false)
-		expect(result.error).toContain('keyboard')
-		expect(calls).toHaveLength(0)
-	})
-
-	it('rejects cursor_position when the host does not support it', async () => {
-		const { host, calls } = makeHost({ cursorPosition: false })
-		const tool = createComputerUseTool(host)
-
-		const result = await tool.execute({ type: 'cursor_position' }, makeContext())
-
-		expect(result.success).toBe(false)
-		expect(result.error).toContain('cursorPosition')
-		expect(calls).toHaveLength(0)
-	})
-
-	it('returns the screenshot as an image BLOCK, not as base64 text', async () => {
-		const { host } = makeHost()
-		const tool = createComputerUseTool(host)
-
-		const result = await tool.execute({ type: 'screenshot' }, makeContext())
-
-		expect(result.success).toBe(true)
-
-		// `output` used to BE the base64 payload, so the model received
-		// hundreds of thousands of tokens of undecodable characters and
-		// could not see the screen at all. It is now a short description.
-		expect(result.output).toContain('1920x1080')
-		expect(result.output.length).toBeLessThan(200)
-
-		const blocks = result.content
-		expect(Array.isArray(blocks)).toBe(true)
-		const image = (blocks as Array<{ type: string; data?: string; mediaType?: string }>)[0]
-		expect(image?.type).toBe('image')
-		expect(image?.mediaType).toBe('image/png')
-		expect(Buffer.from(image?.data ?? '', 'base64').subarray(0, 4)).toEqual(
-			Buffer.from([0x89, 0x50, 0x4e, 0x47]),
-		)
-
-		expect(result.data).toMatchObject({
-			mimeType: 'image/png',
-			width: 1920,
-			height: 1080,
-			encoding: 'base64',
-		})
-	})
-
-	it('returns JSON point output for cursor_position', async () => {
-		const { host } = makeHost()
-		const tool = createComputerUseTool(host)
-
-		const result = await tool.execute({ type: 'cursor_position' }, makeContext())
-
-		expect(result.success).toBe(true)
-		expect(JSON.parse(result.output)).toEqual({ x: 10, y: 20 })
-	})
-
-	it('returns ok for side-effect actions and records the dispatch', async () => {
-		const { host, calls } = makeHost()
-		const tool = createComputerUseTool(host)
-
-		const action = { type: 'mouse_click', at: { x: 50, y: 60 }, button: 'left' } as const
-		const result = await tool.execute(action, makeContext())
-
-		expect(result.success).toBe(true)
-		expect(result.output).toBe('ok')
-		expect(calls).toEqual([action])
-	})
-
-	it('validates input via the discriminated union schema', () => {
-		const { host } = makeHost()
-		const tool = createComputerUseTool(host)
-
-		expect(() => tool.inputSchema.parse({ type: 'screenshot' })).not.toThrow()
-		expect(() =>
-			tool.inputSchema.parse({ type: 'mouse_click', at: { x: 1, y: 2 }, button: 'left' }),
-		).not.toThrow()
-		expect(() => tool.inputSchema.parse({ type: 'mouse_click' })).toThrow()
-		expect(() => tool.inputSchema.parse({ type: 'nope' })).toThrow()
-		expect(() => tool.inputSchema.parse({ type: 'scroll', at: { x: 0, y: 0 } })).toThrow()
-	})
-})

package/src/tools/builtins/__tests__/edit-commits-atomically.test.ts

@@ -1,103 +0,0 @@
-import { mkdtempSync, readFileSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join, resolve } from 'node:path'
-import { describe, expect, it, vi } from 'vitest'
-
-import type { ToolContext } from '../../../types/tool/index.js'
-
-/**
- * That the atomic writer works is tested next door. This tests the thing
- * that actually regressed: whether the TOOL goes through it.
- *
- * `edit` and `write` were reverted to a bare `writeFile`, and the existing
- * atomicity test kept passing because it called `atomicWriteFile` directly —
- * proving the module, never the caller. A write that fails partway then
- * truncates the user's file, which is the one outcome `edit` exists to
- * avoid.
- */
-
-const atomicWriteFile = vi.fn(async () => {})
-vi.mock('../atomic-write-file.js', () => ({ atomicWriteFile }))
-
-function makeContext(workingDirectory: string): ToolContext {
-	return {
-		runId: 'run_atomic' as ToolContext['runId'],
-		workingDirectory,
-		abortSignal: new AbortController().signal,
-		env: {},
-		log: () => {},
-	}
-}
-
-describe('the file-mutating tools commit through the atomic writer', () => {
-	it('edit routes its local write through it', async () => {
-		const { EditTool } = await import('../edit.js')
-		atomicWriteFile.mockClear()
-
-		const dir = mkdtempSync(join(tmpdir(), 'namzu-atomic-tool-'))
-		writeFileSync(join(dir, 'doc.md'), 'alpha\nbeta\n')
-
-		const result = await EditTool.execute(
-			{ path: 'doc.md', old_string: 'beta', new_string: 'gamma', replace_all: false },
-			makeContext(dir),
-		)
-
-		expect(result.success).toBe(true)
-		expect(atomicWriteFile).toHaveBeenCalledTimes(1)
-		expect(atomicWriteFile).toHaveBeenCalledWith(resolve(dir, 'doc.md'), 'alpha\ngamma\n')
-		// The mock swallowed the write, so the file is untouched — which is
-		// itself the proof that nothing else wrote it.
-		expect(readFileSync(join(dir, 'doc.md'), 'utf-8')).toBe('alpha\nbeta\n')
-	})
-
-	it('write routes its local write through it', async () => {
-		const { WriteFileTool } = await import('../write-file.js')
-		atomicWriteFile.mockClear()
-
-		const dir = mkdtempSync(join(tmpdir(), 'namzu-atomic-tool-'))
-
-		const result = await WriteFileTool.execute(
-			{ path: 'out.md', content: 'a complete body' },
-			makeContext(dir),
-		)
-
-		expect(result.success).toBe(true)
-		expect(atomicWriteFile).toHaveBeenCalledTimes(1)
-		expect(atomicWriteFile).toHaveBeenCalledWith(resolve(dir, 'out.md'), 'a complete body')
-	})
-
-	it('edit does not use it for a sandboxed write, which the sandbox owns', async () => {
-		const { EditTool } = await import('../edit.js')
-		atomicWriteFile.mockClear()
-
-		let body = 'alpha\nbeta\n'
-		const sandbox = {
-			id: 'sbx',
-			status: 'ready',
-			rootDir: '/workspace',
-			environment: 'basic',
-			async readFile() {
-				return Buffer.from(body)
-			},
-			async writeFile(_path: string, content: string | Buffer) {
-				body = content.toString()
-			},
-			async exec() {
-				throw new Error('not used')
-			},
-			async listFiles() {
-				return []
-			},
-			async destroy() {},
-		}
-
-		const result = await EditTool.execute(
-			{ path: 'doc.md', old_string: 'beta', new_string: 'gamma', replace_all: false },
-			{ ...makeContext('/workspace'), sandbox } as ToolContext,
-		)
-
-		expect(result.success).toBe(true)
-		expect(body).toBe('alpha\ngamma\n')
-		expect(atomicWriteFile).not.toHaveBeenCalled()
-	})
-})

package/src/tools/builtins/__tests__/edit-insert-reachable.test.ts

@@ -1,172 +0,0 @@
-import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { afterEach, describe, expect, it } from 'vitest'
-
-import type { ToolContext } from '../../../types/tool/index.js'
-import { EditTool } from '../edit.js'
-import { WriteFileTool } from '../write-file.js'
-
-/**
- * The tool's description ordered an idiom its own schema forbade.
- *
- * `edit`'s description says "For insertions, pass insertLine … use
- * insertLine: 'end' to extend a file at the end". `modelInputSchema` listed
- * only path/old_string/new_string/replace_all with
- * `additionalProperties: false`, and `enforceModelInput: true` — so under
- * constrained decoding the append idiom the prompt recommends was the one
- * idiom a model could not emit.
- *
- * A consuming host measured the consequence over 7 days on one tenant: 94 of
- * 159 tool failures were `edit` rejecting an `insertLine` the model had
- * guessed a spelling for. That number is theirs and not reproducible here;
- * the contradiction below is reproducible and is what these pin.
- */
-
-let dirs: string[] = []
-
-afterEach(async () => {
-	await Promise.all(dirs.map((d) => rm(d, { recursive: true, force: true })))
-	dirs = []
-})
-
-async function workdir(): Promise<string> {
-	const dir = await mkdtemp(join(tmpdir(), 'namzu-edit-insert-'))
-	dirs.push(dir)
-	return dir
-}
-
-const ctx = (workingDirectory: string): ToolContext =>
-	({
-		runId: 'run_e',
-		workingDirectory,
-		abortSignal: new AbortController().signal,
-		env: {},
-		log: () => undefined,
-	}) as unknown as ToolContext
-
-const schema = () =>
-	(EditTool as unknown as { modelInputSchema: Record<string, unknown> }).modelInputSchema
-
-describe('the model can emit the idiom the description recommends', () => {
-	it('advertises insertLine at all', () => {
-		const props = schema().properties as Record<string, unknown>
-
-		expect(props.insertLine).toBeDefined()
-	})
-
-	it('keeps the closed shape, so an invented field is still refused', () => {
-		expect(schema().additionalProperties).toBe(false)
-	})
-
-	it('does not require old_string, which an insert cannot supply', () => {
-		// Requiring it is what made the append idiom unexpressible: an insert
-		// has no text to match.
-		expect(schema().required).not.toContain('old_string')
-	})
-
-	it('still requires the two fields every operation needs', () => {
-		expect(schema().required).toEqual(expect.arrayContaining(['path', 'new_string']))
-	})
-
-	it('admits only "end" as a string, so a synonym cannot be generated', () => {
-		const insert = (schema().properties as Record<string, { anyOf?: unknown[] }>).insertLine
-
-		// The schema is where the synonym problem is solved for a provider that
-		// constrains: `"EOF"` is not emittable because `"end"` is the only
-		// string the union admits.
-		//
-		// `anyOf`, not `oneOf`: strict tool use validates against a subset of
-		// JSON Schema that excludes `oneOf`, and the vendor rejects the whole
-		// request rather than one field — so the spelling here is load-bearing,
-		// not stylistic. The two are equivalent for disjoint branches.
-		// `minimum` is gone for the same reason; the execution schema keeps it.
-		expect(insert?.anyOf).toEqual([{ type: 'integer' }, { const: 'end' }])
-	})
-})
-
-describe('an insert actually works end to end', () => {
-	it('appends with insertLine "end"', async () => {
-		const dir = await workdir()
-		await writeFile(join(dir, 'a.md'), 'first\n', 'utf-8')
-
-		const result = await EditTool.execute(
-			{ path: 'a.md', insertLine: 'end', new_string: 'second', replace_all: false },
-			ctx(dir),
-		)
-
-		expect(result.success).toBe(true)
-		expect(await readFile(join(dir, 'a.md'), 'utf-8')).toContain('second')
-	})
-
-	it('inserts after a numbered line', async () => {
-		const dir = await workdir()
-		await writeFile(join(dir, 'a.md'), 'one\ntwo\n', 'utf-8')
-
-		await EditTool.execute(
-			{ path: 'a.md', insertLine: 1, new_string: 'inserted', replace_all: false },
-			ctx(dir),
-		)
-
-		const lines = (await readFile(join(dir, 'a.md'), 'utf-8')).split('\n')
-		expect(lines[1]).toBe('inserted')
-	})
-})
-
-describe('a synonym for the end of the file is accepted, not charged for', () => {
-	it.each(['EOF', 'append', 'last', 'End_Of_File'])('accepts %s', async (spelling) => {
-		const dir = await workdir()
-		await writeFile(join(dir, 'a.md'), 'first\n', 'utf-8')
-
-		const result = await EditTool.execute(
-			{ path: 'a.md', insertLine: spelling, new_string: 'second', replace_all: false },
-			ctx(dir),
-		)
-
-		// Liberal here and strict in the schema, which is the right way round.
-		// None of these is ambiguous; refusing one costs a full model round
-		// trip to be told a synonym.
-		expect(result.success).toBe(true)
-	})
-
-	it('still refuses something that is not a line and not the end', async () => {
-		const dir = await workdir()
-		await writeFile(join(dir, 'a.md'), 'first\n', 'utf-8')
-
-		const result = await EditTool.execute(
-			{ path: 'a.md', insertLine: 'somewhere in the middle', new_string: 'x', replace_all: false },
-			ctx(dir),
-		)
-
-		expect(result.success).toBe(false)
-		// The rejection names what was received, so the retry is informed.
-		expect(result.error).toContain('somewhere in the middle')
-	})
-
-	it('still refuses a negative line', async () => {
-		const dir = await workdir()
-		await writeFile(join(dir, 'a.md'), 'first\n', 'utf-8')
-
-		const result = await EditTool.execute(
-			{ path: 'a.md', insertLine: -3, new_string: 'x', replace_all: false },
-			ctx(dir),
-		)
-
-		expect(result.success).toBe(false)
-	})
-})
-
-describe('the two mutating tools agree on what a path is', () => {
-	it('write refuses a whitespace-only path, as edit already did', async () => {
-		const dir = await workdir()
-
-		const w = await WriteFileTool.execute({ path: '   ', content: 'x' }, ctx(dir))
-		const e = await EditTool.execute(
-			{ path: '   ', old_string: 'a', new_string: 'b', replace_all: false },
-			ctx(dir),
-		)
-
-		expect(w.success).toBe(false)
-		expect(e.success).toBe(false)
-	})
-})