@namzu/sdk 14.0.6 → 15.0.0

package/src/telemetry/__tests__/model-call-span.test.ts

@@ -1,212 +0,0 @@
-import { mkdtemp, rm } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { MockLLMProvider } from '../../provider/mock.js'
-import { ToolRegistry } from '../../registry/tool/execute.js'
-import { drainQuery } from '../../runtime/query/index.js'
-import { createUserMessage } from '../../types/message/index.js'
-
-/**
- * There was no span around the model call at all.
- *
- * `chatSpanName` shipped in the telemetry attributes with zero call sites,
- * so a run's traces carried no LLM latency whatsoever — and the one thing
- * anybody opens a trace to find, which turn was slow and why, was the one
- * thing missing from it. The token counts landed on the iteration span
- * instead of the operation that produced them.
- */
-
-interface Recorded {
-	name: string
-	attributes: Record<string, unknown>
-	ended: boolean
-	status?: number
-}
-
-const spans: Recorded[] = []
-
-vi.mock('../runtime-accessors.js', () => ({
-	getTracer: () => ({
-		startSpan: (name: string) => {
-			const rec: Recorded = { name, attributes: {}, ended: false }
-			spans.push(rec)
-			return {
-				setAttributes: (a: Record<string, unknown>) => Object.assign(rec.attributes, a),
-				setAttribute: (k: string, v: unknown) => {
-					rec.attributes[k] = v
-				},
-				setStatus: (s: { code: number }) => {
-					rec.status = s.code
-				},
-				recordException: () => undefined,
-				addEvent: () => undefined,
-				end: () => {
-					rec.ended = true
-				},
-				spanContext: () => ({ traceId: 't', spanId: 's', traceFlags: 1 }),
-				isRecording: () => true,
-				updateName: () => undefined,
-			}
-		},
-		startActiveSpan: (_n: string, _o: unknown, _c: unknown, fn: (s: unknown) => unknown) =>
-			fn({
-				setAttributes: () => undefined,
-				setStatus: () => undefined,
-				recordException: () => undefined,
-				end: () => undefined,
-				spanContext: () => ({ traceId: 't', spanId: 's', traceFlags: 1 }),
-				isRecording: () => true,
-			}),
-	}),
-	getMeter: () => ({
-		createCounter: () => ({ add: () => undefined }),
-		createHistogram: () => ({ record: () => undefined }),
-	}),
-}))
-
-let workdirs: string[] = []
-
-beforeEach(() => {
-	spans.length = 0
-})
-
-afterEach(async () => {
-	await Promise.all(workdirs.map((d) => rm(d, { recursive: true, force: true })))
-	workdirs = []
-})
-
-/**
- * These four are imported at module scope on purpose, and must stay there.
- *
- * They used to be `await import(...)` inside this function, which meant the
- * query runtime's module graph — 75 imports deep — was loaded on the clock of
- * whichever test called it first. Measured: that test took 1349ms on an idle
- * machine while its eight siblings took 13-16ms, and under CPU load it hit
- * vitest's 5000ms default and went red. Nothing about it was racy and nothing
- * about it was slow; a load cost was simply billed to the wrong clock.
- *
- * At module scope the same work happens during collection, which carries no
- * per-test deadline, so the wall time is unchanged and the deadline is not.
- *
- * Safe because `vi.mock` is hoisted above every import in this file, so a
- * static import still receives the mocked `runtime-accessors`. That is a
- * property of the transform rather than of import order — verified by running,
- * not assumed, since no other file in this package had done it this way.
- */
-async function runOnce(turns: { text?: string }[]): Promise<void> {
-	const dir = await mkdtemp(join(tmpdir(), 'namzu-chatspan-'))
-	workdirs.push(dir)
-
-	await drainQuery({
-		provider: new MockLLMProvider({ turns: turns as never }),
-		tools: new ToolRegistry(),
-		runConfig: {
-			model: 'mock-model',
-			timeoutMs: 30_000,
-			tokenBudget: 100_000,
-			maxIterations: 3,
-			maxResponseTokens: 256,
-			temperature: 0.3,
-		},
-		agentId: 'agent_cs',
-		agentName: 'Chat Span Agent',
-		workingDirectory: dir,
-		sessionId: 'ses_cs',
-		threadId: 'thd_cs',
-		projectId: 'prj_cs',
-		tenantId: 'tnt_cs',
-		messages: [createUserMessage('go')],
-	} as never)
-}
-
-const chatSpans = () => spans.filter((s) => s.name.startsWith('chat '))
-
-describe('the model call has a span of its own', () => {
-	it('opens one named for the model', async () => {
-		await runOnce([{ text: 'done' }])
-
-		// EXACTLY one. This was written as `toHaveLength(1)`, failed with 2,
-		// and was relaxed to `>= 1` under a plausible-sounding explanation
-		// about forced-final turns. The 2 was real: a second span with the
-		// same name and the same parent had been added beside the one
-		// `stream-turn.ts` already opened, so a naive sum double-counted both
-		// latency and tokens. Relaxing the assertion is what let that ship.
-		expect(chatSpans()).toHaveLength(1)
-		expect(chatSpans()[0]?.name).toBe('chat mock-model')
-	})
-
-	it('closes it', async () => {
-		await runOnce([{ text: 'done' }])
-
-		for (const s of chatSpans()) expect(s.ended).toBe(true)
-	})
-
-	it('carries the request parameters that were actually used', async () => {
-		await runOnce([{ text: 'done' }])
-
-		const attrs = chatSpans()[0]?.attributes ?? {}
-		expect(attrs['gen_ai.operation.name']).toBe('chat')
-		expect(attrs['gen_ai.request.model']).toBe('mock-model')
-		expect(attrs['gen_ai.request.temperature']).toBe(0.3)
-		expect(attrs['gen_ai.request.max_tokens']).toBe(256)
-	})
-
-	it('carries the usage on the call that produced it', async () => {
-		await runOnce([{ text: 'done' }])
-
-		const attrs = chatSpans()[0]?.attributes ?? {}
-		// These previously landed only on the iteration span — one level up
-		// from the operation that spent the tokens.
-		expect(attrs).toHaveProperty('gen_ai.usage.input_tokens')
-		expect(attrs).toHaveProperty('gen_ai.usage.output_tokens')
-	})
-
-	it('records what the response said it was, not only what was asked for', async () => {
-		await runOnce([{ text: 'done' }])
-
-		const attrs = chatSpans()[0]?.attributes ?? {}
-		// A provider may answer on a different model than the alias asked
-		// for, and the response id is how a trace is matched to a provider's
-		// own logs. Both constants existed and neither was ever set.
-		expect(attrs['gen_ai.response.model']).toBe('mock-model')
-		expect(attrs['gen_ai.response.id']).toBeDefined()
-	})
-
-	it('records the finish reason as an array, per the convention', async () => {
-		await runOnce([{ text: 'done' }])
-
-		// One call can finish several ways when a provider returns more than
-		// one choice, which is why the convention makes it a list.
-		expect(Array.isArray(chatSpans()[0]?.attributes['gen_ai.response.finish_reasons'])).toBe(true)
-	})
-
-	it('reports cache tokens, which had constants and no producer', async () => {
-		await runOnce([{ text: 'done' }])
-
-		const attrs = chatSpans()[0]?.attributes ?? {}
-		expect(attrs).toHaveProperty('namzu.cache.read_tokens')
-		expect(attrs).toHaveProperty('namzu.cache.write_tokens')
-	})
-
-	it('opens exactly one per model call, however many turns a run takes', async () => {
-		await runOnce([{ text: 'first' }, { text: 'second' }])
-
-		// The count has to track model calls, not runs and not iterations —
-		// which is the only way a duplicate is visible at all.
-		const calls = spans.filter((s) => s.name.includes('iteration')).length
-		expect(chatSpans().length).toBeLessThanOrEqual(calls)
-	})
-
-	it('nests under the iteration span rather than emitting as a root', async () => {
-		await runOnce([{ text: 'done' }])
-
-		// The iteration span is created first; the chat span is parented to it
-		// explicitly because this body is an async generator and the ambient
-		// context at resume time belongs to the consumer.
-		const iterationIndex = spans.findIndex((s) => s.name.includes('iteration'))
-		const chatIndex = spans.findIndex((s) => s.name.startsWith('chat '))
-		expect(iterationIndex).toBeGreaterThanOrEqual(0)
-		expect(chatIndex).toBeGreaterThan(iterationIndex)
-	})
-})

