@namzu/sdk 56.1.0 → 57.0.0

package/src/runtime/query/executor.ts

@@ -6,6 +6,7 @@ import { unknownProgramInLine } from '../../authorization/program.js'
 import { type SkillGrantSet, compileSkillGrant } from '../../authorization/skill-grant.js'
 import { extractFromToolCall, extractFromToolResult } from '../../compaction/extractor.js'
 import type { WorkingStateManager } from '../../compaction/manager.js'
+import { recordRestorable } from '../../compaction/restore.js'
 import { GENAI, NAMZU } from '../../constants/telemetry/index.js'
 import type { PluginLifecycleManager } from '../../plugin/lifecycle.js'
 import { buildProbeContext } from '../../probe/context.js'
@@ -13,6 +14,7 @@ import { ProbeVetoError } from '../../probe/errors.js'
 import { probe as defaultProbeRegistry } from '../../probe/registry.js'
 import type { ProbeEnforcement } from '../../probe/registry.js'
 import type { ActivityStore } from '../../store/activity/memory.js'
+import { fingerprintContent } from '../../tools/builtins/content-fingerprint.js'
 import { sandboxShellSpawn, withoutBashStartup } from '../../tools/command-shell.js'
 import { isAlwaysDestructive } from '../../tools/defineTool.js'
 import { createFileReadTracker } from '../../tools/file-read-tracker.js'
@@ -72,7 +74,11 @@ import {
 	runPreToolHook,
 	unknownToolMessage,
 } from './executor/tool-call-admission.js'
-import { describeVisibleFileEvidence } from './file-evidence-context.js'
+import {
+	type FileEvidence,
+	describeVisibleFileEvidence,
+	visibleFileEvidence,
+} from './file-evidence-context.js'
 import { seedObservationLedger } from './file-evidence-seed.js'
 import { DEFAULT_TOOL_RESULT_GUARDRAILS } from './guardrail-presets.js'
 import { declaredWriteEscalation, shellEscalations } from './path-escalation.js'
@@ -696,6 +702,7 @@ export class ToolExecutor {
 	private emitEvent: EmitEvent
 	private log: Logger
 	private workingStateManager?: WorkingStateManager
+	private historyView?: () => readonly Message[]
 	private probes: ProbeEnforcement
 	private parentSpan?: Span
 	private readonly toolCallBudget?: ToolCallBudget
@@ -745,6 +752,30 @@ export class ToolExecutor {
 		this.workingStateManager = manager
 	}
 
+	/**
+	 * Read the conversation the model is shown, as it is now. Lets a tool ask
+	 * whether an earlier receipt is still there (see `ToolContext.receiptVisible`)
+	 * without being handed the history.
+	 */
+	setHistoryView(view: () => readonly Message[]): void {
+		this.historyView = view
+	}
+
+	private receiptVisible = (callId: string, renderedFingerprint: string): boolean => {
+		const history = this.historyView?.()
+		if (!history) return false
+		for (let index = history.length - 1; index >= 0; index -= 1) {
+			const message = history[index]
+			if (message?.role !== 'tool' || message.toolCallId !== callId) continue
+			return (
+				typeof message.content === 'string' &&
+				message.isError !== true &&
+				fingerprintContent(message.content) === renderedFingerprint
+			)
+		}
+		return false
+	}
+
 	setSandbox(sandbox: Sandbox): void {
 		this.config = { ...this.config, sandbox }
 		this.sandboxGate = undefined
@@ -845,7 +876,21 @@ export class ToolExecutor {
 		})
 	}
 
