@namzu/sdk 14.0.7 → 15.1.0

package/src/advisory/__tests__/consultation-context.test.ts

@@ -1,191 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-
-import type { AdvisorDefinition } from '../../types/advisory/index.js'
-import type { Message } from '../../types/message/index.js'
-import { AdvisoryContext } from '../context.js'
-import { TriggerEvaluator } from '../evaluator.js'
-import { AdvisoryExecutor } from '../executor.js'
-import { ADVISORY_RESPONSE_CONTRACT } from '../parse.js'
-import { AdvisorRegistry } from '../registry.js'
-
-/**
- * An advisor consulted BY THE MODEL saw the question and nothing else.
- *
- * Two paths reach `AdvisoryExecutor.consult`. The trigger path
- * (`iteration/phases/advisory.ts`) has always passed the live messages, the
- * working state and the tool catalogue. The tool path passed
- * `{ messages: [], iteration: 0 }` — a literal empty context — so the
- * model's own `include_context: true` had nothing to include, and the
- * advisor answered a question about a situation it could not see.
- */
-
-function recordingProvider(): { provider: AdvisorDefinition['provider']; calls: Message[][] } {
-	const calls: Message[][] = []
-	const provider = {
-		chatStream: async function* (params: { messages: Message[] }) {
-			calls.push(params.messages)
-			yield { id: 'a1', delta: { content: 'ADVICE: do the thing' } }
-			yield {
-				id: 'a1',
-				delta: {},
-				finishReason: 'stop',
-				usage: { promptTokens: 1, completionTokens: 1, totalTokens: 2 },
-			}
-		},
-	} as unknown as AdvisorDefinition['provider']
-	return { provider, calls }
-}
-
-function advisor(over: Partial<AdvisorDefinition> = {}): AdvisorDefinition {
-	return {
-		id: 'adv_1',
-		name: 'Reviewer',
-		provider: recordingProvider().provider,
-		model: 'mock-model',
-		...over,
-	} as AdvisorDefinition
-}
-
-const log = {
-	debug: vi.fn(),
-	info: vi.fn(),
-	warn: vi.fn(),
-	error: vi.fn(),
-	child: () => log,
-} as never
-
-function contextFor(a: AdvisorDefinition): AdvisoryContext {
-	return new AdvisoryContext(
-		new AdvisorRegistry([a]),
-		new AdvisoryExecutor(log),
-		new TriggerEvaluator([]),
-	)
-}
-
-describe('the context a tool-initiated consultation is given', () => {
-	it('is empty until the runtime supplies one', () => {
-		const ctx = contextFor(advisor())
-
-		// The fallback exists for a context built without a runtime, and it is
-		// what every tool-initiated call used to get.
-		expect(ctx.callContext()).toEqual({ messages: [], iteration: 0 })
-	})
-
-	it('is the live run once the runtime wires it', () => {
-		const ctx = contextFor(advisor())
-		const messages: Message[] = [{ role: 'user', content: 'the situation', timestamp: 1 }]
-
-		ctx.setCallContextProvider(() => ({ messages, iteration: 7 }))
-
-		expect(ctx.callContext().messages).toBe(messages)
-		expect(ctx.callContext().iteration).toBe(7)
-	})
-
-	it('is read at call time, not at construction', () => {
-		const ctx = contextFor(advisor())
-		let iteration = 1
-		ctx.setCallContextProvider(() => ({ messages: [], iteration }))
-
-		iteration = 4
-
-		// The tool is built once per run and called at an unknown later point.
-		// A snapshot would hand every advisor the state the run started with.
-		expect(ctx.callContext().iteration).toBe(4)
-	})
-})
-
-describe('what the advisor actually receives', () => {
-	it('sees the conversation when context is included', async () => {
-		const { provider, calls } = recordingProvider()
-		const executor = new AdvisoryExecutor(log)
-
-		await executor.consult(
-			advisor({ provider }),
-			{ advisorId: 'adv_1', question: 'what next?', includeContext: true },
-			{ messages: [{ role: 'user', content: 'deploy is failing', timestamp: 1 }], iteration: 2 },
-		)
-
-		const sent = JSON.stringify(calls[0])
-		expect(sent).toContain('deploy is failing')
-	})
-
-	it('sees none of it when the caller says not to', async () => {
-		const { provider, calls } = recordingProvider()
-		const executor = new AdvisoryExecutor(log)
-
-		await executor.consult(
-			advisor({ provider }),
-			{ advisorId: 'adv_1', question: 'what next?', includeContext: false },
-			{ messages: [{ role: 'user', content: 'deploy is failing', timestamp: 1 }], iteration: 2 },
-		)
-
-		expect(JSON.stringify(calls[0])).not.toContain('deploy is failing')
-	})
-
-	it('is told when the caller marked the request urgent', async () => {
-		const { provider, calls } = recordingProvider()
-		const executor = new AdvisoryExecutor(log)
-
-		await executor.consult(
-			advisor({ provider }),
-			{ advisorId: 'adv_1', question: 'what next?', urgency: 'high' },
-			{ messages: [], iteration: 1 },
-		)
-
-		// The value used to reach exactly one debug log line, so 'high' and
-		// 'low' produced byte-identical requests.
-		expect(String(calls[0]?.[0]?.content)).toContain('URGENT')
-	})
-
-	it('is told when there is room to consider alternatives', async () => {
-		const { provider, calls } = recordingProvider()
-		const executor = new AdvisoryExecutor(log)
-
-		await executor.consult(
-			advisor({ provider }),
-			{ advisorId: 'adv_1', question: 'what next?', urgency: 'low' },
-			{ messages: [], iteration: 1 },
-		)
-
-		expect(String(calls[0]?.[0]?.content)).toContain('low urgency')
-	})
-
-	it("appends nothing at all for 'normal', which is the point of not stating it", async () => {
-		const { provider, calls } = recordingProvider()
-		const executor = new AdvisoryExecutor(log)
-		const a = advisor({ provider })
-
-		await executor.consult(
-			a,
-			{ advisorId: 'adv_1', question: 'what next?', urgency: 'normal' },
-			{ messages: [], iteration: 1 },
-		)
-		await executor.consult(
-			a,
-			{ advisorId: 'adv_1', question: 'what next?', urgency: 'high' },
-			{ messages: [], iteration: 1 },
-		)
-
-		// Asserting "does not contain the other two phrases" is too weak — it
-		// would let ANY new sentence in. The response contract is the last
-		// thing the prompt says when urgency contributes nothing, so ending on
-		// it is what "appended nothing" actually means.
-		expect(String(calls[0]?.[0]?.content).trimEnd().endsWith(ADVISORY_RESPONSE_CONTRACT)).toBe(true)
-		expect(String(calls[1]?.[0]?.content).trimEnd().endsWith(ADVISORY_RESPONSE_CONTRACT)).toBe(
-			false,
-		)
-	})
-
-	it('says nothing about urgency when the caller did not', async () => {
-		const { provider, calls } = recordingProvider()
-		const executor = new AdvisoryExecutor(log)
-
-		await executor.consult(
-			advisor({ provider }),
-			{ advisorId: 'adv_1', question: 'what next?' },
-			{ messages: [], iteration: 1 },
-		)
-
-		expect(String(calls[0]?.[0]?.content).trimEnd().endsWith(ADVISORY_RESPONSE_CONTRACT)).toBe(true)
-	})
-})