package/src/telemetry/__tests__/span-closure.test.ts

@@ -1,160 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { z } from 'zod'
-// Imported at module scope on purpose, and must stay there.
-//
-// This was `await import(...)` repeated inside all five test bodies. That
-// billed the tool-registry module graph to whichever test happened to run
-// first, out of that test's own 5000ms deadline — and because every body
-// re-entered the same pending import, a stall did not fail one test, it took
-// the whole file down. At module scope the load happens during collection,
-// which has no per-test deadline.
-//
-// `vi.mock` is hoisted above every import here, so the static form still
-// receives the mocked `runtime-accessors`.
-import { ToolRegistry } from '../../registry/tool/execute.js'
-
-/**
- * A span that never ends is a trace that never closes, and the export is
- * incomplete for exactly the run that failed.
- *
- * Both sites had the same shape: an `end()` call at every exit the author
- * could see. The iteration loop had seventeen of them and the tool executor
- * three plus a `finally` that opened below them. That is a rule every future
- * edit has to remember, and it was already broken — anything throwing between
- * the span's creation and the `try` left it open, and a generator abandoned
- * by its consumer reached no exit at all.
- */
-
-const ended: string[] = []
-const started: string[] = []
-
-function fakeSpan(name: string) {
-	return {
-		setAttributes: () => undefined,
-		setAttribute: () => undefined,
-		setStatus: () => undefined,
-		recordException: () => undefined,
-		addEvent: () => undefined,
-		end: () => ended.push(name),
-		spanContext: () => ({ traceId: 't', spanId: 's', traceFlags: 1 }),
-		isRecording: () => true,
-		updateName: () => undefined,
-	}
-}
-
-vi.mock('../runtime-accessors.js', () => ({
-	getTracer: () => ({
-		startSpan: (name: string) => {
-			started.push(name)
-			return fakeSpan(name)
-		},
-		startActiveSpan: (
-			name: string,
-			_opts: unknown,
-			_ctx: unknown,
-			fn: (span: ReturnType<typeof fakeSpan>) => unknown,
-		) => {
-			started.push(name)
-			return fn(fakeSpan(name))
-		},
-	}),
-	getMeter: () => ({
-		createCounter: () => ({ add: () => undefined }),
-		createHistogram: () => ({ record: () => undefined }),
-	}),
-}))
-
-function toolContext() {
-	return {
-		runId: 'run_span',
-		workingDirectory: '.',
-		abortSignal: new AbortController().signal,
-		env: {},
-		log: () => undefined,
-	} as never
-}
-
-beforeEach(() => {
-	started.length = 0
-	ended.length = 0
-})
-
-afterEach(() => {
-	vi.clearAllMocks()
-})
-
-describe('a tool span closes however the call leaves', () => {
-	it('closes on the ordinary path', async () => {
-		const tools = new ToolRegistry()
-		tools.register({
-			name: 'echo',
-			description: 'echo',
-			inputSchema: z.object({}),
-			execute: async () => ({ success: true, output: 'ok' }),
-		})
-
-		await tools.execute('echo', {}, toolContext())
-
-		expect(started).toHaveLength(1)
-		expect(ended).toEqual(started)
-	})
-
-	it('closes when the tool throws', async () => {
-		const tools = new ToolRegistry()
-		tools.register({
-			name: 'boom',
-			description: 'boom',
-			inputSchema: z.object({}),
-			execute: async () => {
-				throw new Error('kaboom')
-			},
-		})
-
-		await tools.execute('boom', {}, toolContext())
-
-		expect(ended).toEqual(started)
-	})
-
-	it('closes when input validation refuses the call', async () => {
-		const tools = new ToolRegistry()
-		tools.register({
-			name: 'strict',
-			description: 'strict',
-			inputSchema: z.object({ required: z.string() }),
-			execute: async () => ({ success: true, output: 'ok' }),
-		})
-
-		await tools.execute('strict', { wrong: 1 }, toolContext())
-
-		expect(ended).toEqual(started)
-	})
-
-	it('closes when the tool is not active', async () => {
-		const tools = new ToolRegistry()
-		tools.register(
-			{
-				name: 'later',
-				description: 'later',
-				inputSchema: z.object({}),
-				execute: async () => ({ success: true, output: 'ok' }),
-			},
-			'deferred',
-		)
-
-		await tools.execute('later', {}, toolContext())
-
-		expect(ended).toEqual(started)
-	})
-
-	it('closes when the registry does not hold the name at all', async () => {
-		const tools = new ToolRegistry()
-
-		// `getOrThrow` sat OUTSIDE the try that owned the finally, so this
-		// path — the one where the model invents a tool name — opened a span
-		// and never closed it.
-		await expect(tools.execute('nonexistent', {}, toolContext())).rejects.toThrow()
-
-		expect(started).toHaveLength(1)
-		expect(ended).toEqual(started)
-	})
-})

