@namzu/sdk 14.0.7 → 15.0.0

package/src/directory/__tests__/load-directory.test.ts

@@ -1,243 +0,0 @@
-import { mkdirSync, mkdtempSync, symlinkSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { describe, expect, it } from 'vitest'
-
-import { loadDirectory } from '../load.js'
-
-/**
- * Every case builds a real directory and reads it. A fixture object standing
- * in for the filesystem would pass while the scan, the import and the
- * containment check all did the wrong thing — and the whole package is those
- * three things.
- *
- * `.js` is used for tool files rather than `.ts`. Node's type stripping is
- * real and the loader accepts both, but a test that depends on it would be
- * testing Node's version rather than this code.
- */
-
-const CAN_SYMLINK = (() => {
-	try {
-		const probe = mkdtempSync(join(tmpdir(), 'namzu-proj-sym-'))
-		symlinkSync(probe, join(probe, 'self'), 'dir')
-		return true
-	} catch {
-		return false
-	}
-})()
-
-function project(files: Record<string, string>): string {
-	const root = mkdtempSync(join(tmpdir(), 'namzu-proj-'))
-	for (const [relative, body] of Object.entries(files)) {
-		const full = join(root, relative)
-		mkdirSync(join(full, '..'), { recursive: true })
-		writeFileSync(full, body)
-	}
-	return root
-}
-
-const TOOL = (name: string) => `
-export default {
-  name: ${JSON.stringify(name)},
-  description: 'a tool',
-  inputSchema: { parse: (v) => v, safeParse: (v) => ({ success: true, data: v }) },
-  execute: async () => ({ success: true, output: 'ok' }),
-}
-`
-
-describe('reading a project directory', () => {
-	it('loads instructions, config and tools', async () => {
-		const root = project({
-			'instructions.md': 'You are helpful.\n',
-			'agent.js': 'export default { model: "m", temperature: 0.2 }',
-			'tools/search.js': TOOL('search'),
-		})
-
-		const { manifest, ok, diagnostics } = await loadDirectory(root)
-
-		expect(ok, JSON.stringify(diagnostics)).toBe(true)
-		expect(manifest.instructions).toBe('You are helpful.')
-		expect(manifest.config).toMatchObject({ model: 'm', temperature: 0.2 })
-		expect(manifest.tools.map((t) => t.definition.name)).toEqual(['search'])
-	})
-
-	it('reports a broken tool instead of dropping it', async () => {
-		const root = project({
-			'instructions.md': 'hi',
-			'tools/good.js': TOOL('good'),
-			'tools/broken.js': 'this is not valid javascript !!!',
-		})
-
-		const { manifest, ok, diagnostics } = await loadDirectory(root)
-
-		expect(ok).toBe(false)
-		// The good one still loaded — one bad file does not lose the rest.
-		expect(manifest.tools.map((t) => t.definition.name)).toEqual(['good'])
-		const failure = diagnostics.find((d) => d.code === 'module_load_failed')
-		expect(failure?.path).toContain('broken')
-		expect(manifest.sources.find((s) => s.id === 'broken')?.outcome).toBe('failed')
-	})
-
-	it('refuses both files when two tools claim one name', async () => {
-		const root = project({
-			'instructions.md': 'hi',
-			'tools/a.js': TOOL('search'),
-			'tools/b.js': TOOL('search'),
-		})
-
-		const { manifest, ok, diagnostics } = await loadDirectory(root)
-
-		expect(ok).toBe(false)
-		expect(diagnostics.some((d) => d.code === 'duplicate_tool_name')).toBe(true)
-		// Picking a winner silently is what hides the mistake.
-		expect(manifest.tools).toHaveLength(1)
-	})
-
-	it('rejects a default export that is not a tool', async () => {
-		const root = project({
-			'instructions.md': 'hi',
-			'tools/x.js': 'export default { hello: 1 }',
-		})
-
-		const { ok, diagnostics } = await loadDirectory(root)
-
-		expect(ok).toBe(false)
-		expect(diagnostics.some((d) => d.code === 'not_a_tool')).toBe(true)
-	})
-
-	it('warns rather than errors when instructions are absent', async () => {
-		// `runAgent` treats instructions as optional; this package does not get
-		// to overrule the kernel about what a valid agent is.
-		const root = project({ 'tools/a.js': TOOL('a') })
-
-		const { ok, diagnostics } = await loadDirectory(root)
-
-		expect(ok).toBe(true)
-		expect(diagnostics.find((d) => d.code === 'instructions_missing')?.severity).toBe('warning')
-	})
-
-	it('errors on an instructions file that says nothing', async () => {
-		const root = project({ 'instructions.md': '   \n' })
-
-		const { ok, diagnostics } = await loadDirectory(root)
-
-		expect(ok).toBe(false)
-		expect(diagnostics.find((d) => d.code === 'instructions_empty')?.severity).toBe('error')
-	})
-
-	it('reports a malformed config field by name', async () => {
-		const root = project({
-			'instructions.md': 'hi',
-			'agent.js': 'export default { model: 42 }',
-		})
-
-		const { ok, diagnostics } = await loadDirectory(root)
-
-		expect(ok).toBe(false)
-		expect(diagnostics.find((d) => d.code === 'invalid_config')?.message).toContain('"model"')
-	})
-
-	it('ignores dot- and underscore-prefixed entries silently', async () => {
-		const root = project({
-			'instructions.md': 'hi',
-			'tools/real.js': TOOL('real'),
-			'tools/_helpers/util.js': 'export const x = 1',
-			'tools/.hidden.js': TOOL('hidden'),
-		})
-
-		const { manifest, ok, diagnostics } = await loadDirectory(root)
-
-		expect(ok).toBe(true)
-		expect(manifest.tools.map((t) => t.definition.name)).toEqual(['real'])
-		expect(diagnostics.some((d) => d.code === 'unscanned_directory')).toBe(false)
-	})
-
-	it('warns about a subdirectory it did not scan', async () => {
-		const root = project({
-			'instructions.md': 'hi',
-			'tools/nested/deep.js': TOOL('deep'),
-		})
-
-		const { diagnostics } = await loadDirectory(root)
-
-		expect(diagnostics.find((d) => d.code === 'unscanned_directory')?.message).toContain('nested')
-	})
-
-	it('reports a missing directory rather than throwing', async () => {
-		const { ok, diagnostics } = await loadDirectory(join(tmpdir(), 'namzu-does-not-exist-xyz'))
-
-		expect(ok).toBe(false)
-		expect(diagnostics[0]?.code).toBe('root_missing')
-	})
-
-	it('throws only on programmer error', async () => {
-		await expect(loadDirectory('' as string)).rejects.toThrow(TypeError)
-	})
-})
-
-describe('modules: skip', () => {
-	it('gives full structure without importing anything', async () => {
-		// The proof is the side effect: a module that would throw on import is
-		// listed, and nothing runs.
-		const root = project({
-			'instructions.md': 'You are helpful.',
-			'agent.js': 'throw new Error("agent.js executed")',
-			'tools/a.js': 'throw new Error("tool executed")',
-		})
-
-		const { manifest, ok } = await loadDirectory(root, { modules: 'skip' })
-
-		expect(ok).toBe(true)
-		expect(manifest.instructions).toBe('You are helpful.')
-		expect(manifest.sources.map((s) => s.id).sort()).toEqual(['a', 'agent', 'instructions'])
-		expect(
-			manifest.sources
-				.filter((s) => s.slot !== 'instructions')
-				.every((s) => s.outcome === 'not_loaded'),
-		).toBe(true)
-		expect(manifest.tools).toHaveLength(0)
-	})
-})
-
-describe('include is an allow-list', () => {
-	it('scans only what was asked for', async () => {
-		const root = project({ 'instructions.md': 'hi', 'tools/a.js': TOOL('a') })
-
-		const { manifest } = await loadDirectory(root, { include: ['tools'] })
-
-		expect(manifest.included).toEqual(['tools'])
-		expect(manifest.instructions).toBe('')
-		expect(manifest.tools).toHaveLength(1)
-	})
-
-	it('scans nothing when the list is empty', async () => {
-		// An allow-list that admits everything when empty is the fail-open
-		// shape this estate removed elsewhere.
-		const root = project({ 'instructions.md': 'hi', 'tools/a.js': TOOL('a') })
-
-		const { manifest } = await loadDirectory(root, {
-			include: [] as unknown as ['tools'],
-		})
-
-		expect(manifest.sources).toHaveLength(0)
-		expect(manifest.tools).toHaveLength(0)
-	})
-})
-
-describe('symlinks are refused, not followed', () => {
-	it.skipIf(!CAN_SYMLINK)('does not import a linked tool file', async () => {
-		const outside = mkdtempSync(join(tmpdir(), 'namzu-outside-'))
-		writeFileSync(join(outside, 'evil.js'), TOOL('evil'))
-		const root = project({
-			'instructions.md': 'hi',
-			'tools/real.js': TOOL('real'),
-		})
-		symlinkSync(join(outside, 'evil.js'), join(root, 'tools', 'linked.js'), 'file')
-
-		const { manifest, diagnostics } = await loadDirectory(root)
-
-		// The file that would be imported is not the file that was listed.
-		expect(manifest.tools.map((t) => t.definition.name)).toEqual(['real'])
-		expect(diagnostics.some((d) => d.code === 'symlink_refused')).toBe(true)
-	})
-})

package/src/directory/__tests__/subagents.test.ts

@@ -1,155 +0,0 @@
-import { mkdirSync, mkdtempSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { describe, expect, it } from 'vitest'
-
-import { deriveSupervisorOptions } from '../derive-supervisor.js'
-import { loadDirectory } from '../load.js'
-
-/**
- * `SupervisorAgent` needs an `agentIds` roster and a manager that can spawn
- * them. Nothing led from a directory to either, so a multi-agent system could
- * be described on disk and not run.
- *
- * Delegates are loaded by recursion — a delegate directory has the same shape
- * as its parent — capped at one level, because how deep a system may fan out
- * is a topology decision and a directory layout should not make it by default.
- */
-
-const provider = { id: 'mock', name: 'Mock' } as never
-const agentManager = { sendMessage: async () => ({}) } as never
-
-function tree(files: Record<string, string>): string {
-	const root = mkdtempSync(join(tmpdir(), 'namzu-sub-'))
-	for (const [relative, body] of Object.entries(files)) {
-		const full = join(root, relative)
-		mkdirSync(join(full, '..'), { recursive: true })
-		writeFileSync(full, body)
-	}
-	return root
-}
-
-const TOOL = (name: string) => `
-export default {
-  name: ${JSON.stringify(name)},
-  description: 'a tool',
-  inputSchema: { parse: (v) => v, safeParse: (v) => ({ success: true, data: v }) },
-  execute: async () => ({ success: true, output: 'ok' }),
-}
-`
-
-const SYSTEM = {
-	'instructions.md': 'You coordinate.',
-	'agent.js': 'export default { model: "coordinator-model" }',
-	'agents/researcher/instructions.md': 'You research.',
-	'agents/researcher/agent.js': 'export default { model: "cheap-model" }',
-	'agents/researcher/tools/search.js': TOOL('search'),
-	'agents/writer/instructions.md': 'You write.',
-}
-
-describe('a project that declares delegates', () => {
-	it('loads each one as a project in its own right', async () => {
-		const { manifest, ok, diagnostics } = await loadDirectory(tree(SYSTEM))
-
-		expect(ok, JSON.stringify(diagnostics)).toBe(true)
-		expect(manifest.agents.map((a) => a.id).sort()).toEqual(['researcher', 'writer'])
-
-		const researcher = manifest.agents.find((a) => a.id === 'researcher')
-		expect(researcher?.manifest.instructions).toBe('You research.')
-		expect(researcher?.manifest.tools.map((t) => t.definition.name)).toEqual(['search'])
-		expect(researcher?.manifest.config.model).toBe('cheap-model')
-	})
-
-	it('surfaces a delegate failure in the parent list', async () => {
-		// A delegate that could not load is a fact about THIS project. A caller
-		// reading one list should not have to walk the tree to discover the run
-		// will be short a specialist.
-		const { manifest, ok, diagnostics } = await loadDirectory(
-			tree({ ...SYSTEM, 'agents/writer/tools/bad.js': 'this is not valid !!!' }),
-		)
-
-		expect(ok).toBe(false)
-		expect(diagnostics.some((d) => d.message.startsWith('agents/writer:'))).toBe(true)
-		// The broken one is not offered as a delegate.
-		expect(manifest.agents.map((a) => a.id)).toEqual(['researcher'])
-	})
-
-	it('refuses to read a second level of delegates', async () => {
-		const { manifest, diagnostics } = await loadDirectory(
-			tree({
-				...SYSTEM,
-				'agents/researcher/agents/deeper/instructions.md': 'You are too deep.',
-			}),
-		)
-
-		const researcher = manifest.agents.find((a) => a.id === 'researcher')
-		expect(researcher?.manifest.agents).toHaveLength(0)
-		expect(diagnostics.some((d) => d.code === 'subagent_too_deep')).toBe(true)
-	})
-
-	it('imports nothing under modules: skip, delegates included', async () => {
-		const { manifest, ok } = await loadDirectory(
-			tree({
-				'instructions.md': 'hi',
-				'agents/x/instructions.md': 'hi',
-				'agents/x/tools/boom.js': 'throw new Error("executed")',
-			}),
-			{ modules: 'skip' },
-		)
-
-		expect(ok).toBe(true)
-		expect(manifest.sources.some((s) => s.slot === 'agents')).toBe(true)
-	})
-})
-
-describe('deriving supervisor options', () => {
-	it('builds the roster from the directory', async () => {
-		const { manifest } = await loadDirectory(tree(SYSTEM))
-
-		const { config, delegates } = deriveSupervisorOptions(manifest, { provider, agentManager })
-
-		expect(config.agentIds.sort()).toEqual(['researcher', 'writer'])
-		expect(config.systemPrompt).toBe('You coordinate.')
-		expect(config.model).toBe('coordinator-model')
-		expect(delegates).toHaveLength(2)
-	})
-
-	it('lets a delegate keep its own model and inherit when it has none', async () => {
-		// A cheap model for a narrow job is the common case; inheriting
-		// unconditionally would bill every specialist at the coordinator rate.
-		const { manifest } = await loadDirectory(tree(SYSTEM))
-		const { delegates } = deriveSupervisorOptions(manifest, { provider, agentManager })
-
-		expect(delegates.find((d) => d.id === 'researcher')?.model).toBe('cheap-model')
-		expect(delegates.find((d) => d.id === 'writer')?.model).toBe('coordinator-model')
-	})
-
-	it('carries each delegate its own instructions and tools', async () => {
-		const { manifest } = await loadDirectory(tree(SYSTEM))
-		const { delegates } = deriveSupervisorOptions(manifest, { provider, agentManager })
-
-		const researcher = delegates.find((d) => d.id === 'researcher')
-		expect(researcher?.systemPrompt).toBe('You research.')
-		expect(researcher?.tools.has('search')).toBe(true)
-	})
-
-	it('refuses a project with no delegates', async () => {
-		// An empty roster makes create_task unmountable, so the result would be
-		// a coordinator that cannot coordinate — and the caller asked for one.
-		const { manifest } = await loadDirectory(
-			tree({ 'instructions.md': 'hi', 'agent.js': 'export default { model: "m" }' }),
-		)
-
-		expect(() => deriveSupervisorOptions(manifest, { provider, agentManager })).toThrow(
-			/declares no delegates/,
-		)
-	})
-
-	it('refuses a manifest whose modules were never loaded', async () => {
-		const { manifest } = await loadDirectory(tree(SYSTEM), { modules: 'skip' })
-
-		expect(() => deriveSupervisorOptions(manifest, { provider, agentManager })).toThrow(
-			/modules: "skip"/,
-		)
-	})
-})

package/src/directory/__tests__/supervisor-budget.test.ts

@@ -1,117 +0,0 @@
-import { mkdirSync, mkdtempSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { describe, expect, it } from 'vitest'
-
-import { deriveSupervisorOptions } from '../derive-supervisor.js'
-import { loadDirectory } from '../load.js'
-
-/**
- * `BaseAgentConfig` declares `tokenBudget` and `timeoutMs` as REQUIRED, and
- * `deriveSupervisorOptions` supplied them only when `agent.ts` happened to
- * name them — which is the uncommon case. An `as SupervisorAgentConfig` made
- * that compile, so the returned object was typed `tokenBudget: number` while
- * holding `undefined`.
- *
- * The consequence is not a type-level nicety. `buildLimitConfig` defaults only
- * `maxIterations`, so an undefined budget and timeout disable BOTH hard stops
- * — a project-derived supervisor ran with no token cap and no wall clock. And
- * the child-spawn guard computes a delegate's allocation from the parent
- * budget, so `undefined` became `NaN`, and `NaN <= 0` is false: the refusal
- * that exists to stop an unfunded child let it through.
- *
- * The cast is now `satisfies`, which is what keeps this from recurring — but
- * a type check is not a test, so the values are asserted here too.
- */
-
-const provider = { id: 'mock', name: 'Mock' } as never
-const agentManager = { sendMessage: async () => ({}) } as never
-
-function tree(files: Record<string, string>): string {
-	const root = mkdtempSync(join(tmpdir(), 'namzu-budget-'))
-	for (const [relative, body] of Object.entries(files)) {
-		const full = join(root, relative)
-		mkdirSync(join(full, '..'), { recursive: true })
-		writeFileSync(full, body)
-	}
-	return root
-}
-
-const MINIMAL = {
-	'agent.js': 'export default { model: "m" }',
-	'agents/researcher/agent.js': 'export default { model: "m2" }',
-	'agents/researcher/instructions.md': 'Research things.',
-}
-
-describe('a derived supervisor always has a budget and a clock', () => {
-	it('defaults both when agent.ts names neither', async () => {
-		const { manifest } = await loadDirectory(tree(MINIMAL))
-		const { config } = deriveSupervisorOptions(manifest, { provider, agentManager })
-
-		// The exact numbers matter less than that they are finite: a NaN or an
-		// undefined here is what silently disabled the limits.
-		expect(Number.isFinite(config.tokenBudget)).toBe(true)
-		expect(Number.isFinite(config.timeoutMs)).toBe(true)
-		expect(config.tokenBudget).toBeGreaterThan(0)
-		expect(config.timeoutMs).toBeGreaterThan(0)
-	})
-
-	it('uses the same defaults the SDK front door uses', async () => {
-		// Imported from the module that owns them rather than through the
-		// package entry: this file now lives inside that package, and a
-		// self-import resolves to the built `dist`, not to the source under
-		// test — which is how a stale build reads as a passing test.
-		const { DEFAULT_TIMEOUT_MS, DEFAULT_TOKEN_BUDGET } = await import('../../agents/runAgent.js')
-		const { manifest } = await loadDirectory(tree(MINIMAL))
-		const { config } = deriveSupervisorOptions(manifest, { provider, agentManager })
-
-		// Two front doors that default differently is a difference nobody would
-		// find until a run behaved unlike its sibling.
-		expect(config.tokenBudget).toBe(DEFAULT_TOKEN_BUDGET)
-		expect(config.timeoutMs).toBe(DEFAULT_TIMEOUT_MS)
-	})
-
-	it('still honours what agent.ts declares', async () => {
-		const { manifest } = await loadDirectory(
-			tree({
-				...MINIMAL,
-				'agent.js': 'export default { model: "m", tokenBudget: 1234, timeoutMs: 5678 }',
-			}),
-		)
-		const { config } = deriveSupervisorOptions(manifest, { provider, agentManager })
-
-		expect(config.tokenBudget).toBe(1234)
-		expect(config.timeoutMs).toBe(5678)
-	})
-
-	it('lets an override win over both', async () => {
-		const { manifest } = await loadDirectory(tree(MINIMAL))
-		const { config } = deriveSupervisorOptions(manifest, {
-			provider,
-			agentManager,
-			overrides: { tokenBudget: 42 },
-		})
-
-		expect(config.tokenBudget).toBe(42)
-	})
-})
-
-describe('a derived supervisor carries the skills it loaded', () => {
-	it('passes skills through instead of dropping them', async () => {
-		const { manifest } = await loadDirectory(
-			tree({
-				...MINIMAL,
-				'skills/plan-a-trip/SKILL.md':
-					'---\nname: plan-a-trip\ndescription: Plan a trip\n---\n\nAsk for dates.',
-			}),
-		)
-		expect(manifest.skills).toHaveLength(1)
-
-		const { config } = deriveSupervisorOptions(manifest, { provider, agentManager })
-
-		// Loaded from disk, put on the manifest, and then — before this — left
-		// out of the config the supervisor actually runs with.
-		expect(config.skills).toHaveLength(1)
-		expect(config.skills?.[0]?.metadata.name).toBe('plan-a-trip')
-	})
-})

package/src/eval/__tests__/case-deadline.test.ts

@@ -1,147 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { runExperiment } from '../experiment.js'
-import type { EvalRun } from '../types.js'
-
-/**
- * `executeCase` was a bare await, so a `run` closure that never settled
- * blocked its worker and `runExperiment` never returned — no report, no
- * partial results, nothing to read.
- *
- * Narrower than it sounds: the documented path inherits three deadlines
- * from the runtime it drives. The residual is a closure that does not go
- * through `query()`, and a mid-iteration provider stall the
- * between-iterations guard cannot see. Both are reachable, and neither is
- * the suite's to absorb silently.
- */
-
-const emptyRun = (): EvalRun => ({
-	output: 'ok',
-	steps: [],
-	toolCalls: [],
-	totalTokens: 0,
-	totalCostUsd: 0,
-	durationMs: 0,
-})
-
-const never = () => new Promise<EvalRun>(() => {})
-
-const scorer = {
-	name: 'always-one',
-	score: async () => ({ score: 1, reason: 'fine' }),
-}
-
-describe('a case that never settles', () => {
-	it('is reported instead of hanging the suite', async () => {
-		const report = await runExperiment({
-			name: 'deadline',
-			cases: [{ name: 'hangs', input: null }],
-			scorers: [scorer],
-			timeoutMs: 20,
-			run: never,
-		})
-
-		expect(report.cases).toHaveLength(1)
-		expect(report.cases[0]?.run.error).toMatch(/timed out after 20ms/)
-	})
-
-	it('does not take the rest of the suite with it', async () => {
-		// Forty cases should not be lost to one that hung — the same rule
-		// the harness already applied to a case that threw.
-		const report = await runExperiment({
-			name: 'deadline',
-			cases: [
-				{ name: 'hangs', input: null },
-				{ name: 'fine', input: null },
-			],
-			scorers: [scorer],
-			timeoutMs: 20,
-			run: async (_input, evalCase) => (evalCase.name === 'hangs' ? await never() : emptyRun()),
-		})
-
-		expect(report.cases.map((c) => c.case).sort()).toEqual(['fine', 'hangs'])
-		expect(report.passed).toBe(1)
-		expect(report.failed).toBe(1)
-	})
-
-	it('reports the time it actually burned, not zero', async () => {
-		// A case that spent its whole deadline is the most interesting
-		// number in the report; zero would hide it.
-		const report = await runExperiment({
-			name: 'deadline',
-			cases: [{ name: 'hangs', input: null }],
-			scorers: [scorer],
-			timeoutMs: 30,
-			run: never,
-		})
-
-		expect(report.cases[0]?.run.durationMs).toBeGreaterThanOrEqual(20)
-	})
-})
-
-describe('the signal handed to run', () => {
-	it('fires when the deadline passes, so a cooperating closure can stop', async () => {
-		let aborted = false
-		await runExperiment({
-			name: 'deadline',
-			cases: [{ name: 'watches', input: null }],
-			scorers: [scorer],
-			timeoutMs: 20,
-			run: async (_input, _case, signal) => {
-				signal.addEventListener('abort', () => {
-					aborted = true
-				})
-				return await never()
-			},
-		})
-
-		expect(aborted).toBe(true)
-	})
-
-	it('stays quiet for a case that finished in time', async () => {
-		// A spurious abort after the work is done would train a closure to
-		// ignore the signal entirely.
-		let aborted = false
-		await runExperiment({
-			name: 'deadline',
-			cases: [{ name: 'fast', input: null }],
-			scorers: [scorer],
-			timeoutMs: 5_000,
-			run: async (_input, _case, signal) => {
-				signal.addEventListener('abort', () => {
-					aborted = true
-				})
-				return emptyRun()
-			},
-		})
-
-		expect(aborted).toBe(false)
-	})
-})
-
-describe('a suite with no deadline set', () => {
-	it('behaves exactly as before', async () => {
-		const report = await runExperiment({
-			name: 'no-deadline',
-			cases: [{ name: 'fine', input: null }],
-			scorers: [scorer],
-			run: async () => emptyRun(),
-		})
-
-		expect(report.passed).toBe(1)
-		expect(report.cases[0]?.run.error).toBeUndefined()
-	})
-
-	it('still turns a throw into a result rather than a crash', async () => {
-		const report = await runExperiment({
-			name: 'no-deadline',
-			cases: [{ name: 'throws', input: null }],
-			scorers: [scorer],
-			run: async () => {
-				throw new Error('broken case')
-			},
-		})
-
-		expect(report.cases[0]?.run.error).toBe('broken case')
-	})
-})