package/src/advisory/__tests__/structured-response.test.ts

@@ -1,128 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-
-import type { AdvisorDefinition } from '../../types/advisory/index.js'
-import type { StreamChunk } from '../../types/provider/index.js'
-import { AdvisoryExecutor } from '../executor.js'
-import { ADVISORY_RESPONSE_CONTRACT, parseAdvisoryResponse } from '../parse.js'
-
-/**
- * `AdvisoryResult.warnings` and `.decisions` had two consumers each — the
- * advisory phase folds decisions into working state and renders warnings
- * back to the executing agent, and the advisory tool renders both — and no
- * producer at all. The parser returned `{ advice }` and a comment saying
- * structure came later. Every consumer branch was dead in a real run, and
- * their tests passed because they built the result by hand.
- */
-
-describe('an advisor answer is read back into its parts', () => {
-	it('lifts warnings and decisions out of the prose', () => {
-		const parsed = parseAdvisoryResponse(
-			[
-				'Proceed, but slowly.',
-				'<warnings>',
-				'- the store is not transactional',
-				'- retries are not idempotent',
-				'</warnings>',
-				'<decisions>',
-				'- keep the existing schema',
-				'</decisions>',
-			].join('\n'),
-		)
-
-		expect(parsed.warnings).toEqual([
-			'the store is not transactional',
-			'retries are not idempotent',
-		])
-		expect(parsed.decisions).toEqual(['keep the existing schema'])
-	})
-
-	it('leaves the blocks out of the advice, so nothing is said twice', () => {
-		const parsed = parseAdvisoryResponse('Do it.\n<warnings>\n- careful\n</warnings>')
-
-		expect(parsed.advice).toBe('Do it.')
-		expect(parsed.advice).not.toContain('careful')
-	})
-
-	it('accepts whichever bullet the model reached for', () => {
-		const parsed = parseAdvisoryResponse('<decisions>\n1. first\n* second\n• third\n</decisions>')
-
-		expect(parsed.decisions).toEqual(['first', 'second', 'third'])
-	})
-
-	it('omits the fields entirely rather than reporting empty ones', () => {
-		const parsed = parseAdvisoryResponse('Just advice.\n<warnings>\n\n</warnings>')
-
-		expect(parsed.advice).toBe('Just advice.')
-		expect(parsed.warnings).toBeUndefined()
-		expect(parsed.decisions).toBeUndefined()
-	})
-
-	it('treats an unclosed block as prose instead of guessing where it ends', () => {
-		const parsed = parseAdvisoryResponse('Careful.\n<warnings>\n- half a thought')
-
-		expect(parsed.warnings).toBeUndefined()
-		expect(parsed.advice).toContain('half a thought')
-	})
-
-	it('reads a plain answer as pure advice', () => {
-		expect(parseAdvisoryResponse('  Ship it.  ')).toEqual({ advice: 'Ship it.' })
-	})
-})
-
-describe('every advisor is told the convention its answer is read with', () => {
-	function capturingProvider(seen: { system?: string }) {
-		return {
-			chatStream: vi.fn(async function* (params: {
-				messages: Array<{ role: string; content: string | null }>
-			}): AsyncGenerator<StreamChunk> {
-				seen.system = params.messages.find((m) => m.role === 'system')?.content ?? undefined
-				yield { id: 'r', delta: { content: 'ok' } } as StreamChunk
-				yield {
-					id: 'r',
-					delta: {},
-					finishReason: 'stop',
-					usage: {
-						promptTokens: 0,
-						completionTokens: 0,
-						totalTokens: 0,
-						cachedTokens: 0,
-						cacheWriteTokens: 0,
-					},
-				} as StreamChunk
-			}),
-		} as unknown as AdvisorDefinition['provider']
-	}
-
-	async function systemPromptFor(advisor: Partial<AdvisorDefinition>): Promise<string> {
-		const seen: { system?: string } = {}
-		await new AdvisoryExecutor().consult(
-			{ id: 'a', name: 'A', model: 'm', provider: capturingProvider(seen), ...advisor },
-			{ question: 'q' },
-			{ messages: [], iteration: 1 },
-		)
-		return seen.system ?? ''
-	}
-
-	it('appends the contract to the default prompt', async () => {
-		expect(await systemPromptFor({})).toContain(ADVISORY_RESPONSE_CONTRACT)
-	})
-
-	// The failure that hides: a host writes its own prompt, the advisor is
-	// never told the convention, and its warnings are silently unparseable.
-	it('appends it to a host-written prompt too, without discarding that prompt', async () => {
-		const prompt = await systemPromptFor({ systemPrompt: 'You are terse.' })
-
-		expect(prompt).toContain('You are terse.')
-		expect(prompt).toContain(ADVISORY_RESPONSE_CONTRACT)
-	})
-
-	it('appends it to a persona-assembled prompt too', async () => {
-		const prompt = await systemPromptFor({
-			persona: {
-				identity: { role: 'reviewer', description: 'Reviews plans.' },
-			} as AdvisorDefinition['persona'],
-		})
-
-		expect(prompt).toContain(ADVISORY_RESPONSE_CONTRACT)
-	})
-})