package/src/telemetry/__tests__/span-hierarchy.test.ts

@@ -1,94 +0,0 @@
-import { type Span, SpanStatusCode, context as otelContext, trace } from '@opentelemetry/api'
-import { describe, expect, it } from 'vitest'
-
-import { parentContext } from '../attributes.js'
-
-/**
- * OTel's GenAI conventions define a strict hierarchy —
- * `invoke_agent` → `chat {model}` → `execute_tool` — and vendor dashboards
- * (Langfuse, Braintrust, Phoenix, Datadog) rely on it. namzu emitted every
- * span as a ROOT: a repo-wide grep for `context.with` / `trace.setSpan`
- * returned zero hits, so a single 20-iteration run produced 21 disconnected
- * traces with no waterfall and no LLM latency at all.
- *
- * The subtlety this file exists to pin: `startActiveSpan` does NOT hold
- * context across `yield`. Every span-owning body in the run loop is an async
- * generator, and a generator resumes on its CONSUMER's async context — so
- * the naive conversion silently fails to parent anything, and the only fix
- * that works is passing the parent explicitly.
- */
-
-/** Minimal in-memory span capture; avoids pulling in the SDK exporter. */
-function fakeSpan(name: string): Span {
-	return {
-		spanContext: () => ({ traceId: name, spanId: name, traceFlags: 1 }),
-		setAttribute: () => fakeSpan(name),
-		setAttributes: () => fakeSpan(name),
-		addEvent: () => fakeSpan(name),
-		setStatus: () => fakeSpan(name),
-		updateName: () => fakeSpan(name),
-		end: () => {},
-		isRecording: () => true,
-		recordException: () => {},
-		addLink: () => fakeSpan(name),
-		addLinks: () => fakeSpan(name),
-	} as unknown as Span
-}
-
-describe('parentContext', () => {
-	it('returns the ambient context when there is no parent', () => {
-		expect(parentContext(undefined)).toBe(otelContext.active())
-	})
-
-	it('puts the given span into the returned context', () => {
-		const parent = fakeSpan('run')
-		const ctx = parentContext(parent)
-		expect(trace.getSpan(ctx)).toBe(parent)
-	})
-
-	it('does not mutate the ambient context', () => {
-		const before = trace.getSpan(otelContext.active())
-		parentContext(fakeSpan('run'))
-		expect(trace.getSpan(otelContext.active())).toBe(before)
-	})
-
-	it('survives an await — which is exactly what the ambient context does not', async () => {
-		// This is the whole reason the helper exists. An explicit context is
-		// a value; the ambient one is per-async-scope and is gone by the time
-		// a generator resumes on its consumer's stack.
-		const parent = fakeSpan('run')
-		const ctx = parentContext(parent)
-		await Promise.resolve()
-		await new Promise((r) => setTimeout(r, 0))
-		expect(trace.getSpan(ctx)).toBe(parent)
-	})
-
-	it('demonstrates the failure mode it replaces', async () => {
-		// `context.with` establishes an ambient parent only for the
-		// synchronous body plus awaited continuations it owns. Reading it
-		// from a *separately scheduled* task sees nothing — which is the
-		// position every async generator in the run loop is in.
-		const parent = fakeSpan('run')
-		let observedInsideDetachedTask: Span | undefined
-
-		await otelContext.with(trace.setSpan(otelContext.active(), parent), async () => {
-			await new Promise<void>((resolve) => {
-				setTimeout(() => {
-					observedInsideDetachedTask = trace.getSpan(otelContext.active())
-					resolve()
-				}, 0)
-			})
-		})
-
-		expect(observedInsideDetachedTask).toBeUndefined()
-		// …while the explicit context still carries the parent.
-		expect(trace.getSpan(parentContext(parent))).toBe(parent)
-	})
-})
-
-describe('span status constants are the ones we stamp', () => {
-	it('uses OK / ERROR rather than ad-hoc strings', () => {
-		expect(SpanStatusCode.OK).toBeDefined()
-		expect(SpanStatusCode.ERROR).toBeDefined()
-	})
-})

