@namzu/sdk 2.0.0 → 3.0.0

package/src/bridge/sse/mapper.ts

@@ -33,6 +33,65 @@ const MAPPING: {
 		transform: (e, runId) => ({ run_id: runId, iteration: e.iteration }),
 	},
 
+	reasoning_started: {
+		wire: 'reasoning.started',
+		transform: (e, runId) => ({
+			run_id: runId,
+			iteration: e.iteration,
+			message_id: e.messageId,
+			block_index: e.blockIndex,
+			reasoning_type: e.reasoningType,
+		}),
+	},
+
+	reasoning_delta: {
+		wire: 'reasoning.delta',
+		transform: (e, runId) => ({
+			run_id: runId,
+			message_id: e.messageId,
+			block_index: e.blockIndex,
+			text: e.text,
+		}),
+	},
+
+	reasoning_completed: {
+		wire: 'reasoning.completed',
+		transform: (e, runId) => ({
+			run_id: runId,
+			iteration: e.iteration,
+			message_id: e.messageId,
+			block_index: e.blockIndex,
+			text: e.text,
+			signed: e.signed,
+		}),
+	},
+
+	guardrail_triggered: {
+		wire: 'guardrail.triggered',
+		transform: (e, runId) => ({
+			run_id: runId,
+			stage: e.stage,
+			action: e.action,
+			guardrail: e.guardrail,
+			reason: e.reason,
+		}),
+	},
+
+	compaction_completed: {
+		wire: 'compaction.completed',
+		transform: (e, runId) => ({
+			run_id: runId,
+			iteration: e.iteration,
+			messages_before: e.messagesBefore,
+			messages_after: e.messagesAfter,
+			tokens_before: e.tokensBefore,
+			tokens_after: e.tokensAfter,
+			measured_by: e.measuredBy,
+			context_window_tokens: e.contextWindowTokens,
+			window_source: e.windowSource,
+		}),
+	},
+
 	tool_executing: {
 		wire: 'tool.executing',
 		transform: (e, runId) => ({
@@ -43,6 +102,56 @@ const MAPPING: {
 		}),
 	},
 
+	// Ephemeral, like text_delta: a live view wants it, the durable record
+	// does not, and a chatty tool must not be able to bloat transcript.jsonl.
+	tool_progress: {
+		wire: 'tool.progress',
+		transform: (e, runId) => ({
+			run_id: runId,
+			tool_use_id: e.toolUseId,
+			tool_name: e.toolName,
+			message: e.message,
+			fraction: e.fraction,
+		}),
+	},
+
+	// Same reason as `tool_progress`, for the other half of a run's wall
+	// clock: a backoff can run for the better part of a minute, and without
+	// this the client gets no event and no keepalive for its duration.
+	provider_retry: {
+		wire: 'provider.retry',
+		transform: (e, runId) => ({
+			run_id: runId,
+			iteration: e.iteration,
+			attempt: e.attempt,
+			max_retries: e.maxRetries,
+			delay_ms: e.delayMs,
+			code: e.code,
+			status: e.status,
+			server_directed: e.serverDirected,
+		}),
+	},
+
+	user_question_asked: {
+		wire: 'question.asked',
+		transform: (e, runId) => ({
+			run_id: runId,
+			checkpoint_id: e.checkpointId,
+			question_id: e.questionId,
+			question: e.question,
+		}),
+	},
+
+	user_question_answered: {
+		wire: 'question.answered',
+		transform: (e, runId) => ({
+			run_id: runId,
+			checkpoint_id: e.checkpointId,
+			question_id: e.questionId ?? null,
+			answered: e.answered,
+		}),
+	},
+
 	tool_completed: {
 		wire: 'tool.completed',
 		transform: (e, runId) => ({

package/src/compaction/__tests__/cleared-result-recovery.test.ts

@@ -0,0 +1,118 @@
+import { describe, expect, it } from 'vitest'
+
+import { SPILL_MARKER } from '../../runtime/query/tool-output-budget.js'
+import type { Message } from '../../types/message/index.js'
+import { clearStaleToolResults, isClearedToolResult } from '../tool-result-editing.js'
+
+/**
+ * Clearing replaced the whole content with a placeholder, which destroyed
+ * the recovery pointer for exactly the results that most needed one.
+ *
+ * When a tool result exceeds the output budget its full text is written to
+ * disk and a line pointing at it is embedded IN the result. Clearing that
+ * result deleted the line — so the largest outputs lost the cheapest way
+ * back to them, and the placeholder then advised calling the tool again,
+ * which is advice to re-run something that returned megabytes.
+ */
+
+function history(resultText: string): Message[] {
+	return [
+		{ role: 'user', content: 'go' },
+		{
+			role: 'assistant',
+			content: null,
+			toolCalls: [{ id: 'c1', type: 'function', function: { name: 'bash', arguments: '{}' } }],
+		},
+		{ role: 'tool', toolCallId: 'c1', content: resultText },
+		{ role: 'user', content: 'next' },
+	] as Message[]
+}
+
+const clear = (messages: Message[]) =>
+	clearStaleToolResults(messages, { keepRecentToolResults: 0, minCharsToClear: 100 })
+
+const clearedText = (messages: Message[]): string => {
+	const tool = messages.find((m) => m.role === 'tool')
+	return String((tool as { content: string }).content)
+}
+
+describe('a spilled result', () => {
+	// The marker sits in the MIDDLE, outside both the head and the tail
+	// window. Left near the end it would ride along in the tail and the
+	// test would pass with the preservation removed.
+	const spilled = [
+		'first line of output',
+		'x'.repeat(5_000),
+		`${SPILL_MARKER} /runs/r1/tool-output/bash-1.txt`,
+		'Read a specific window with `read` (offset/limit) or search it with `grep`.',
+		'y'.repeat(5_000),
+	].join('\n')
+
+	it('keeps the pointer to the spilled file', () => {
+		const { messages } = clear(history(spilled))
+		// The line is the only route back to content the budget
+		// deliberately preserved on disk.
+		expect(clearedText(messages)).toContain('/runs/r1/tool-output/bash-1.txt')
+	})
+
+	it('tells the model to read it rather than re-run the tool', () => {
+		const { messages } = clear(history(spilled))
+		const text = clearedText(messages)
+		expect(text).toMatch(/read|grep/)
+		// Re-running a tool that returned megabytes is the advice this
+		// replaces.
+		expect(text).not.toContain('Call the tool again')
+	})
+
+	it('still reclaims most of the content', () => {
+		const { charsReclaimed, clearedCount } = clear(history(spilled))
+		expect(clearedCount).toBe(1)
+		expect(charsReclaimed).toBeGreaterThan(4_000)
+	})
+})
+
+describe('an ordinary large result', () => {
+	const long = `HEAD-MARKER\n${'y'.repeat(5_000)}\nTAIL-MARKER`
+
+	it('keeps a readable head and tail', () => {
+		const text = clearedText(clear(history(long)).messages)
+		// A result is not uniformly valuable; what a model needs is usually
+		// near one end.
+		expect(text).toContain('HEAD-MARKER')
+		expect(text).toContain('TAIL-MARKER')
+	})
+
+	it('says how much it elided', () => {
+		expect(clearedText(clear(history(long)).messages)).toMatch(/characters elided/)
+	})
+
+	it('still advises re-running when there is nothing on disk', () => {
+		expect(clearedText(clear(history(long)).messages)).toContain('Call the tool again')
+	})
+
+	it('is still recognisable as cleared', () => {
+		// A second pass must not clear its own placeholder again.
+		const once = clear(history(long)).messages
+		expect(isClearedToolResult(clearedText(once))).toBe(true)
+		expect(clear(once).clearedCount).toBe(0)
+	})
+
+	it('reclaims more than it keeps', () => {
+		const { charsReclaimed } = clear(history(long))
+		expect(charsReclaimed).toBeGreaterThan(3_000)
+	})
+})
+
+describe('a result barely over the threshold', () => {
+	it('does not lose everything to save a few hundred characters', () => {
+		const short = `IMPORTANT-FIRST-LINE\n${'z'.repeat(200)}\nIMPORTANT-LAST-LINE`
+		const { messages } = clearStaleToolResults(history(short), {
+			keepRecentToolResults: 0,
+			minCharsToClear: 100,
+		})
+		const text = clearedText(messages)
+		// The three lines the agent was reasoning from used to go with it.
+		expect(text).toContain('IMPORTANT-FIRST-LINE')
+		expect(text).toContain('IMPORTANT-LAST-LINE')
+	})
+})

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

@@ -0,0 +1,77 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+	DEFAULT_ASSUMED_CONTEXT_WINDOW,
+	lookupContextWindow,
+	resolveContextWindow,
+} from '../context-window.js'
+
+/**
+ * The compaction trigger divides "how full is the context" by a window.
+ * It used to divide by `runConfig.tokenBudget` — a cumulative spend cap,
+ * a different quantity entirely — which is why the whole subsystem was
+ * inert in every shipped consumer.
+ */
+
+describe('lookupContextWindow', () => {
+	it('resolves dated model ids through their family prefix', () => {
+		expect(lookupContextWindow('claude-opus-5-20260514')).toBe(200_000)
+		expect(lookupContextWindow('claude-sonnet-5')).toBe(200_000)
+	})
+
+	it('resolves namespaced ids from Bedrock and OpenRouter', () => {
+		expect(lookupContextWindow('us.anthropic.claude-sonnet-5-v1:0')).toBe(200_000)
+		expect(lookupContextWindow('anthropic/claude-opus-5')).toBe(200_000)
+	})
+
+	it('is case-insensitive', () => {
+		expect(lookupContextWindow('GPT-4O')).toBe(128_000)
+	})
+
+	it('prefers the more specific key when two prefixes both match', () => {
+		// 'gpt-4' also matches 'gpt-4.1' and 'gpt-4o' as a substring; the
+		// longest key must win or every GPT-4 family model collapses to 8k.
+		expect(lookupContextWindow('gpt-4.1')).toBe(1_047_576)
+		expect(lookupContextWindow('gpt-4o-mini')).toBe(128_000)
+		expect(lookupContextWindow('gpt-4')).toBe(8_192)
+	})
+
+	it('returns undefined for an unknown model rather than guessing', () => {
+		expect(lookupContextWindow('some-local-finetune-v3')).toBeUndefined()
+		expect(lookupContextWindow(undefined)).toBeUndefined()
+	})
+})
+
+describe('resolveContextWindow', () => {
+	it('an explicit config value wins over the table', () => {
+		expect(resolveContextWindow(50_000, 'claude-opus-5')).toEqual({
+			tokens: 50_000,
+			source: 'config',
+		})
+	})
+
+	it('falls back to the model table', () => {
+		expect(resolveContextWindow(undefined, 'claude-opus-5')).toEqual({
+			tokens: 200_000,
+			source: 'model-table',
+		})
+	})
+
+	it('falls back to a conservative default for an unknown model', () => {
+		expect(resolveContextWindow(undefined, 'mystery-model')).toEqual({
+			tokens: DEFAULT_ASSUMED_CONTEXT_WINDOW,
+			source: 'default',
+		})
+	})
+
+	it('ignores a zero or negative configured window instead of dividing by it', () => {
+		expect(resolveContextWindow(0, 'claude-opus-5').source).toBe('model-table')
+		expect(resolveContextWindow(-1, 'claude-opus-5').source).toBe('model-table')
+	})
+
+	it('never returns zero — the trigger divides by this', () => {
+		for (const model of [undefined, '', 'unknown', 'claude-opus-5', 'gpt-4']) {
+			expect(resolveContextWindow(undefined, model).tokens).toBeGreaterThan(0)
+		}
+	})
+})

package/src/compaction/__tests__/dangling.test.ts

@@ -391,14 +391,24 @@ describe('findSafeTrimIndex', () => {
 			createAssistantMessage('unmatched', ['call-3']), // Unmatched
 		]
 
-		// Try various trim points — target within bounds (excludes edge case target=messages.length
-		// where trailing unmatched assistant cannot be trimmed forward)
+		// Asserted on the KEPT side, which is the side that reaches a
+		// provider. This used to check that the DROPPED prefix was
+		// dangle-free — a proxy for "the kept tail has no leading orphan",
+		// and only ever a proxy: the prefix is summarised into prose, so an
+		// unanswered call inside it harms nothing. Checking the real
+		// property directly also covers the case the proxy missed, which is
+		// a tail that opens on an assistant turn.
 		for (let target = 0; target < messages.length; target++) {
 			const safeIdx = findSafeTrimIndex(messages, target)
-			const keptMessages = messages.slice(0, safeIdx)
-
-			const result = findDanglingMessages(keptMessages)
-			expect(result.isValid).toBe(true)
+			const kept = messages.slice(safeIdx)
+			if (kept.length === 0) continue
+
+			// The tail becomes the whole conversation once the summary is
+			// hoisted out as a system message, so it has to open the way a
+			// conversation opens.
+			expect(kept[0]?.role).toBe('user')
+			// And it cannot open on a result whose call was summarised away.
+			expect(kept[0]?.role).not.toBe('tool')
 		}
 	})
 

package/src/compaction/__tests__/lossiness.test.ts

@@ -0,0 +1,187 @@
+import { describe, expect, it } from 'vitest'
+
+import { CompactionConfigSchema } from '../../config/runtime.js'
+import { extractFromToolResult } from '../extractor.js'
+import { WorkingStateManager } from '../manager.js'
+import { serializeState } from '../serializer.js'
+
+/**
+ * What survives compaction is the ONLY record of the history it replaced.
+ * Two ways that record was quietly degrading:
+ *
+ * 1. Capped lists evicted with `shift()` — oldest-first — so on a long run
+ *    the 26th assistant note silently deleted the 1st. The early entries
+ *    are the load-bearing ones (the original requirement, the decision
+ *    that set the approach); the recent ones are still in the un-compacted
+ *    tail of the conversation.
+ * 2. Every tool the builtin name-sets did not recognise — every MCP tool,
+ *    every custom tool — collapsed into a flat 120-character head slice,
+ *    which on JSON spends the whole budget on syntax.
+ */
+
+function config(overrides: Record<string, unknown> = {}) {
+	return CompactionConfigSchema.parse({ maxListSize: 5, keepFirstEntries: 2, ...overrides })
+}
+
+describe('capped lists keep their head', () => {
+	it('evicts from the middle, not the front', () => {
+		const m = new WorkingStateManager(config())
+		for (let i = 1; i <= 8; i++) m.addDecision(`decision ${i}`)
+
+		const { decisions } = m.getState()
+		expect(decisions).toHaveLength(5)
+		// The first two survive…
+		expect(decisions.slice(0, 2)).toEqual(['decision 1', 'decision 2'])
+		// …and the newest do too. The middle is what went.
+		expect(decisions.slice(-2)).toEqual(['decision 7', 'decision 8'])
+	})
+
+	it('counts what it dropped', () => {
+		const m = new WorkingStateManager(config())
+		for (let i = 1; i <= 8; i++) m.addDecision(`d${i}`)
+		expect(m.getState().evicted.decisions).toBe(3)
+	})
+
+	it('counts each slot separately', () => {
+		const m = new WorkingStateManager(config())
+		for (let i = 1; i <= 7; i++) m.addFailure(`f${i}`)
+		for (let i = 1; i <= 6; i++) m.addDiscovery(`x${i}`)
+
+		expect(m.getState().evicted.failures).toBe(2)
+		expect(m.getState().evicted.discoveries).toBe(1)
+		expect(m.getState().evicted.decisions).toBeUndefined()
+	})
+
+	it('never evicts below the pinned head, even with a tiny cap', () => {
+		const m = new WorkingStateManager(config({ maxListSize: 2, keepFirstEntries: 5 }))
+		for (let i = 1; i <= 6; i++) m.addDecision(`d${i}`)
+
+		const { decisions } = m.getState()
+		expect(decisions).toHaveLength(2)
+		// keepFirst is clamped below the cap, so the list still admits new
+		// entries rather than freezing on its first two forever.
+		expect(decisions[0]).toBe('d1')
+		expect(decisions[1]).toBe('d6')
+	})
+
+	it('keeps tool results newest-first — recency genuinely wins there', () => {
+		// An old `read` of a file that has since been edited is worse than
+		// useless, so this slot is the one exception.
+		const m = new WorkingStateManager(config({ maxToolResults: 3 }))
+		for (let i = 1; i <= 5; i++) {
+			m.addToolResult({ tool: 't', summary: `s${i}`, timestamp: i })
+		}
+		expect(m.getState().toolResults.map((r) => r.summary)).toEqual(['s3', 's4', 's5'])
+		expect(m.getState().evicted.toolResults).toBe(2)
+	})
+})
+
+describe('the summary admits what it lost', () => {
+	it('names the dropped count in the rendered section', () => {
+		const m = new WorkingStateManager(config())
+		for (let i = 1; i <= 8; i++) m.addDecision(`d${i}`)
+
+		const rendered = serializeState(m.getState())
+		expect(rendered).toContain('3 entries dropped')
+	})
+
+	it('says nothing when nothing was dropped', () => {
+		const m = new WorkingStateManager(config())
+		m.addDecision('only one')
+		expect(serializeState(m.getState())).not.toContain('dropped')
+	})
+
+	it('uses the singular for one', () => {
+		const m = new WorkingStateManager(config())
+		for (let i = 1; i <= 6; i++) m.addDecision(`d${i}`)
+		expect(serializeState(m.getState())).toContain('1 entry dropped')
+	})
+})
+
+describe('unrecognised tools get a useful summary', () => {
+	const m = () => new WorkingStateManager(config({ maxToolResults: 30 }))
+
+	it('describes the shape of a JSON array instead of slicing its syntax', () => {
+		const mgr = m()
+		const payload = JSON.stringify(
+			Array.from({ length: 40 }, (_, i) => ({ id: `row-${i}`, name: 'x'.repeat(30) })),
+		)
+		extractFromToolResult(mgr, 'mcp_crm_list_deals', payload, false)
+
+		const summary = mgr.getState().toolResults[0]?.summary ?? ''
+		expect(summary).toContain('array of 40')
+		expect(summary).toContain('id')
+		expect(summary).toContain('name')
+	})
+
+	it('lists the keys of a JSON object', () => {
+		const mgr = m()
+		const payload = JSON.stringify({
+			status: 'ok',
+			total: 12,
+			items: Array.from({ length: 50 }, (_, i) => `item-${i}-${'x'.repeat(20)}`),
+		})
+		extractFromToolResult(mgr, 'mcp_docs_search', payload, false)
+
+		const summary = mgr.getState().toolResults[0]?.summary ?? ''
+		expect(summary).toContain('object{')
+		expect(summary).toContain('status')
+		expect(summary).toContain('items')
+	})
+
+	it('keeps head AND tail of long plain text', () => {
+		const mgr = m()
+		extractFromToolResult(mgr, 'custom_tool', `START${'.'.repeat(4000)}END`, false)
+
+		const summary = mgr.getState().toolResults[0]?.summary ?? ''
+		expect(summary).toContain('START')
+		expect(summary).toContain('END')
+		expect(summary).toContain('chars omitted')
+	})
+
+	it('leaves a short result completely alone', () => {
+		const mgr = m()
+		extractFromToolResult(mgr, 'custom_tool', 'all good', false)
+		expect(mgr.getState().toolResults[0]?.summary).toBe('all good')
+	})
+
+	it('gives an unknown tool more room than the old flat 120 chars', () => {
+		const mgr = m()
+		extractFromToolResult(mgr, 'custom_tool', 'z'.repeat(5000), false)
+		expect((mgr.getState().toolResults[0]?.summary ?? '').length).toBeGreaterThan(120)
+	})
+})
+
+describe('the tool-result section admits what it dropped', () => {
+	it('names the count once results have been evicted', () => {
+		const m = new WorkingStateManager(config({ maxToolResults: 2 }))
+		m.addToolResult({ tool: 'read', summary: 'first', timestamp: 0 })
+		m.addToolResult({ tool: 'read', summary: 'second', timestamp: 0 })
+		m.addToolResult({ tool: 'read', summary: 'third', timestamp: 0 })
+
+		const rendered = serializeState(m.getState())
+
+		// The section carrying the most volume was the only one rendering a
+		// fragment as if it were the whole record: the count was tracked and
+		// never printed.
+		expect(rendered).toContain('1 earlier tool result dropped')
+		expect(rendered).toContain('second')
+		expect(rendered).toContain('third')
+	})
+
+	it('pluralizes past one', () => {
+		const m = new WorkingStateManager(config({ maxToolResults: 1 }))
+		for (const summary of ['a', 'b', 'c']) m.addToolResult({ tool: 'read', summary, timestamp: 0 })
+
+		expect(serializeState(m.getState())).toContain('2 earlier tool results dropped')
+	})
+
+	it('says nothing when nothing was dropped', () => {
+		const m = new WorkingStateManager(config({ maxToolResults: 8 }))
+		m.addToolResult({ tool: 'read', summary: 'only', timestamp: 0 })
+
+		const rendered = serializeState(m.getState())
+		expect(rendered).toContain('only')
+		expect(rendered).not.toContain('dropped to stay within')
+	})
+})

package/src/compaction/__tests__/state-across-resume.test.ts

@@ -0,0 +1,99 @@
+import { describe, expect, it } from 'vitest'
+
+import type { CompactionConfig } from '../../config/runtime.js'
+import { WorkingStateManager } from '../manager.js'
+import { serializeState } from '../serializer.js'
+import { restoreWorkingState, snapshotWorkingState } from '../wire.js'
+
+/**
+ * Compaction replaces older history with a summary and drops any PRIOR
+ * summary, on the grounds that `serializeState` is cumulative so the new
+ * one supersedes it. Within a process that is true.
+ *
+ * Across a resume it was not: the manager was rebuilt empty on every
+ * `query()`, so a resumed run's second compaction summarized only
+ * post-resume activity and deleted the block holding everything before it
+ * — the block the restore path had deliberately carried forward as the
+ * only surviving record of the compacted history.
+ */
+
+function config(): CompactionConfig {
+	return {
+		strategy: 'structured',
+		triggerThreshold: 0.7,
+		resetThreshold: 0.4,
+		keepRecentMessages: 4,
+		clearToolResults: true,
+		keepRecentToolResults: 3,
+		minToolResultCharsToClear: 1_000,
+		maxToolResults: 30,
+		maxListSize: 25,
+		keepFirstEntries: 3,
+		llmVerification: false,
+		llmVerificationMaxTokens: 2048,
+		richStateThreshold: 15,
+		convoTextBudget: 12_000,
+		maxSentencesPerTurn: 5,
+		maxCharsPerNote: 500,
+		maxCharsPerRequirement: 300,
+		maxCharsPerTask: 400,
+	} as CompactionConfig
+}
+
+/** A manager holding the kind of state a first hour of work produces. */
+function firstHour(): WorkingStateManager {
+	const m = new WorkingStateManager(config())
+	m.setTask('migrate the billing schema')
+	m.addDecision('chose an additive migration over a rewrite')
+	m.addFailure('the first attempt deadlocked on the invoices table')
+	m.addDiscovery('invoices has a partial index nobody documented')
+	m.trackFile('src/billing/schema.ts', { type: 'edit', detail: 'added the additive columns' })
+	return m
+}
+
+describe('working state survives a process boundary', () => {
+	it('round-trips every slot', () => {
+		const before = firstHour()
+		const after = restoreWorkingState(snapshotWorkingState(before), config())
+
+		expect(serializeState(after.getState())).toBe(serializeState(before.getState()))
+	})
+
+	it('carries the file map, which JSON alone would flatten to nothing', () => {
+		// `WorkingState.files` is a Map. `JSON.stringify` renders a Map as
+		// `{}`, so a naive snapshot would silently lose every tracked file.
+		const restored = restoreWorkingState(snapshotWorkingState(firstHour()), config())
+		expect(restored.getState().files.get('src/billing/schema.ts')).toBeDefined()
+	})
+
+	it('carries the eviction counters, so a resumed summary still admits its losses', () => {
+		// The state that survives compaction is the only record of the
+		// history it replaced. A resumed summary that forgot what it had
+		// already dropped would claim a completeness it does not have.
+		const m = new WorkingStateManager(config())
+		for (let i = 0; i < 40; i++) m.addDecision(`decision ${i}`)
+		expect(m.getState().evicted.decisions).toBeGreaterThan(0)
+
+		const restored = restoreWorkingState(snapshotWorkingState(m), config())
+		expect(restored.getState().evicted.decisions).toBe(m.getState().evicted.decisions)
+	})
+
+	it('keeps accumulating after the restore rather than starting over', () => {
+		// This is the property the whole fix exists for: the SECOND
+		// compaction of a resumed run must summarize the first hour AND what
+		// followed, because it is about to delete the block that held the
+		// first hour.
+		const restored = restoreWorkingState(snapshotWorkingState(firstHour()), config())
+		restored.addDecision('after the resume, switched to a batched backfill')
+
+		const serialized = serializeState(restored.getState())
+		expect(serialized).toContain('additive migration')
+		expect(serialized).toContain('batched backfill')
+	})
+
+	it('an empty snapshot restores to an empty manager', () => {
+		const empty = new WorkingStateManager(config())
+		const restored = restoreWorkingState(snapshotWorkingState(empty), config())
+		expect(restored.slotCount()).toBe(empty.slotCount())
+	})
+})