package/src/advisory/context.test.ts

@@ -1,109 +0,0 @@
-/**
- * Current-code invariants asserted (2026-04-21, ses_006 Phase 6):
- *
- *   - `AdvisoryContext` composes a registry + executor + evaluator +
- *     optional budget. It is a dumb container + a call-history log.
- *   - `recordCall(record)` appends to `callHistory` in call order.
- *   - `getBudgetStatus()`:
- *     - `used` = `callHistory.length`.
- *     - `total` = `budget?.maxCallsPerRun` (undefined when no budget).
- *     - `remaining` = total − used when total defined; undefined else.
- *   - `checkBudget()`:
- *     - Allowed when no budget OR remaining > 0.
- *     - Denied with reason when remaining ≤ 0.
- */
-
-import { describe, expect, it } from 'vitest'
-
-import type { AdvisoryCallRecord } from '../types/advisory/index.js'
-
-import { AdvisoryContext } from './context.js'
-import type { TriggerEvaluator } from './evaluator.js'
-import type { AdvisoryExecutor } from './executor.js'
-import type { AdvisorRegistry } from './registry.js'
-
-function stubRegistry(): AdvisorRegistry {
-	return {} as unknown as AdvisorRegistry
-}
-
-function stubExecutor(): AdvisoryExecutor {
-	return {} as unknown as AdvisoryExecutor
-}
-
-function stubEvaluator(): TriggerEvaluator {
-	return {} as unknown as TriggerEvaluator
-}
-
-function callRecord(id: string): AdvisoryCallRecord {
-	return {
-		advisorId: id,
-		request: { question: 'q' },
-		result: { advice: 'a' },
-		usage: {
-			promptTokens: 0,
-			completionTokens: 0,
-			totalTokens: 0,
-			cachedTokens: 0,
-			cacheWriteTokens: 0,
-		},
-		cost: { inputCostPer1M: 0, outputCostPer1M: 0, totalCost: 0, cacheDiscount: 0 },
-		durationMs: 0,
-		iteration: 0,
-		timestamp: Date.now(),
-	}
-}
-
-describe('AdvisoryContext', () => {
-	it('starts with empty callHistory', () => {
-		const ctx = new AdvisoryContext(stubRegistry(), stubExecutor(), stubEvaluator())
-		expect(ctx.callHistory).toEqual([])
-	})
-
-	it('recordCall appends in order', () => {
-		const ctx = new AdvisoryContext(stubRegistry(), stubExecutor(), stubEvaluator())
-		ctx.recordCall(callRecord('a'))
-		ctx.recordCall(callRecord('b'))
-		expect(ctx.callHistory.map((r) => r.advisorId)).toEqual(['a', 'b'])
-	})
-
-	describe('getBudgetStatus', () => {
-		it('no budget → total + remaining undefined; used reflects history length', () => {
-			const ctx = new AdvisoryContext(stubRegistry(), stubExecutor(), stubEvaluator())
-			ctx.recordCall(callRecord('a'))
-			expect(ctx.getBudgetStatus()).toEqual({ used: 1, total: undefined, remaining: undefined })
-		})
-
-		it('with budget → total + remaining computed', () => {
-			const ctx = new AdvisoryContext(stubRegistry(), stubExecutor(), stubEvaluator(), {
-				maxCallsPerRun: 3,
-			})
-			ctx.recordCall(callRecord('a'))
-			expect(ctx.getBudgetStatus()).toEqual({ used: 1, total: 3, remaining: 2 })
-		})
-	})
-
-	describe('checkBudget', () => {
-		it('allowed when no budget', () => {
-			const ctx = new AdvisoryContext(stubRegistry(), stubExecutor(), stubEvaluator())
-			expect(ctx.checkBudget()).toEqual({ allowed: true })
-		})
-
-		it('allowed when remaining > 0', () => {
-			const ctx = new AdvisoryContext(stubRegistry(), stubExecutor(), stubEvaluator(), {
-				maxCallsPerRun: 2,
-			})
-			ctx.recordCall(callRecord('a'))
-			expect(ctx.checkBudget()).toEqual({ allowed: true })
-		})
-
-		it('denied when remaining <= 0', () => {
-			const ctx = new AdvisoryContext(stubRegistry(), stubExecutor(), stubEvaluator(), {
-				maxCallsPerRun: 1,
-			})
-			ctx.recordCall(callRecord('a'))
-			const result = ctx.checkBudget()
-			expect(result.allowed).toBe(false)
-			expect(result.reason).toMatch(/budget exhausted/)
-		})
-	})
-})

