@namzu/sdk 2.0.0 → 3.0.0

package/src/compaction/manager.ts

@@ -13,6 +13,7 @@ function createEmptyState(): WorkingState {
 		toolResults: [],
 		userRequirements: [],
 		assistantNotes: [],
+		evicted: {},
 	}
 }
 
@@ -43,36 +44,50 @@ export class WorkingStateManager {
 	}
 
 	addDecision(decision: string): void {
-		this.pushWithEviction(this.state.decisions, decision, this.config.maxListSize)
+		this.pushWithEviction('decisions', this.state.decisions, decision, this.config.maxListSize)
 	}
 
 	addFailure(failure: string): void {
-		this.pushWithEviction(this.state.failures, failure, this.config.maxListSize)
+		this.pushWithEviction('failures', this.state.failures, failure, this.config.maxListSize)
 	}
 
 	addDiscovery(discovery: string): void {
-		this.pushWithEviction(this.state.discoveries, discovery, this.config.maxListSize)
+		this.pushWithEviction('discoveries', this.state.discoveries, discovery, this.config.maxListSize)
 	}
 
 	addEnvironment(env: string): void {
-		this.pushWithEviction(this.state.environment, env, this.config.maxListSize)
+		this.pushWithEviction('environment', this.state.environment, env, this.config.maxListSize)
 	}
 
 	addToolResult(result: ToolResultSlot): void {
 		this.state.toolResults.push(result)
+		// Tool results are the one slot where recency genuinely wins: an old
+		// `read` of a file that has since been edited is worse than useless.
+		// Oldest-first eviction is correct here; it is still counted.
 		while (this.state.toolResults.length > this.config.maxToolResults) {
 			this.state.toolResults.shift()
+			this.state.evicted.toolResults = (this.state.evicted.toolResults ?? 0) + 1
 		}
 	}
 
 	addUserRequirement(requirement: string): void {
 		const truncated = requirement.slice(0, this.config.maxCharsPerRequirement)
-		this.pushWithEviction(this.state.userRequirements, truncated, this.config.maxListSize)
+		this.pushWithEviction(
+			'userRequirements',
+			this.state.userRequirements,
+			truncated,
+			this.config.maxListSize,
+		)
 	}
 
 	addAssistantNote(note: string): void {
 		const truncated = note.slice(0, this.config.maxCharsPerNote)
-		this.pushWithEviction(this.state.assistantNotes, truncated, this.config.maxListSize)
+		this.pushWithEviction(
+			'assistantNotes',
+			this.state.assistantNotes,
+			truncated,
+			this.config.maxListSize,
+		)
 	}
 
 	slotCount(): number {
@@ -94,14 +109,44 @@ export class WorkingStateManager {
 		return this.state
 	}
 
+	/**
+	 * Adopt a previously captured state.
+	 *
+	 * Used on resume: a run that compacted, checkpointed and came back in a
+	 * new process needs the state its earlier summary was built from, or the
+	 * next compaction supersedes that summary with one covering only what
+	 * happened after the resume. See {@link restoreWorkingState}.
+	 */
+	replaceState(state: WorkingState): void {
+		this.state = state
+	}
+
 	reset(): void {
 		this.state = createEmptyState()
 	}
 
-	private pushWithEviction(list: string[], item: string, max: number): void {
+	/**
+	 * Append, evicting from the MIDDLE once the list is full.
+	 *
+	 * This used to `shift()`, dropping the oldest entry — so on a long run
+	 * the 26th assistant note silently deleted the 1st, and "the structured
+	 * state that survives compaction" degraded into a rolling window over
+	 * recent activity. The early entries are the load-bearing ones: the
+	 * original requirement, the decision that set the approach, the failure
+	 * that ruled an option out. The recent ones are still in the
+	 * un-compacted tail of the conversation.
+	 *
+	 * So the first `keepFirstEntries` are pinned and eviction happens just
+	 * after them — `keep_first` semantics, the same shape OpenHands'
+	 * condenser uses. The eviction is counted so the serializer can say
+	 * something was dropped rather than presenting a gap as complete.
+	 */
+	private pushWithEviction(slot: string, list: string[], item: string, max: number): void {
 		list.push(item)
+		const keepFirst = Math.min(this.config.keepFirstEntries, Math.max(0, max - 1))
 		while (list.length > max) {
-			list.shift()
+			list.splice(keepFirst, 1)
+			this.state.evicted[slot] = (this.state.evicted[slot] ?? 0) + 1
 		}
 	}
 }

package/src/compaction/managers/structured.ts

@@ -97,12 +97,13 @@ export class StructuredCompactionManager implements ConversationManager {
 			const desiredTrimPoint = result.length - this.config.keepRecentMessages
 			const safeTrimIdx = findSafeTrimIndex(result, desiredTrimPoint)
 
-			// Always keep the injected system message
-			const trimPoint = Math.min(
-				safeTrimIdx,
-				Math.max(0, result.length - this.config.keepRecentMessages),
-			)
-			return result.slice(trimPoint)
+			// The safe index is the answer, not a suggestion. This used to
+			// take `Math.min(safeTrimIdx, desiredTrimPoint)` — and since the
+			// safe index only ever moves FORWARD of the desired one, that
+			// minimum resolved back to the desired point every time and
+			// discarded the entire safety search. Whatever the guard was
+			// reaching for, what it did was undo the thing above it.
+			return result.slice(safeTrimIdx)
 		}
 
 		return result

package/src/compaction/retention.ts

@@ -0,0 +1,89 @@
+import type { AssistantMessage, Message, ToolMessage } from '../types/message/index.js'
+
+/**
+ * Which messages compaction may not evict or clear.
+ *
+ * The retention floor was entirely POSITIONAL: the leading system run, the
+ * working-memory slot, the last N turns, the most recent tool results.
+ * Every one of those is "whatever happens to be at an end of the
+ * transcript", so a constraint stated in the MIDDLE of a conversation —
+ * "the account id is X, never bill a different one" — aged out at the same
+ * rate as chatter. The working-memory slot cannot express it either: that
+ * is host-rendered per turn and does not know what the user said.
+ *
+ * `retain` says it directly. The cost of the marker is paid by whoever
+ * sets it: pinned turns are exempt from the reclaim that keeps a long run
+ * alive, so pinning the whole history is a way to make compaction useless.
+ * Nothing here enforces a ceiling — a limit would have to guess which pin
+ * mattered, and dropping the wrong one silently is worse than the run
+ * overflowing loudly.
+ */
+
+const isAssistantWithCalls = (m: Message): m is AssistantMessage =>
+	m.role === 'assistant' && Array.isArray((m as AssistantMessage).toolCalls)
+
+/**
+ * Indices of every message protected by a `retain` marker, expanded across
+ * tool pairs.
+ *
+ * Transitive by necessity, not politeness. A `tool_result` whose
+ * `tool_use` was dropped is rejected by the provider outright, so pinning
+ * half a pair would turn a retention request into a broken next turn. So:
+ * a pinned tool result pulls in the assistant turn that issued the call,
+ * and a pinned assistant turn pulls in EVERY result answering it — the
+ * second hop matters, because an assistant turn with three calls and one
+ * surviving result is the same dangling error in the other direction.
+ */
+export function findRetainedIndices(messages: readonly Message[]): Set<number> {
+	const retained = new Set<number>()
+	for (let i = 0; i < messages.length; i++) {
+		if (messages[i]?.retain === true) retained.add(i)
+	}
+	if (retained.size === 0) return retained
+
+	const assistantOfCall = new Map<string, number>()
+	const resultsOfAssistant = new Map<number, number[]>()
+
+	for (let i = 0; i < messages.length; i++) {
+		const message = messages[i]
+		if (!message || !isAssistantWithCalls(message)) continue
+		for (const call of message.toolCalls ?? []) {
+			assistantOfCall.set(call.id, i)
+		}
+	}
+	for (let i = 0; i < messages.length; i++) {
+		const message = messages[i]
+		if (!message || message.role !== 'tool') continue
+		const owner = assistantOfCall.get((message as ToolMessage).toolCallId)
+		if (owner === undefined) continue
+		const siblings = resultsOfAssistant.get(owner)
+		if (siblings) siblings.push(i)
+		else resultsOfAssistant.set(owner, [i])
+	}
+
+	// Worklist rather than one pass: pulling in an assistant turn adds
+	// results that were not marked, and each of those would otherwise have
+	// to be re-examined by hand.
+	const pending = [...retained]
+	while (pending.length > 0) {
+		const index = pending.pop()
+		if (index === undefined) continue
+		const message = messages[index]
+		if (!message) continue
+
+		const add = (candidate: number | undefined) => {
+			if (candidate === undefined || retained.has(candidate)) return
+			retained.add(candidate)
+			pending.push(candidate)
+		}
+
+		if (message.role === 'tool') {
+			add(assistantOfCall.get((message as ToolMessage).toolCallId))
+		}
+		for (const sibling of resultsOfAssistant.get(index) ?? []) {
+			add(sibling)
+		}
+	}
+
+	return retained
+}

package/src/compaction/serializer.ts

@@ -33,12 +33,29 @@ function renderFiles(
 	return lines.join('\n')
 }
 
-function renderList(items: string[]): string {
-	return items.map((item) => `- ${item}`).join('\n')
+function renderList(items: string[], evictedCount = 0): string {
+	const lines = items.map((item) => `- ${item}`)
+	if (evictedCount > 0) {
+		// Say what is missing. A summary that presents a gap as complete is
+		// worse than one that admits the gap: the model reasons about a
+		// fragment as if it were the whole record.
+		const noun = evictedCount === 1 ? 'entry' : 'entries'
+		lines.push(`- _(${evictedCount} ${noun} dropped to stay within the state budget)_`)
+	}
+	return lines.join('\n')
 }
 
-function renderToolResults(results: { tool: string; summary: string }[]): string {
-	return results.map((r) => `- **${r.tool}**: ${r.summary}`).join('\n')
+function renderToolResults(results: { tool: string; summary: string }[], evictedCount = 0): string {
+	const lines = results.map((r) => `- **${r.tool}**: ${r.summary}`)
+	if (evictedCount > 0) {
+		// The same admission every sibling section makes. This one counted
+		// its evictions and then rendered without them, so the section that
+		// carries the most volume was the only one presenting a fragment as
+		// the whole record.
+		const noun = evictedCount === 1 ? 'result' : 'results'
+		lines.push(`- _(${evictedCount} earlier tool ${noun} dropped to stay within the state budget)_`)
+	}
+	return lines.join('\n')
 }
 
 export function serializeState(state: WorkingState): string {
@@ -49,7 +66,9 @@ export function serializeState(state: WorkingState): string {
 	}
 
 	if (state.userRequirements.length > 0) {
-		sections.push(`${SECTION_HEADERS.userRequirements}\n\n${renderList(state.userRequirements)}`)
+		sections.push(
+			`${SECTION_HEADERS.userRequirements}\n\n${renderList(state.userRequirements, state.evicted.userRequirements)}`,
+		)
 	}
 
 	if (state.plan.length > 0) {
@@ -57,7 +76,9 @@ export function serializeState(state: WorkingState): string {
 	}
 
 	if (state.environment.length > 0) {
-		sections.push(`${SECTION_HEADERS.environment}\n\n${renderList(state.environment)}`)
+		sections.push(
+			`${SECTION_HEADERS.environment}\n\n${renderList(state.environment, state.evicted.environment)}`,
+		)
 	}
 
 	if (state.files.size > 0) {
@@ -65,23 +86,33 @@ export function serializeState(state: WorkingState): string {
 	}
 
 	if (state.decisions.length > 0) {
-		sections.push(`${SECTION_HEADERS.decisions}\n\n${renderList(state.decisions)}`)
+		sections.push(
+			`${SECTION_HEADERS.decisions}\n\n${renderList(state.decisions, state.evicted.decisions)}`,
+		)
 	}
 
 	if (state.assistantNotes.length > 0) {
-		sections.push(`${SECTION_HEADERS.assistantNotes}\n\n${renderList(state.assistantNotes)}`)
+		sections.push(
+			`${SECTION_HEADERS.assistantNotes}\n\n${renderList(state.assistantNotes, state.evicted.assistantNotes)}`,
+		)
 	}
 
 	if (state.toolResults.length > 0) {
-		sections.push(`${SECTION_HEADERS.toolResults}\n\n${renderToolResults(state.toolResults)}`)
+		sections.push(
+			`${SECTION_HEADERS.toolResults}\n\n${renderToolResults(state.toolResults, state.evicted.toolResults)}`,
+		)
 	}
 
 	if (state.failures.length > 0) {
-		sections.push(`${SECTION_HEADERS.failures}\n\n${renderList(state.failures)}`)
+		sections.push(
+			`${SECTION_HEADERS.failures}\n\n${renderList(state.failures, state.evicted.failures)}`,
+		)
 	}
 
 	if (state.discoveries.length > 0) {
-		sections.push(`${SECTION_HEADERS.discoveries}\n\n${renderList(state.discoveries)}`)
+		sections.push(
+			`${SECTION_HEADERS.discoveries}\n\n${renderList(state.discoveries, state.evicted.discoveries)}`,
+		)
 	}
 
 	return sections.join('\n\n')

package/src/compaction/tool-result-editing.ts

@@ -0,0 +1,229 @@
+import { SPILL_MARKER } from '../runtime/query/tool-output-budget.js'
+import { toolResultToText } from '../types/message/content.js'
+import type { Message, ToolMessage, ToolResultBlock } from '../types/message/index.js'
+import { findRetainedIndices } from './retention.js'
+
+/**
+ * Clear stale tool OUTPUT in place, without touching the conversation's
+ * shape.
+ *
+ * Compaction was all-or-nothing: once the threshold hit, every older
+ * message became a summary and the agent's own reasoning — the decisions,
+ * the false starts it learned from, the exact wording of a plan — was
+ * paraphrased away with it. That is a heavy price to pay for a context
+ * problem that is usually caused by something much dumber: a handful of
+ * enormous tool outputs the agent already read, extracted what it needed
+ * from, and moved past.
+ *
+ * Clearing those reclaims most of the same tokens while preserving every
+ * message verbatim. It is safe where trimming is not, because the `tool`
+ * message stays exactly where it is with the same `toolCallId` — so the
+ * `tool_use` ↔ `tool_result` pairing the providers require is untouched by
+ * construction. The placeholder tells the model what happened, so a result
+ * it turns out to still need is one tool call away rather than lost.
+ */
+export interface ToolResultEditConfig {
+	/**
+	 * How many of the most recent tool results to leave alone. The agent is
+	 * usually still working with these, and clearing them buys tokens by
+	 * forcing an immediate re-read — a net loss.
+	 */
+	readonly keepRecentToolResults?: number
+	/**
+	 * Don't bother clearing results smaller than this. Below it the
+	 * placeholder is comparable in size to the output, so the churn buys
+	 * nothing and costs the model a confusing hole in its history.
+	 */
+	readonly minCharsToClear?: number
+	/** Tools whose output is never cleared, by name. */
+	readonly preserveTools?: readonly string[]
+}
+
+export const DEFAULT_KEEP_RECENT_TOOL_RESULTS = 3
+export const DEFAULT_MIN_CHARS_TO_CLEAR = 1_000
+
+/** Marks a cleared result, and is how a second pass recognizes its own work. */
+const CLEARED_PREFIX = '[tool output cleared]'
+
+/**
+ * How much of the original result survives a clear, at each end.
+ *
+ * Small on purpose — the point of clearing is to reclaim context, and a
+ * generous keep defeats it. But zero was the wrong number: a result just
+ * over the minimum lost 100% of itself, including the three lines the
+ * agent was actively reasoning from, to reclaim a few hundred characters.
+ */
+const KEEP_HEAD_CHARS = 400
+const KEEP_TAIL_CHARS = 200
+
+/**
+ * Build the placeholder that replaces a cleared result.
+ *
+ * Two things survive, for two different reasons.
+ *
+ * The SPILL LINE, unconditionally: when a result was over the output
+ * budget its full text was written to disk and that line is the pointer
+ * back to it. Replacing the whole content destroyed the cheapest recovery
+ * route precisely for the largest results — and then told the model to
+ * call the tool again, which is advice to re-run something that returned
+ * megabytes. Keeping one line preserves a `read`/`grep` route worth far
+ * more than the line costs.
+ *
+ * A HEAD AND TAIL, because a result is not uniformly valuable: what a
+ * model needs from a long output is usually near one end, and keeping a
+ * few hundred characters of each is the difference between "I remember
+ * roughly what this said" and "call it again".
+ */
+function clearedPlaceholder(
+	content: ToolMessage['content'],
+	toolName: string,
+	size: number,
+): string {
+	const text = typeof content === 'string' ? content : toolResultToText(content)
+	const parts: string[] = [
+		`${CLEARED_PREFIX} ${toolName} returned ${size.toLocaleString('en-US')} characters, cleared to reclaim context.`,
+	]
+
+	const spillLine = text.split('\n').find((line) => line.startsWith(SPILL_MARKER))
+	if (spillLine) {
+		parts.push(
+			spillLine,
+			'Read a window of it with `read` (offset/limit) or search it with `grep`.',
+		)
+	} else {
+		parts.push('Call the tool again if you still need the rest.')
+	}
+
+	if (text.length > KEEP_HEAD_CHARS + KEEP_TAIL_CHARS) {
+		parts.push(
+			'',
+			text.slice(0, KEEP_HEAD_CHARS),
+			`… ${(text.length - KEEP_HEAD_CHARS - KEEP_TAIL_CHARS).toLocaleString('en-US')} characters elided …`,
+			text.slice(-KEEP_TAIL_CHARS),
+		)
+	} else {
+		// Shorter than what an elision would keep, so eliding it would drop
+		// content while saving nothing. A caller that lowered the minimum
+		// far enough to reach a result this small gets it back whole, and a
+		// truthful `charsReclaimed` of about zero — rather than a total loss
+		// dressed up as a saving.
+		parts.push('', text)
+	}
+
+	return parts.join('\n')
+}
+
+export interface ToolResultEditOutcome {
+	readonly messages: Message[]
+	readonly clearedCount: number
+	/** Characters removed from the model-visible history. */
+	readonly charsReclaimed: number
+}
+
+export function isClearedToolResult(content: unknown): boolean {
+	return typeof content === 'string' && content.startsWith(CLEARED_PREFIX)
+}
+
+/**
+ * Replace the output of old, large tool results with a short placeholder.
+ *
+ * Returns a NEW array; the input is not mutated. `clearedCount === 0` means
+ * nothing was eligible, and the caller should fall through to whatever it
+ * would have done anyway.
+ */
+export function clearStaleToolResults(
+	messages: readonly Message[],
+	config: ToolResultEditConfig = {},
+): ToolResultEditOutcome {
+	const keepRecent = Math.max(0, config.keepRecentToolResults ?? DEFAULT_KEEP_RECENT_TOOL_RESULTS)
+	const minChars = Math.max(0, config.minCharsToClear ?? DEFAULT_MIN_CHARS_TO_CLEAR)
+	const preserve = new Set(config.preserveTools ?? [])
+
+	// Which tool call produced which result, so a preserve-list can be
+	// written in terms of TOOL NAMES — the only handle a host actually has.
+	const toolNameByCallId = new Map<string, string>()
+	for (const msg of messages) {
+		if (msg.role !== 'assistant' || !msg.toolCalls) continue
+		for (const call of msg.toolCalls) {
+			toolNameByCallId.set(call.id, call.function.name)
+		}
+	}
+
+	const toolIndices: number[] = []
+	messages.forEach((msg, index) => {
+		if (msg.role === 'tool') toolIndices.push(index)
+	})
+
+	// `slice(-0)` returns the WHOLE array, so a plain `slice(-keepRecent)`
+	// would protect EVERY result when the caller asked to protect none.
+	const protectedFromEnd = new Set(keepRecent === 0 ? [] : toolIndices.slice(-keepRecent))
+
+	// A pinned result is pinned against THIS too. Clearing keeps the message
+	// and replaces its content, which is exactly the loss `retain` was asked
+	// to prevent — a placeholder where the account id used to be reads as an
+	// answer, not as an omission.
+	const retained = findRetainedIndices(messages)
+
+	let clearedCount = 0
+	let charsReclaimed = 0
+
+	const edited = messages.map((msg, index) => {
+		if (msg.role !== 'tool') return msg
+		if (protectedFromEnd.has(index)) return msg
+		if (retained.has(index)) return msg
+
+		const tool = msg as ToolMessage
+		// An error result is small and it STEERS — it is the thing the model
+		// reads to decide what to do differently. Clearing it would reclaim
+		// nothing and remove the reason a later turn makes sense.
+		if (tool.isError) return msg
+		if (isClearedToolResult(tool.content)) return msg
+
+		const toolName = toolNameByCallId.get(tool.toolCallId) ?? 'unknown'
+		if (preserve.has(toolName)) return msg
+
+		const size = measureContent(tool.content)
+		if (size < minChars) return msg
+
+		clearedCount++
+		charsReclaimed += size - 0
+		return {
+			...tool,
+			content: clearedPlaceholder(tool.content, toolName, size),
+		} satisfies ToolMessage
+	})
+
+	// Subtract what the placeholders themselves cost, so the number a
+	// caller uses to decide "was that enough?" is the real saving and not
+	// an overstatement.
+	if (clearedCount > 0) {
+		let placeholderChars = 0
+		for (const msg of edited) {
+			if (msg.role === 'tool' && isClearedToolResult(msg.content)) {
+				placeholderChars += measureContent(msg.content)
+			}
+		}
+		charsReclaimed = Math.max(0, charsReclaimed - placeholderChars)
+	}
+
+	return { messages: edited, clearedCount, charsReclaimed }
+}
+
+/**
+ * Size of a tool result as the model sees it.
+ *
+ * An image block is measured by its base64 payload, which is the whole
+ * point: a screenshot is the single largest thing a tool result can carry,
+ * and it is exactly the kind of output an agent reads once and never
+ * needs again.
+ */
+function measureContent(content: ToolMessage['content']): number {
+	if (typeof content === 'string') return content.length
+	if (!Array.isArray(content)) return 0
+	let total = 0
+	for (const block of content as readonly ToolResultBlock[]) {
+		if (block.type === 'text') total += block.text.length
+		else if (block.type === 'image') total += block.data.length
+	}
+	return total
+}

package/src/compaction/types.ts

@@ -9,6 +9,16 @@ export interface WorkingState {
 	toolResults: ToolResultSlot[]
 	userRequirements: string[]
 	assistantNotes: string[]
+	/**
+	 * How many entries each capped list has dropped, keyed by slot name.
+	 *
+	 * The state that survives compaction is the only record of the history
+	 * it replaced, so silently shrinking it is the one thing this structure
+	 * must not do. Counting the loss lets the serializer say so, which is
+	 * the difference between "here is the state" and "here is what is left
+	 * of the state".
+	 */
+	evicted: Record<string, number>
 }
 
 export interface PlanSlot {

package/src/compaction/verifier.ts

@@ -1,5 +1,6 @@
 import type { CompactionConfig } from '../config/runtime.js'
 import { collect } from '../provider/collect.js'
+import type { TokenUsage } from '../types/common/index.js'
 import type { Message } from '../types/message/index.js'
 import type { LLMProvider } from '../types/provider/interface.js'
 import type { WorkingStateManager } from './manager.js'
@@ -42,11 +43,31 @@ function truncateMessages(messages: Message[], budget: number): string {
 	return lines.join('\n\n')
 }
 
+/**
+ * Narrow sink for the tokens a side-channel model call spends.
+ *
+ * The verifier runs outside the iteration loop, so its usage never reached
+ * `runMgr.accumulateUsage` and the guard could not see it — and it fires
+ * exactly when the context is largest, making it the most expensive call
+ * the run does not count. A one-method sink keeps the compaction layer
+ * from depending on `RunPersistence`.
+ */
+export type UsageSink = (usage: TokenUsage) => void
+
 export async function buildVerifiedSummary(
 	manager: WorkingStateManager,
 	olderMessages: Message[],
 	provider: LLMProvider,
 	config: CompactionConfig,
+	onUsage?: UsageSink,
+	/**
+	 * The run's model. Required in practice: this used to send `model: ''`,
+	 * which some drivers quietly default and others reject outright — on
+	 * some backends the model id IS the endpoint. So compaction's verifier failed
+	 * exactly on the providers where a long run most needs it, and the
+	 * failure surfaced as compaction killing the run it exists to save.
+	 */
+	model?: string,
 ): Promise<string> {
 	const serialized = serializeState(manager.getState())
 
@@ -77,13 +98,15 @@ export async function buildVerifiedSummary(
 
 	const response = await collect(
 		provider.chatStream({
-			model: '',
+			model: model ?? '',
 			messages: verificationMessages,
 			maxTokens: config.llmVerificationMaxTokens,
 			temperature: 0,
 		}),
 	)
 
+	onUsage?.(response.usage)
+
 	const responseText = response.message.content?.trim() ?? ''
 
 	// `COMPLETE` is the verifier saying it found nothing to add. An EMPTY reply