package/src/test-setup.ts

@@ -1,24 +0,0 @@
-/**
- * Vitest `setupFiles` entry for `@namzu/sdk`.
- *
- * Silences the root logger for the entire test run. Tests that assert on
- * log output use their own mocked Logger instances (constructed via the
- * `makeLogger()` helpers colocated with each test) — those are not
- * affected by the root-level silence.
- *
- * The only thing this suppresses is the stderr spam produced by
- * production code paths that fall through to `getRootLogger()` — e.g.
- * `ToolRegistry.execute`'s zod-validation and thrown-error branches,
- * `ConnectorToolRouter.getTools`' per-instance error catch, the
- * AgentBus listener-throw handler, and every connector's `connect()`
- * info log. CI annotates any `[ERROR]` stderr line as a workflow
- * error; silencing the root logger during tests keeps the CI log
- * clean.
- *
- * This is test-only configuration. It runs before every test file and
- * does not affect consumers.
- */
-
-import { configureLogger } from './utils/logger.js'
-
-configureLogger({ level: 'silent' })

package/src/tools/__tests__/file-tool-containment.test.ts

@@ -1,190 +0,0 @@
-import { mkdirSync, mkdtempSync, readFileSync, symlinkSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { describe, expect, it } from 'vitest'
-
-import type { ToolContext } from '../../types/tool/index.js'
-import { EditTool } from '../builtins/edit.js'
-import { ReadFileTool } from '../builtins/read-file.js'
-import { WriteFileTool } from '../builtins/write-file.js'
-
-/**
- * `read`, `write` and `edit` all called `resolve(workingDirectory, input.path)`
- * bare. The search tools — `glob`, `grep`, `ls` — were contained; the three
- * that actually read and mutate user files were not, so `path: "../../.."`
- * reached whatever sits above the working directory with no sandbox involved.
- * `resolveWithin` existed the whole time, and its own docstring says the
- * filesystem tools never reached it.
- *
- * The second half is subtler and is why a lexical check alone was not the
- * answer. `atomicWriteFile` resolves its destination and writes THROUGH a
- * symlink on purpose, so that editing a linked file updates the target rather
- * than replacing the link with a regular file. Paired with a lexical check
- * that is check-then-follow: `./escape -> /elsewhere` climbs nothing on paper
- * and the write lands outside anyway. CWE-59; the ordering fix is CWE-22's
- * stated mitigation — canonicalize, then validate the canonical form.
- *
- * The over-rejection cases matter as much as the escapes. A containment check
- * that refuses legitimate paths is not a safer version of one that works, and
- * the trap is real: `os.tmpdir()` is itself a symlink on macOS, so
- * canonicalizing the candidate while comparing against a raw root would refuse
- * every path in a temp directory — including every path in this file.
- */
-
-function workspace() {
-	const root = mkdtempSync(join(tmpdir(), 'namzu-contain-'))
-	const outside = mkdtempSync(join(tmpdir(), 'namzu-outside-'))
-	writeFileSync(join(outside, 'secret.txt'), 'SECRET')
-	writeFileSync(join(root, 'inside.txt'), 'inside content')
-	return { root, outside }
-}
-
-const ctx = (root: string): ToolContext =>
-	({
-		runId: 'run_test' as ToolContext['runId'],
-		workingDirectory: root,
-		abortSignal: new AbortController().signal,
-		env: {},
-		log: () => {},
-	}) as unknown as ToolContext
-
-/**
- * Whether this host can create a symlink at all.
- *
- * Windows refuses without elevation or Developer Mode (`EPERM`), and the
- * first version of this file swallowed that per-test and returned early — so
- * three symlink tests reported PASSED on a machine where they had exercised
- * nothing. A test that cannot run must say so; a green tick for work that
- * did not happen is the failure this whole file exists to catch, one level
- * up. `skipIf` makes the reporter print it as skipped, and CI runs on Linux
- * where the probe succeeds and the cases actually execute.
- */
-const CAN_SYMLINK = (() => {
-	try {
-		const probeRoot = mkdtempSync(join(tmpdir(), 'namzu-symprobe-'))
-		symlinkSync(probeRoot, join(probeRoot, 'self'), 'dir')
-		return true
-	} catch {
-		return false
-	}
-})()
-
-describe('the file tools stay inside the working directory', () => {
-	it('read refuses a traversal', async () => {
-		const { root, outside } = workspace()
-		const climb = join('..', join(outside).split(/[\\/]/).pop() as string, 'secret.txt')
-
-		const result = await ReadFileTool.execute({ path: climb } as never, ctx(root))
-
-		expect(result.success).toBe(false)
-		expect(result.error).toMatch(/escapes the working directory/)
-	})
-
-	it('write refuses a traversal', async () => {
-		const { root } = workspace()
-
-		const result = await WriteFileTool.execute(
-			{ path: '../escaped.txt', content: 'nope' } as never,
-			ctx(root),
-		)
-
-		expect(result.success).toBe(false)
-		expect(result.error).toMatch(/escapes the working directory/)
-	})
-
-	it('edit refuses a traversal', async () => {
-		const { root } = workspace()
-
-		const result = await EditTool.execute(
-			{ path: '../escaped.txt', old_string: 'a', new_string: 'b' } as never,
-			ctx(root),
-		)
-
-		expect(result.success).toBe(false)
-		expect(result.error).toMatch(/escapes the working directory/)
-	})
-
-	it.skipIf(!CAN_SYMLINK)('write refuses a path that climbs out THROUGH a symlink', async () => {
-		const { root, outside } = workspace()
-		symlinkSync(outside, join(root, 'escape'), 'dir')
-
-		const result = await WriteFileTool.execute(
-			{ path: 'escape/planted.txt', content: 'nope' } as never,
-			ctx(root),
-		)
-
-		expect(result.success).toBe(false)
-		expect(result.error).toMatch(/escapes the working directory/)
-		// The whole point: nothing was written outside.
-		expect(() => readFileSync(join(outside, 'planted.txt'))).toThrow()
-	})
-
-	it.skipIf(!CAN_SYMLINK)(
-		'read refuses a file reached through a symlink out of the root',
-		async () => {
-			const { root, outside } = workspace()
-			symlinkSync(outside, join(root, 'escape'), 'dir')
-
-			const result = await ReadFileTool.execute({ path: 'escape/secret.txt' } as never, ctx(root))
-
-			expect(result.success).toBe(false)
-			expect(result.error).toMatch(/escapes the working directory/)
-		},
-	)
-
-	it.skipIf(!CAN_SYMLINK)(
-		'edit refuses a file reached through a symlink out of the root',
-		async () => {
-			const { root, outside } = workspace()
-			symlinkSync(join(outside, 'secret.txt'), join(root, 'linked.txt'), 'file')
-
-			const result = await EditTool.execute(
-				{ path: 'linked.txt', old_string: 'SECRET', new_string: 'REPLACED' } as never,
-				ctx(root),
-			)
-
-			expect(result.success).toBe(false)
-			expect(readFileSync(join(outside, 'secret.txt'), 'utf-8')).toBe('SECRET')
-		},
-	)
-})
-
-describe('the containment check does not over-reject', () => {
-	it('reads a file inside the root, whose temp root is itself a symlink on some platforms', async () => {
-		const { root } = workspace()
-
-		const result = await ReadFileTool.execute({ path: 'inside.txt' } as never, ctx(root))
-
-		expect(result.success).toBe(true)
-		expect(result.output).toContain('inside content')
-	})
-
-	it('creates a file that does not exist yet, in a directory that does not either', async () => {
-		const { root } = workspace()
-
-		const result = await WriteFileTool.execute(
-			{ path: 'nested/deeper/fresh.txt', content: 'hello' } as never,
-			ctx(root),
-		)
-
-		expect(result.success).toBe(true)
-		expect(readFileSync(join(root, 'nested', 'deeper', 'fresh.txt'), 'utf-8')).toBe('hello')
-	})
-
-	it.skipIf(!CAN_SYMLINK)('still follows a symlink that stays inside the root', async () => {
-		const { root } = workspace()
-		mkdirSync(join(root, 'real'))
-		writeFileSync(join(root, 'real', 'target.txt'), 'original')
-		symlinkSync(join(root, 'real', 'target.txt'), join(root, 'alias.txt'), 'file')
-
-		const result = await EditTool.execute(
-			{ path: 'alias.txt', old_string: 'original', new_string: 'updated' } as never,
-			ctx(root),
-		)
-
-		expect(result.success).toBe(true)
-		// Written THROUGH the link, so the link survives and the target moved —
-		// the behaviour `atomicWriteFile` exists to preserve.
-		expect(readFileSync(join(root, 'real', 'target.txt'), 'utf-8')).toBe('updated')
-	})
-})