-	/** Request-only evidence from the same ledger used by mutation admission. No filesystem I/O. */
+	/**
+	 * The entries that hold now, from the same ledger used by mutation
+	 * admission. No filesystem I/O. The loop records the difference from what
+	 * the conversation already says.
+	 */
+	fileEvidenceEntries(messages: readonly Message[]): FileEvidence[] {
+		return visibleFileEvidence(
+			messages,
+			this.fileReadTracker,
+			this.config.workingDirectory,
+			this.sandboxed,
+		)
+	}
+
+	/** The whole of the evidence as one text, from the same ledger. No filesystem I/O. */
 	describeFileEvidence(messages: readonly Message[]): string | undefined {
 		return describeVisibleFileEvidence(
 			messages,
@@ -2167,6 +2212,7 @@ export class ToolExecutor {
 				this.dispatchNested(name, input, context, recordObservation, undefined, options),
 			sandbox: this.config.sandbox,
 			fileReadTracker: this.fileReadTracker,
+			receiptVisible: this.receiptVisible,
 			...(this.config.codeAnalysis ? { codeAnalysis: this.config.codeAnalysis } : {}),
 			// Bound to this turn, once. Binding here rather than passing the
 			// owner from the tool is what makes the scoping structural: there
@@ -2566,6 +2612,15 @@ export class ToolExecutor {
 
 		if (this.workingStateManager) {
 			extractFromToolResult(this.workingStateManager, toolName, output, effectiveIsError)
+			// What the model was shown, kept whole so a compaction can put it back.
+			recordRestorable(this.workingStateManager, {
+				toolName,
+				input,
+				output: typeof modelContent === 'string' ? modelContent : output,
+				success: !effectiveIsError,
+				unchanged: result.facts?.kind === 'read' && result.facts.unchanged === true,
+				workingDirectory: this.config.workingDirectory,
+			})
 			for (const pin of this.config.abortSignal.aborted ? [] : (result.workingState ?? [])) {
 				this.workingStateManager.pin(pin.key, pin.text, toolName)
 			}

package/src/runtime/query/file-evidence-context.ts

@@ -29,14 +29,13 @@ import {
  */
 const MAX_RECEIPT_UNITS = 32_000
 
-/** The heading of the file-evidence block; a later block under it replaces an earlier one. */
-export const FILE_EVIDENCE_HEADING =
-	'Visible file evidence (as of this step; a later block with this heading replaces this one)'
+/** The words every file-evidence entry opens with. */
+export const FILE_EVIDENCE_HEADING = 'Visible file evidence'
 
-/** Said when the entries of an earlier block no longer hold and none replaces them. */
-export const FILE_EVIDENCE_NONE = `${FILE_EVIDENCE_HEADING}: no entry holds any longer.`
+/** Starts the line of an entry that names the paths whose earlier entries no longer hold. */
+const NO_LONGER_HOLDS = 'No longer holds: '
 
-interface FileEvidence {
+export interface FileEvidence {
 	readonly path: string
 	/** Absent on the write-rooted entries; `'read'` on a body that is a receipt. */
 	readonly kind?: 'read'
@@ -46,14 +45,14 @@ interface FileEvidence {
 }
 
 /** Join visible call bodies, successful receipts and this executor's observation ledger. */
-export function describeVisibleFileEvidence(
+export function visibleFileEvidence(
 	messages: readonly Message[],
 	tracker: FileReadTracker,
 	workingDirectory: string,
 	sandboxed: boolean,
-): string | undefined {
+): FileEvidence[] {
 	// Execution-owned witnesses survive transparent wrappers; a name alone proves nothing.
-	if (!tracker.writeCallId || !tracker.fingerprint) return
+	if (!tracker.writeCallId || !tracker.fingerprint) return []
 	// Lexical, as this projection has always looked entries up: a spelling that
 	// does not resolve to the tool's canonical key finds nothing and the path is
 	// simply not admitted. Writing the ledger is the side that has to key the
@@ -85,8 +84,77 @@ export function describeVisibleFileEvidence(
 			// Malformed retained inputs or a custom tracker cannot establish evidence.
 		}
 	}
-	if (files.size === 0) return
-	return `${FILE_EVIDENCE_HEADING}: each entry's current body is the complete body in the named successful write call, with the edit calls in editsInCalls — when present — applied in that order. An entry marked kind:"read" instead names a successful read call whose own receipt shows the file WHOLE, rendered with every line behind its own N<tab> prefix; that receipt is the body, and such an entry never carries editsInCalls. This runtime performed that reconstruction and checked it against its own file observation; it is not a derivation left to you. Reuse the body for a targeted edit; a read solely to recall it is unnecessary. This is NOT a fresh disk check, and after a resume the observation behind an entry may itself have been rebuilt from this conversation's own earlier calls rather than made while this process ran. Built-in edit/write still compare the disk body at mutation admission and refuse observed drift; on refusal inspect the current file and replan. Missing entries establish nothing.\n${JSON.stringify([...files.values()])}`
+	return [...files.values()]
+}
+
+const FILE_EVIDENCE_GUIDANCE = `each entry names a file (path), the successful write call that holds its complete current body (bodyInCall, that call's id), the edit calls to apply to that body in order (editsInCalls, when present), and a short code for the file as this runtime last observed it (observedFingerprint, which changes when the content does). An entry marked kind:"read" instead names a successful read call whose own receipt shows the whole file, every line behind its own N<tab> prefix; that receipt is the body, and such an entry never carries edit calls. The runtime did that reconstruction and checked it against its own file observation. Reuse the body for a targeted edit; a read only to recall it is unnecessary. This is not a fresh disk check, and after a resume the observation behind an entry may have been rebuilt from this conversation's earlier calls rather than made while this process ran. The built-in edit and write tools still compare the disk body when they run and refuse on drift; on refusal, inspect the current file and replan. Missing entries establish nothing. An entry for a path replaces every earlier entry for that path, and a path listed under "No longer holds" has no entry any more.`
+
+/** The whole of what holds now: every entry, with the guidance for reading them. */
+export function describeVisibleFileEvidence(
+	messages: readonly Message[],
+	tracker: FileReadTracker,
+	workingDirectory: string,
+	sandboxed: boolean,
+): string | undefined {
+	const entries = visibleFileEvidence(messages, tracker, workingDirectory, sandboxed)
+	if (entries.length === 0) return
+	return `${FILE_EVIDENCE_HEADING}: ${FILE_EVIDENCE_GUIDANCE}\n${JSON.stringify(entries)}`
+}
+
+/**
+ * The entries an earlier record still holds, by path, as the JSON each was
+ * written with. Read from the record's text, in order, so a later entry for a
+ * path replaces an earlier one and a retracted path is gone.
+ */
+function heldFileEvidence(recorded: readonly string[]): Map<string, string> {
+	const held = new Map<string, string>()
+	for (const text of recorded) {
+		for (const line of text.split('\n')) {
+			try {
+				if (line.startsWith(NO_LONGER_HOLDS)) {
+					const paths: unknown = JSON.parse(line.slice(NO_LONGER_HOLDS.length))
+					if (Array.isArray(paths))
+						for (const path of paths) if (typeof path === 'string') held.delete(path)
+				} else if (line.startsWith('[')) {
+					const entries: unknown = JSON.parse(line)
+					if (Array.isArray(entries))
+						for (const entry of entries)
+							if (typeof entry?.path === 'string') held.set(entry.path, JSON.stringify(entry))
+				}
+			} catch {
+				// a line of the record that is not an entry list
+			}
+		}
+	}
+	return held
+}
+
+/**
+ * What to record now about the files, given what holds (`current`) and what
+ * the entries already in the conversation say (`recorded`, oldest first):
+ * only the entries that are new or changed, and the paths whose earlier entry
+ * no longer holds. An earlier entry is never edited; this says what replaces
+ * it. The first record of a conversation carries the guidance for reading
+ * entries, later ones do not repeat it. Nothing to say returns undefined.
+ */
+export function recordFileEvidence(
+	current: readonly FileEvidence[],
+	recorded: readonly string[],
+): string | undefined {
+	const held = heldFileEvidence(recorded)
+	const changed = current.filter((entry) => held.get(entry.path) !== JSON.stringify(entry))
+	const now = new Set(current.map((entry) => entry.path))
+	const gone = [...held.keys()].filter((path) => !now.has(path))
+	if (changed.length === 0 && gone.length === 0) return
+	const lead =
+		recorded.length === 0
+			? `${FILE_EVIDENCE_HEADING}: ${FILE_EVIDENCE_GUIDANCE}`
+			: `${FILE_EVIDENCE_HEADING}, changed since the last entry; \`bodyInCall\` and \`observedFingerprint\` read as before. An entry for a path replaces the earlier entries for that path.`
+	return [
+		lead,
+		...(gone.length > 0 ? [`${NO_LONGER_HOLDS}${JSON.stringify(gone)}`] : []),
+		...(changed.length > 0 ? [JSON.stringify(changed)] : []),
+	].join('\n')
 }
 
 /** A full body that arrived whole in one call and is still the file's body. */

package/src/runtime/query/index.ts

@@ -64,6 +64,7 @@ import {
 	type AssistantMessage,
 	type Message,
 	createSystemMessage,
+	lastPromptText,
 } from '../../types/message/index.js'
 import type { AgentPersona } from '../../types/persona/index.js'
 import type { LLMProvider } from '../../types/provider/index.js'
@@ -813,6 +814,13 @@ export interface QueryParams {
 	 */
 	projectInstructionContext?: ProjectInstructionContext
 
+	/**
+	 * Text the host wants carried across a compaction, such as where its plan
+	 * file is. Asked once per pass, after the summary is written; the answer is
+	 * appended to the restored context. Returning nothing adds nothing.
+	 */
+	postCompactionContext?: () => string | undefined | Promise<string | undefined>
+
 	/**
 	 * Where this conversation's durable state lives.
 	 *
@@ -1655,6 +1663,8 @@ export async function* query(params: QueryParams): AsyncGenerator<SessionEvent,
 		const compactionConfig = params.compactionConfig
 			? CompactionConfigSchema.parse(params.compactionConfig)
 			: undefined
+		// The live history, so a tool can ask whether an earlier receipt is still in it.
+		toolExecutor.setHistoryView(() => ctx.recorder.messages)
 		if (compactionConfig && compactionConfig.strategy !== 'disabled') {
 			workingStateManager = new WorkingStateManager(compactionConfig)
 			toolExecutor.setWorkingStateManager(workingStateManager)
@@ -1828,6 +1838,9 @@ export async function* query(params: QueryParams): AsyncGenerator<SessionEvent,
 			...(params.projectInstructionContext
 				? { projectInstructionContext: params.projectInstructionContext }
 				: {}),
+			...(params.postCompactionContext
+				? { postCompactionContext: params.postCompactionContext }
+				: {}),
 			...(providerContextWindow !== undefined ? { providerContextWindow } : {}),
 			resolveModelContextWindow: async (model) => {
 				if (!modelContextWindows.has(model)) {
@@ -2028,7 +2041,7 @@ export async function* query(params: QueryParams): AsyncGenerator<SessionEvent,
 						{
 							turnId: ctx.turnId,
 							sessionId: params.sessionId,
-							prompt: lastUserPrompt(initialMessages),
+							prompt: lastPromptText(initialMessages),
 							signal: ctx.abortController.signal,
 						},
 						eventTranslator.emitEvent,
@@ -2893,15 +2906,6 @@ async function settleAbandonedTurn(
 	}
 }
 
-/** The text of the newest user turn, which is what a prompt hook is asked about. */
-function lastUserPrompt(messages: readonly Message[]): string {
-	for (let i = messages.length - 1; i >= 0; i--) {
-		const m = messages[i]
-		if (m?.role === 'user' && typeof m.content === 'string') return m.content
-	}
-	return ''
-}
-
 type DrainQueryParams = Omit<QueryParams, 'resumeHandler'> & {
 	resumeHandler?: ResumeHandler
 }

package/src/runtime/query/iteration/index.ts

@@ -28,7 +28,6 @@ import {
 import { getTracer } from '../../../telemetry/runtime-accessors.js'
 import { STRUCTURED_OUTPUT_TOOL_NAME } from '../../../tools/builtins/structuredOutput.js'
 import type { ToolManager } from '../../../toolsets/manager.js'
-import { splitAtEvidenceBlocks } from '../../../turn/evidence-recall.js'
 import type { CostInfo, TokenUsage } from '../../../types/common/index.js'
 import { NamzuError } from '../../../types/errors/index.js'
 import type { MessageId, SessionId, TurnId } from '../../../types/ids/index.js'
@@ -58,7 +57,6 @@ import { createCallbackInference } from '../callback-inference.js'
 import { SandboxAcquisitionStopped } from '../deferred-sandbox.js'
 import { deliverDurableInbound } from '../durable-inbound.js'
 import type { ToolCallOutcome } from '../executor.js'
-import { FILE_EVIDENCE_NONE } from '../file-evidence-context.js'
 import { projectObservationContext } from '../observation-context.js'
 import { applyLifecycleHookResults } from '../plugin-hooks.js'
 import {
@@ -103,17 +101,16 @@ import {
 	type TextOnlyModelRefusal,
 	streamWithProviderRejectedImageRecovery,
 } from './provider-rejected-image.js'
+import { appendRecordedContext } from './recorded-context.js'
 import { type MediaRemoval, RequestRepair } from './request-repair.js'
-import { TurnContextCarry } from './step-context.js'
+import { placeRequestContext } from './step-context.js'
 import {
-	FILE_EVIDENCE_KEY,
 	type StepShaping,
-	appendWorkContext,
 	beforeStep,
 	prepareStep,
 	selectContextModel,
 	stepContextMessage,
-	workContextBlocks,
+	workContext,
 } from './step-shaping.js'
 import { streamProviderTurn } from './stream-turn.js'
 
@@ -194,8 +191,7 @@ export class IterationOrchestrator {
 	 * one process must not suppress each other's first envelope.
 	 */
 	private lastEnvelopeKey: string | undefined
-	/** Where this turn's request-only data first went, so it stays there. */
-	private readonly turnContext = new TurnContextCarry()
+	/** The previous request's context, so a pre-call hook is told what changed. */
 	private previousRequestContext: RequestContextSnapshot | undefined
 
 	private projectObservations(messages: Message[]): Message[] {
@@ -838,6 +834,11 @@ export class IterationOrchestrator {
 								'limit-finalization',
 							)
 						: undefined
+					// What the step asked to have kept in the conversation joins the
+					// history now, after its last message, so this request and every
+					// later one begin with it. Nothing is inserted ahead of a message
+					// that is already recorded.
+					appendRecordedContext(recorder, step.recordedContext, this.ctx.log)
 					const baseMessages = recorder.messages
 
 					// Step guidance is appended to the REQUEST, never pushed onto
@@ -911,24 +912,30 @@ export class IterationOrchestrator {
 							DEFAULT_MAX_REQUEST_RICH_CONTENT_BYTES,
 						{ imagesReadable: this.modelReadsImages(stepModel) },
 					)
-					// The blocks of data that belong to this turn (recalled memory and
-					// evidence, the context contributions, the work context) sit just
-					// before the operator's latest message the first time the model
-					// answers it, so the request is the last thing it reads. They stay
-					// there on every later call of the turn, and a block that first
-					// appears on a later call follows the history of that moment, so each
-					// request begins with the whole of the one before it. The short
-					// reminders and notices stay after the history.
+					// Request-only data (the context contributions, notes about the
+					// search, the work context) goes last on every call, after the
+					// whole history, so the history a caching driver reads never
+					// changes shape from one call to the next. What a step wants
+					// kept is recorded in the history above instead. The short
+					// reminders and notices follow it.
 					const messages = [...projected]
-					this.turnContext.place(
+					// What the loop learns about files and finished work holds until it
+					// changes, so it is recorded, after the history as it stands, and
+					// carried in this request where it will sit in the next one's history.
+					const work = workContext(shaping, projected, iterationNum, step)
+					const recordedNow = appendRecordedContext(recorder, work.recorded, this.ctx.log)
+					placeRequestContext(
 						messages,
-						requestHistory,
-						workingMemory.history.at(-1),
-						[contextText, ...(step.context ? splitAtEvidenceBlocks(step.context) : [])]
-							.filter((text): text is string => Boolean(text))
-							.map(stepContextMessage),
-						workContextBlocks(shaping, projected, iterationNum, step),
-						{ [FILE_EVIDENCE_KEY]: stepContextMessage(FILE_EVIDENCE_NONE) },
+						recordedNow,
+						// The working-memory block and the policy notice already end the
+						// request; the entries just recorded belong ahead of them.
+						(workingMemory.context ? 1 : 0) + (policyNotice ? 1 : 0),
+						[
+							...[contextText, step.context]
+								.filter((text): text is string => Boolean(text))
+								.map(stepContextMessage),
+							...work.requestOnly,
+						],
 					)
 					if (closingDirective) messages.push(closingDirective)
 					await this.reportUnsupportedToolResults(messages)
@@ -2896,9 +2903,8 @@ export class IterationOrchestrator {
 				this.ctx.turnConfig.maxRequestRichContentBytes ?? DEFAULT_MAX_REQUEST_RICH_CONTENT_BYTES,
 				{ imagesReadable: this.modelReadsImages(model) },
 			)
-			appendWorkContext(this.stepShaping(), finalMessages, this.steps.length + 1, { model })
 			// The closing directive is the last thing the model reads: after
-			// the working memory and any work context above.
+			// the working memory above.
 			finalMessages.push(
 				createRuntimeContextMessage(
 					`[SYSTEM] Turn is ending due to ${reason}. ${CLOSING_RESPONSE_GUIDANCE}`,

package/src/runtime/query/iteration/phases/compaction.ts

@@ -11,6 +11,7 @@ import {
 } from '../../../../compaction/plan.js'
 import type { ContextReducer, ContextReduction } from '../../../../compaction/reducer.js'
 import { createSlidingWindowReducer } from '../../../../compaction/reducer.js'
+import { renderRestoredContext } from '../../../../compaction/restore.js'
 import { findRetainedIndices } from '../../../../compaction/retention.js'
 import { serializeState } from '../../../../compaction/serializer.js'
 import {
@@ -1003,6 +1004,24 @@ async function runCompactionCheckInner(
 		compactedContent = serializeState(manager.getState())
 	}
 
+	// Skills the model loaded and files it read go back verbatim after the
+	// summary, with whatever the host wants carried across (its plan file).
+	let hostNote: string | undefined
+	try {
+		hostNote = await ctx.postCompactionContext?.()
+	} catch (error) {
+		// A host note is an addition; the pass does not depend on it.
+		ctx.log.warn('The host note for a compaction could not be read — leaving it out', {
+			[NAMZU.TURN_ID]: ctx.recorder.turnId,
+			'exception.message': error instanceof Error ? error.message : String(error),
+		})
+	}
+	const restored = renderRestoredContext(manager.getState(), {
+		contextWindowTokens: budget,
+		...(hostNote ? { hostNote } : {}),
+	})
+	if (restored) compactedContent = `${compactedContent}\n\n${restored}`
+
 	// The pointer is only worth a line when both tools it names are mounted.
 	const mounted = new Set(ctx.tools?.listNames?.() ?? [])
 	const compactionMessage = buildCompactionMessage(

package/src/runtime/query/iteration/phases/context.ts

@@ -256,6 +256,9 @@ export interface IterationContext {
 	/** Live project policy; separate from human inbound continuation. */
 	readonly projectInstructionContext?: ProjectInstructionContext
 
+	/** Host text appended to the restored context after a compaction. */
+	readonly postCompactionContext?: () => string | undefined | Promise<string | undefined>
+
 	readonly workingStateManager?: WorkingStateManager
 
 	/**

package/src/runtime/query/iteration/recorded-context.ts

@@ -0,0 +1,48 @@
+import { NAMZU } from '../../../constants/telemetry/index.js'
+import type { TurnRecorder } from '../../../manager/session/turn-recorder.js'
+import {
+	type Message,
+	createTurnContextEntry,
+	isTurnContextKey,
+	turnContextEntries,
+} from '../../../types/message/index.js'
+import type { RecordedContextItem } from '../../../types/session/index.js'
+import type { Logger } from '../../../utils/logger.js'
+
+/**
+ * Append what a step asked to have recorded, after whatever the history
+ * ends with.
+ *
+ * Only at the end: an entry slipped in ahead of the operator's message would
+ * put the live array out of log order, and the recorder would then write a
+ * whole compaction record to re-base it on every turn. An item adds nothing
+ * when its text is empty or equals the last entry under its key, so a step
+ * that offers the same text on every call records it once. Returns the
+ * entries it added, so a request built before they were added can carry them
+ * at the place they will hold.
+ */
+export function appendRecordedContext(
+	recorder: Pick<TurnRecorder, 'messages' | 'pushMessage' | 'turnId'>,
+	items: readonly RecordedContextItem[] | undefined,
+	log: Pick<Logger, 'warn'>,
+	at: Date = new Date(),
+): Message[] {
+	const appended: Message[] = []
+	for (const item of items ?? []) {
+		const text = item.text.trim()
+		if (text.length === 0) continue
+		if (!isTurnContextKey(item.key)) {
+			log.warn('A step recorded context under a key that is not a name; it was skipped', {
+				[NAMZU.TURN_ID]: recorder.turnId,
+				'namzu.runtime.key': String(item.key).slice(0, 80),
+			})
+			continue
+		}
+		const earlier = turnContextEntries(recorder.messages, item.key)
+		if (earlier.at(-1) === text) continue
+		const entry = createTurnContextEntry(item.key, text, at, { later: earlier.length > 0 })
+		recorder.pushMessage(entry)
+		appended.push(entry)
+	}
+	return appended
+}