package/src/advisory/evaluator.test.ts

@@ -1,192 +0,0 @@
-/**
- * Current-code invariants asserted (2026-04-21, ses_006 Phase 6):
- *
- *   - Constructor filters OUT triggers with `enabled: false` + sorts
- *     by `priority` desc (higher first). Triggers without priority
- *     sort at 0.
- *   - `evaluate(state)` returns every trigger whose condition matches
- *     AND whose cooldown has elapsed. Order reflects the sorted
- *     trigger list.
- *   - Budget exhausted (callCount ≥ maxCallsPerRun) → evaluate returns [].
- *   - `recordFiring(id, iteration)` updates both `lastFiredMap` (for
- *     cooldown) and `callCount` (for budget).
- *   - Condition matchers:
- *     - `on_error`: matches iff state.lastError is set; if categories
- *       are given, requires at least one category substring match.
- *     - `on_iteration`: `state.iteration % everyN === 0`.
- *     - `on_context_percent`: `state.contextWindowPercent >= threshold`.
- *     - `on_tool_category`: `state.lastToolCategory` present + in
- *       `condition.categories`.
- *     - `on_cost_percent`: costBudgetPercent present + ≥ threshold.
- *     - `on_complexity`: totalToolCalls ≥ toolCallThreshold.
- *     - `custom`: calls the predicate.
- *   - Cooldown: trigger does NOT fire if `iteration - lastFired <
- *     cooldownIterations`. No cooldown → always eligible.
- *
- *   - **Purity:** evaluate() is pure relative to the advisory phase —
- *     it returns triggers; it does NOT inject messages or mutate
- *     external state. The injection happens in the advisory phase
- *     (runtime/query/iteration/phases/advisory.ts), which pushes a
- *     user message via `runMgr.pushMessage`. That file is OUT of
- *     scope for this test file (covered by the phase test).
- */
-
-import { describe, expect, it, vi } from 'vitest'
-
-import type { AdvisoryTrigger, TriggerEvaluationState } from '../types/advisory/index.js'
-
-import { TriggerEvaluator } from './evaluator.js'
-
-function trigger(id: string, overrides: Partial<AdvisoryTrigger> = {}): AdvisoryTrigger {
-	return {
-		id,
-		condition: { type: 'on_iteration', everyN: 1 },
-		...overrides,
-	}
-}
-
-function state(overrides: Partial<TriggerEvaluationState> = {}): TriggerEvaluationState {
-	return {
-		iteration: 1,
-		totalToolCalls: 0,
-		totalTokens: 0,
-		contextWindowPercent: 0,
-		totalCostUsd: 0,
-		costBudgetPercent: undefined,
-		lastError: undefined,
-		lastToolCategory: undefined,
-		advisoryCallCount: 0,
-		...overrides,
-	}
-}
-
-describe('TriggerEvaluator — constructor', () => {
-	it('filters out triggers with enabled: false', () => {
-		const e = new TriggerEvaluator([trigger('a'), trigger('b', { enabled: false })])
-		expect(e.evaluate(state()).map((t) => t.id)).toEqual(['a'])
-	})
-
-	it('sorts triggers by priority descending', () => {
-		const e = new TriggerEvaluator([
-			trigger('low', { priority: 1 }),
-			trigger('high', { priority: 10 }),
-			trigger('mid', { priority: 5 }),
-		])
-		expect(e.evaluate(state()).map((t) => t.id)).toEqual(['high', 'mid', 'low'])
-	})
-})
-
-describe('TriggerEvaluator — budget', () => {
-	it('returns [] when callCount >= maxCallsPerRun', () => {
-		const e = new TriggerEvaluator([trigger('a')], { maxCallsPerRun: 1 })
-		e.recordFiring('a', 1)
-		expect(e.evaluate(state({ iteration: 2 }))).toEqual([])
-	})
-
-	it('ignores budget when maxCallsPerRun is not set', () => {
-		const e = new TriggerEvaluator([trigger('a')])
-		e.recordFiring('a', 1)
-		e.recordFiring('a', 2)
-		expect(e.evaluate(state({ iteration: 3 })).length).toBeGreaterThan(0)
-	})
-})
-
-describe('TriggerEvaluator — cooldown', () => {
-	it('blocks triggers in their cooldown window', () => {
-		const e = new TriggerEvaluator([trigger('a', { cooldownIterations: 3 })])
-		e.recordFiring('a', 1)
-		expect(e.evaluate(state({ iteration: 2 })).map((t) => t.id)).toEqual([])
-		expect(e.evaluate(state({ iteration: 3 })).map((t) => t.id)).toEqual([])
-		expect(e.evaluate(state({ iteration: 4 })).map((t) => t.id)).toEqual(['a'])
-	})
-
-	it('always fires when no cooldown is configured', () => {
-		const e = new TriggerEvaluator([trigger('a')])
-		e.recordFiring('a', 1)
-		expect(e.evaluate(state({ iteration: 2 })).map((t) => t.id)).toEqual(['a'])
-	})
-})
-
-describe('TriggerEvaluator — condition matchers', () => {
-	it('on_error: requires lastError to be set', () => {
-		const e = new TriggerEvaluator([trigger('t', { condition: { type: 'on_error' } })])
-		expect(e.evaluate(state())).toEqual([])
-		expect(e.evaluate(state({ lastError: 'boom' })).map((t) => t.id)).toEqual(['t'])
-	})
-
-	it('on_error with categories: at least one substring match', () => {
-		const e = new TriggerEvaluator([
-			trigger('t', { condition: { type: 'on_error', categories: ['timeout', 'permission'] } }),
-		])
-		expect(e.evaluate(state({ lastError: 'Connection timeout' })).map((t) => t.id)).toEqual(['t'])
-		expect(e.evaluate(state({ lastError: 'Syntax error' }))).toEqual([])
-	})
-
-	it('on_iteration: iteration % everyN === 0', () => {
-		const e = new TriggerEvaluator([
-			trigger('t', { condition: { type: 'on_iteration', everyN: 3 } }),
-		])
-		expect(e.evaluate(state({ iteration: 1 }))).toEqual([])
-		expect(e.evaluate(state({ iteration: 3 })).map((t) => t.id)).toEqual(['t'])
-		expect(e.evaluate(state({ iteration: 6 })).map((t) => t.id)).toEqual(['t'])
-	})
-
-	it('on_context_percent: contextWindowPercent >= threshold', () => {
-		const e = new TriggerEvaluator([
-			trigger('t', { condition: { type: 'on_context_percent', threshold: 80 } }),
-		])
-		expect(e.evaluate(state({ contextWindowPercent: 70 }))).toEqual([])
-		expect(e.evaluate(state({ contextWindowPercent: 80 })).map((t) => t.id)).toEqual(['t'])
-	})
-
-	it('on_tool_category: lastToolCategory present + in categories list', () => {
-		const e = new TriggerEvaluator([
-			trigger('t', {
-				condition: { type: 'on_tool_category', categories: ['network', 'filesystem'] },
-			}),
-		])
-		expect(e.evaluate(state())).toEqual([])
-		expect(e.evaluate(state({ lastToolCategory: 'other' }))).toEqual([])
-		expect(e.evaluate(state({ lastToolCategory: 'network' })).map((t) => t.id)).toEqual(['t'])
-	})
-
-	it('on_cost_percent: costBudgetPercent present + >= threshold', () => {
-		const e = new TriggerEvaluator([
-			trigger('t', { condition: { type: 'on_cost_percent', threshold: 75 } }),
-		])
-		expect(e.evaluate(state())).toEqual([]) // undefined costBudgetPercent
-		expect(e.evaluate(state({ costBudgetPercent: 50 }))).toEqual([])
-		expect(e.evaluate(state({ costBudgetPercent: 80 })).map((t) => t.id)).toEqual(['t'])
-	})
-
-	it('on_complexity: totalToolCalls >= toolCallThreshold', () => {
-		const e = new TriggerEvaluator([
-			trigger('t', { condition: { type: 'on_complexity', toolCallThreshold: 10 } }),
-		])
-		expect(e.evaluate(state({ totalToolCalls: 5 }))).toEqual([])
-		expect(e.evaluate(state({ totalToolCalls: 10 })).map((t) => t.id)).toEqual(['t'])
-	})
-
-	it('custom: calls the predicate with state', () => {
-		const predicate = vi.fn(() => true)
-		const e = new TriggerEvaluator([trigger('t', { condition: { type: 'custom', predicate } })])
-		const s = state({ iteration: 42 })
-		expect(e.evaluate(s).map((t) => t.id)).toEqual(['t'])
-		expect(predicate).toHaveBeenCalledWith(s)
-	})
-})
-
-describe('TriggerEvaluator — recordFiring', () => {
-	it('updates lastFiredMap + callCount', () => {
-		const e = new TriggerEvaluator([trigger('a', { cooldownIterations: 5 })], {
-			maxCallsPerRun: 2,
-		})
-		e.recordFiring('a', 1)
-		// cooldown active: no fires in iterations 2–5
-		expect(e.evaluate(state({ iteration: 2 }))).toEqual([])
-		// cooldown lifted at 6, but budget allows one more
-		e.recordFiring('a', 6)
-		// budget exhausted
-		expect(e.evaluate(state({ iteration: 11 }))).toEqual([])
-	})
-})