@namzu/sdk 62.7.0 → 62.9.0

package/src/compaction/salience/working-set.ts

@@ -73,14 +73,18 @@ export function isStubbedNarration(content: unknown): boolean {
 	return typeof content === 'string' && content.includes(STUB_MARK)
 }
 
-export function planWorkingSet(
+/** What decides whether a message is something the pass may shed at all. */
+interface EvictionRules {
+	readonly minTool: number
+	readonly minNarration: number
+	readonly preserve: ReadonlySet<string>
+	readonly toolNameByCallId: ReadonlyMap<string, string>
+}
+
+function evictionRules(
 	messages: readonly Message[],
-	scored: readonly ScoredMessage[],
-	options: WorkingSetOptions,
-): WorkingSetPlan {
-	const minTool = options.minToolResultChars ?? 1_000
-	const minNarration = options.minNarrationChars ?? 240
-	const preserve = new Set(options.preserveTools ?? [])
+	options: Pick<WorkingSetOptions, 'minToolResultChars' | 'minNarrationChars' | 'preserveTools'>,
+): EvictionRules {
 	const toolNameByCallId = new Map<string, string>()
 	for (const m of messages) {
 		if (m.role !== 'assistant') continue
@@ -88,6 +92,87 @@ export function planWorkingSet(
 			toolNameByCallId.set(call.id, call.function.name)
 		}
 	}
+	return {
+		minTool: options.minToolResultChars ?? 1_000,
+		minNarration: options.minNarrationChars ?? 240,
+		preserve: new Set(options.preserveTools ?? []),
+		toolNameByCallId,
+	}
+}
+
+/**
+ * Whether the pass could clear or stub this message, ignoring only what
+ * protection decides (the floor, the recent turns, retained turns, a pair
+ * with a protected half) and what the score decides. The one place the
+ * eligibility rules live: {@link planWorkingSet} asks it of each unprotected
+ * message, and {@link hasEvictableMessage} asks it of every message.
+ */
+function evictionKind(m: Message, tokens: number, rules: EvictionRules): 'clear' | 'stub' | null {
+	if (tokens === 0) return null
+	if (m.role === 'tool') {
+		const tool = m as ToolMessage
+		if (tool.isError || isClearedToolResult(tool.content)) return null
+		if (rules.preserve.has(rules.toolNameByCallId.get(tool.toolCallId) ?? '')) return null
+		if (tokens * CHARS_PER_TOKEN < rules.minTool) return null
+		return 'clear'
+	}
+	if (m.role === 'assistant' && !Array.isArray((m as AssistantMessage).toolCalls)) {
+		const text = typeof m.content === 'string' ? m.content : ''
+		if (text.length < rules.minNarration || isStubbedNarration(text)) return null
+		return 'stub'
+	}
+	return null
+}
+
+/**
+ * A cheap count of whether anything at all is left for the pass to shed:
+ * false means {@link planWorkingSet} would return no action whatever the
+ * scores are, so scoring can be skipped. It leaves out the two protections
+ * that are only a position (the leading system run and the last
+ * `keepRecentMessages`); retained turns, tool-call pairs and the goal floor
+ * are not looked at. True is therefore only "go and look", and a false is
+ * exact.
+ */
+export function hasEvictableMessage(
+	messages: readonly Message[],
+	options: Pick<WorkingSetOptions, 'minToolResultChars' | 'minNarrationChars' | 'preserveTools'> & {
+		readonly keepRecentMessages: number
+	},
+): boolean {
+	const rules = evictionRules(messages, options)
+	let floorEnd = 0
+	while (floorEnd < messages.length && messages[floorEnd]?.role === 'system') floorEnd += 1
+	const end = Math.max(floorEnd, messages.length - options.keepRecentMessages)
+	for (let i = floorEnd; i < end; i += 1) {
+		const m = messages[i] as Message
+		if (evictionKind(m, estimateMessageTokens(m), rules) !== null) return true
+	}
+	return false
+}
+
+/** The plan of a pass that sheds nothing: every message as it was. */
+export function planNothingToShed(
+	messages: readonly Message[],
+	options: Pick<WorkingSetOptions, 'estimatedTokens' | 'targetTokens'>,
+): WorkingSetPlan {
+	return {
+		messages: [...messages],
+		actions: [],
+		clearedCount: 0,
+		stubbedCount: 0,
+		charsReclaimed: 0,
+		reclaimedTokens: 0,
+		reachedTarget: options.estimatedTokens - options.targetTokens <= 0,
+	}
+}
+
+export function planWorkingSet(
+	messages: readonly Message[],
+	scored: readonly ScoredMessage[],
+	options: WorkingSetOptions,
+): WorkingSetPlan {
+	const rules = evictionRules(messages, options)
+	const { toolNameByCallId } = rules
 
 	// Ordered by salience, not salience per token. Per token was the plan's
 	// first answer and it evicts the wrong thing: a large result the goal
@@ -104,31 +189,17 @@ export function planWorkingSet(
 	}
 	const candidates: Candidate[] = []
 	for (const s of scored) {
-		if (s.protected !== null || s.tokens === 0) continue
+		if (s.protected !== null) continue
 		const m = messages[s.index] as Message
-		if (m.role === 'tool') {
-			const tool = m as ToolMessage
-			if (tool.isError || isClearedToolResult(tool.content)) continue
-			if (preserve.has(toolNameByCallId.get(tool.toolCallId) ?? '')) continue
-			if (s.tokens * CHARS_PER_TOKEN < minTool) continue
-			candidates.push({
-				index: s.index,
-				kind: 'clear',
-				salience: s.salience,
-				tokens: s.tokens,
-				goalBound: s.relevance >= 0.5 || s.utility >= 1,
-			})
-		} else if (m.role === 'assistant' && !Array.isArray((m as AssistantMessage).toolCalls)) {
-			const text = typeof m.content === 'string' ? m.content : ''
-			if (text.length < minNarration || isStubbedNarration(text)) continue
-			candidates.push({
-				index: s.index,
-				kind: 'stub',
-				salience: s.salience,
-				tokens: s.tokens,
-				goalBound: s.relevance >= 0.5 || s.utility >= 1,
-			})
-		}
+		const kind = evictionKind(m, s.tokens, rules)
+		if (kind === null) continue
+		candidates.push({
+			index: s.index,
+			kind,
+			salience: s.salience,
+			tokens: s.tokens,
+			goalBound: s.relevance >= 0.5 || s.utility >= 1,
+		})
 	}
 	candidates.sort((a, b) => a.salience - b.salience || b.tokens - a.tokens || a.index - b.index)
 	const maxSalience = candidates.reduce((m, c) => Math.max(m, c.salience), Number.NEGATIVE_INFINITY)

package/src/config/runtime.ts

@@ -32,6 +32,20 @@ export const CompactionConfigSchema = z.object({
 	 * `triggerThreshold` summarises. The context is held around here.
 	 */
 	softTarget: z.number().min(0).max(1).optional(),
+	/**
+	 * `salience` only: how far below `softTarget`, as a fraction of the
+	 * window, a pass sheds. A pass still starts when the context reaches the
+	 * soft target, but it then keeps shedding until the context is
+	 * `softTargetHeadroom` of the window under it, so the next pass is needed
+	 * only after that headroom has been used instead of on the next turn.
+	 * Fewer passes, and the request is rewritten (a prompt cache's prefix
+	 * broken) once per headroom instead of once per turn; the cost is that
+	 * the context is held that much lower, so that much less history stays
+	 * whole. The messages shed are the same ones in the same order, only
+	 * earlier. Absent or `0`, the default, a pass sheds to the soft target
+	 * and no further, exactly as before.
+	 */
+	softTargetHeadroom: z.number().min(0).max(1).optional(),
 	/**
 	 * Optional model context-window size (tokens) the compaction trigger
 	 * measures the CURRENT window against. NO default: when omitted the

package/src/manager/session/turn-recorder.ts

@@ -1,3 +1,4 @@
+import { isDeepStrictEqual } from 'node:util'
 import {
 	AUTO_CONTINUATION_USER_MESSAGE,
 	REASONING_CUT_USER_MESSAGE,
@@ -7,6 +8,7 @@ import { NAMZU } from '../../constants/telemetry/index.js'
 import { resolveModelPricing } from '../../pricing/index.js'
 import type { SessionTokenBudget } from '../../store/budget/index.js'
 import type { SessionCheckpointStore } from '../../store/checkpoint/index.js'
+import { foldSessionLog } from '../../store/session-log/incremental.js'
 import {
 	type SessionLease,
 	type SessionLog,
@@ -93,6 +95,16 @@ function stampMessageId(message: Message, id: MessageId | undefined): void {
 	else (message as { id?: MessageId }).id = id
 }
 
+/** Two messages that differ only in their id and time are the same text. */
+function sameStoredContent(a: Message, b: Message): boolean {
+	const { id: _a, timestamp: _ta, ...restA } = a
+	const { id: _b, timestamp: _tb, ...restB } = b
+	return isDeepStrictEqual(
+		JSON.parse(JSON.stringify(restA)) as unknown,
+		JSON.parse(JSON.stringify(restB)) as unknown,
+	)
+}
+
 /** How {@link TurnRecorder.open} takes the session's writer lease and starts an empty log. */
 export interface TurnRecorderOpenOptions {
 	/** A lease the caller already holds. Absent: the recorder claims one and releases it at the end. */
@@ -254,6 +266,8 @@ export class TurnRecorder {
 	 * these needs no re-basing, so no `compaction` record is written for it.
 	 */
 	#foldIdsAtResume: readonly MessageId[] | undefined
+	/** What the log folds to for a message a replacement or an edit changed, as of the resume. */
+	#foldEditedAtResume = new Map<MessageId, Message>()
 	/** When a resumed turn began: its `turn_started` record, not this process's start. */
 	#resumedTurnStartedAt: number | undefined
 
@@ -867,21 +881,38 @@ export class TurnRecorder {
 	async #readResumedLog(): Promise<readonly MessageId[] | undefined> {
 		await this.flush()
 		const fold = new SessionMessageFold()
+		// Whether the latest change to a message was a compaction edit: only
+		// that one is the recorder's to put back (a guardrail's replacement is
+		// the settled answer and the restored context is not allowed to undo it).
+		const latestChange = new Map<MessageId, 'edited' | 'replaced'>()
 		for await (const entry of this.log.read()) {
 			const record = entry.record as SessionRecord
 			if (record.type === 'turn_started' && record.turnId === this.turnId) {
 				const at = Date.parse(record.ts)
 				if (Number.isFinite(at)) this.#resumedTurnStartedAt = at
 			}
+			if (record.type === 'message_edited') latestChange.set(record.targetMessageId, 'edited')
+			else if (record.type === 'message_replaced')
+				latestChange.set(record.targetMessageId, 'replaced')
 			fold.apply(record)
 		}
-		if (fold.spilledSummary) return undefined
 		const ids: MessageId[] = []
+		let allRecorded = !fold.spilledSummary
+		this.#foldEditedAtResume.clear()
+		// Filled for every fold entry with an id, whether or not the fold also
+		// holds id-less entries (a summary): a restored context older than an edit
+		// is put right either way. An entry whose text is spilled is not
+		// compared, so a message edited to a spilled text is not put back.
 		for (const entry of fold.entries()) {
-			if (!entry.messageId) return undefined
+			if (!entry.messageId) {
+				allRecorded = false
+				continue
+			}
 			ids.push(entry.messageId)
+			if (latestChange.get(entry.messageId) === 'edited' && entry.spill === undefined)
+				this.#foldEditedAtResume.set(entry.messageId, entry.message)
 		}
-		return ids
+		return allRecorded ? ids : undefined
 	}
 
 	/** The recorded context is exactly what the log folds to: a resume changed nothing. */
@@ -1092,6 +1123,13 @@ export class TurnRecorder {
 		options: {
 			readonly messageId?: MessageId
 			readonly transient?: boolean
+			/**
+			 * The message is part of the history a resume restores, not a new
+			 * one. While the resume's re-base is pending, a restored message with no
+			 * id is held and nothing is reconciled; the first message that is not
+			 * restored (or any other reconcile) re-bases once on the whole context.
+			 */
+			readonly restored?: boolean
 		} = {},
 	): void {
 		if (options.messageId) {
@@ -1109,6 +1147,16 @@ export class TurnRecorder {
 			})
 			return
 		}
+		if (options.restored && this.#rebasePending && this.#phase === 'active') {
+			// A restored message with no id (a compaction summary, the working-memory
+			// slot, a message the host added) can arrive before the recorded ones.
+			// Reconciling now would re-base the fold on a context holding only it and
+			// drop the recorded messages that follow; hold it as an id-less view entry
+			// and let the first reconciliation after the whole context is in place
+			// write one `compaction` that keeps the recorded ids after it.
+			this.#view.push({ message })
+			return
+		}
 		this.#syncMessages()
 	}
 
@@ -1151,6 +1199,100 @@ export class TurnRecorder {
 		return id
 	}
 
+	/**
+	 * A compaction pass edits one message by replacing its object with a copy
+	 * that has other content (`{ ...message, content }`). The copy still carries
+	 * the id the original was stamped with, but the recorder's own indexes are
+	 * keyed by object identity, so without this it would see an unknown message
+	 * and record every message after it again. A live object that is not in the
+	 * view, whose `id` is that of a recorded view entry whose own object has left
+	 * the context, is that same message edited: one `message_edited` record
+	 * carries its new content and the view entry follows the new object.
+	 *
+	 * Only an id claimed by exactly one live object is taken, so two copies of
+	 * one message are never both treated as its edit. Anything else is left to
+	 * the callers, which record it as a new message.
+	 */
+	#absorbEdits(): void {
+		if (this.#phase !== 'active') return
+		const live = this.#turn.messages
+		const inContext = new Set<Message>(live)
+		let orphans: Map<MessageId, ViewEntry> | undefined
+		for (const entry of this.#view) {
+			if (entry.id === undefined || entry.transient || inContext.has(entry.message)) continue
+			orphans ??= new Map()
+			orphans.set(entry.id, entry)
+		}
+		if (orphans === undefined) return
+		const known = new Set<Message>(this.#view.map((entry) => entry.message))
+		const claimed = new Map<MessageId, Message[]>()
+		for (const message of live) {
+			if (known.has(message) || this.#transient.has(message)) continue
+			const id = message.id
+			if (id === undefined || !orphans.has(id)) continue
+			const list = claimed.get(id)
+			if (list) list.push(message)
+			else claimed.set(id, [message])
+		}
+		const turnId = this.turnId
+		for (const [id, messages] of claimed) {
+			const message = messages[0] as Message
+			const entry = orphans.get(id) as ViewEntry
+			if (messages.length !== 1 || message.role !== entry.message.role) continue
+			// `previous` is the live object the view holds: a message mutated in place
+			// and then replaced by a copy of itself is adopted without a record, and
+			// the fold keeps the text it recorded.
+			const previous = entry.message
+			entry.message = message
+			this.#ids.set(message, id)
+			this.#recorded.set(message, id)
+			// A copy with the same text (a structured clone, a re-parsed message)
+			// is adopted as is: the fold already shows that content.
+			if (sameStoredContent(previous, message)) continue
+			void this.#enqueue(() =>
+				this.#append({
+					type: 'message_edited',
+					turnId,
+					targetMessageId: id,
+					content: message,
+					ignorable: true,
+					reason: 'compaction',
+				}),
+			).catch(() => undefined)
+		}
+	}
+
+	/**
+	 * A resume restores the context a checkpoint holds, which can predate a
+	 * compaction edit written after it. The ids still match, so the log is not
+	 * re-based; but the fold then shows the edited text of a message the context
+	 * holds as it was. One `message_edited` per such message makes the fold show
+	 * the context the resume actually runs with.
+	 */
+	#recordDriftFromFold(): void {
+		const edited = this.#foldEditedAtResume
+		if (edited.size === 0) return
+		const turnId = this.turnId
+		for (const entry of this.#view) {
+			if (entry.id === undefined || entry.transient) continue
+			const folded = edited.get(entry.id)
+			if (folded === undefined || sameStoredContent(folded, entry.message)) continue
+			const message = entry.message
+			const id = entry.id
+			void this.#enqueue(() =>
+				this.#append({
+					type: 'message_edited',
+					turnId,
+					targetMessageId: id,
+					content: message,
+					ignorable: true,
+					reason: 'resume',
+				}),
+			).catch(() => undefined)
+		}
+		edited.clear()
+	}
+
 	/**
 	 * Reconcile the context with the log. Nothing is written before the turn
 	 * begins or after it pauses or settles.
@@ -1163,9 +1305,15 @@ export class TurnRecorder {
 			this.#foldIdsAtResume = undefined
 			if (!unchanged) {
 				this.#recordCompaction()
+				// Kept ids whose restored text differs from the edited text the fold
+				// holds get their record; entries re-recorded under fresh ids are not
+				// in the map and are skipped.
+				this.#recordDriftFromFold()
 				return
 			}
+			this.#recordDriftFromFold()
 		}
+		this.#absorbEdits()
 		const live = this.#turn.messages
 		const view = this.#view
 		let prefix = 0
@@ -1204,6 +1352,7 @@ export class TurnRecorder {
 	 * log order, the whole context becomes the summary.
 	 */
 	#recordCompaction(): void {
+		this.#absorbEdits()
 		const live = this.#turn.messages
 		const byMessage = new Map(this.#view.map((entry) => [entry.message, entry]))
 		const next: ViewEntry[] = live.map((message) => {
@@ -1441,12 +1590,29 @@ export async function readFoldedHistory(
 	log: SessionLog,
 	options: { readonly throughSeq?: number } = {},
 ): Promise<RecordedMessage[]> {
+	// Folding the whole log is advanced from the last record the previous call
+	// folded, not redone from byte 0 on every turn. A fold to a seq is a
+	// different question and is read in full.
+	if (options.throughSeq === undefined) {
+		return foldSessionLog(log, {
+			name: 'folded-history',
+			mode: 'strict',
+			create: () => new SessionMessageFold(),
+			apply: (fold, entry) => fold.apply(entry.record as SessionRecord),
+			result: (fold) => recordedMessages(log, fold),
+		})
+	}
 	const fold = new SessionMessageFold()
-	for await (const entry of log.read(
-		options.throughSeq !== undefined ? { throughSeq: options.throughSeq } : {},
-	)) {
+	for await (const entry of log.read({ throughSeq: options.throughSeq })) {
 		fold.apply(entry.record as SessionRecord)
 	}
+	return recordedMessages(log, fold)
+}
+
+async function recordedMessages(
+	log: SessionLog,
+	fold: SessionMessageFold,
+): Promise<RecordedMessage[]> {
 	const out: RecordedMessage[] = []
 	const spilled = fold.spilledSummary
 	if (spilled) {
@@ -1463,9 +1629,10 @@ export async function readFoldedHistory(
 		}
 	}
 	for (const entry of fold.entries()) {
+		// A message from a shared fold is copied: the caller owns what it gets.
 		const message = entry.spill
 			? (JSON.parse(await log.readSpill(entry.spill as SpillRef)) as Message)
-			: entry.message
+			: structuredClone(entry.message)
 		out.push({
 			message: withMessageId(message, entry.messageId),
 			...(entry.messageId ? { messageId: entry.messageId } : {}),
@@ -1474,6 +1641,34 @@ export async function readFoldedHistory(
 	return out
 }
 
+type RecordedContent = { readonly content: Message; readonly spill?: SpillRef }
+
+function recordedContent(record: {
+	readonly content: Message
+	readonly spill?: SpillRef | undefined
+}): RecordedContent {
+	return { content: record.content, ...(record.spill ? { spill: record.spill } : {}) }
+}
+
+/** Every message ever recorded, and the texts an edited one held before each edit. */
+export interface EverRecordedMessages {
+	/** The latest text of each message, by its durable id. */
+	readonly latest: ReadonlyMap<MessageId, Message>
+	/**
+	 * Whether `id` held `message`'s text before a compaction edit. A
+	 * `message_replaced` for the id forgets the texts before it: a guardrail's
+	 * replacement is the settled answer. A spilled earlier text is read only
+	 * when a comparison needs it.
+	 */
+	heldBeforeAnEdit(id: MessageId, message: Message): Promise<boolean>
+}
+
+interface EverRecordedState {
+	readonly latest: Map<MessageId, RecordedContent>
+	/** Only ids that have an edit appear here. */
+	readonly earlier: Map<MessageId, RecordedContent[]>
+}
+
 /**
  * Every message this session's log has ever recorded, keyed by the durable
  * id its `message` record gave it — including one a compaction has since
@@ -1488,29 +1683,63 @@ export async function readFoldedHistory(
 export async function readEverRecordedMessages(
 	log: SessionLog,
 ): Promise<ReadonlyMap<MessageId, Message>> {
-	const latest = new Map<MessageId, { readonly content: Message; readonly spill?: SpillRef }>()
-	for await (const entry of log.read()) {
-		const record = entry.record as SessionRecord
-		if (record.type === 'message') {
-			latest.set(record.messageId, {
-				content: record.content,
-				...(record.spill ? { spill: record.spill } : {}),
-			})
-		} else if (record.type === 'message_replaced') {
-			latest.set(record.targetMessageId, {
-				content: record.content,
-				...(record.spill ? { spill: record.spill } : {}),
-			})
-		}
-	}
-	const resolved = new Map<MessageId, Message>()
-	for (const [id, entry] of latest) {
-		const content = entry.spill
-			? (JSON.parse(await log.readSpill(entry.spill)) as Message)
-			: entry.content
-		resolved.set(id, withMessageId(content, id))
-	}
-	return resolved
+	return (await readEverRecordedMessageIndex(log)).latest
+}
+
+/**
+ * {@link readEverRecordedMessages} plus what a host that cached the history
+ * before a compaction edit still holds, answered from the same reduction with
+ * no read of the log of its own.
+ */
+export async function readEverRecordedMessageIndex(log: SessionLog): Promise<EverRecordedMessages> {
+	return foldSessionLog(log, {
+		name: 'ever-recorded-messages',
+		mode: 'strict',
+		create: (): EverRecordedState => ({ latest: new Map(), earlier: new Map() }),
+		apply: ({ latest, earlier }, entry) => {
+			const record = entry.record as SessionRecord
+			if (record.type === 'message') {
+				latest.set(record.messageId, recordedContent(record))
+			} else if (record.type === 'message_replaced') {
+				earlier.delete(record.targetMessageId)
+				latest.set(record.targetMessageId, recordedContent(record))
+			} else if (record.type === 'message_edited') {
+				const before = latest.get(record.targetMessageId)
+				if (before !== undefined) {
+					const held = earlier.get(record.targetMessageId)
+					if (held) held.push(before)
+					else earlier.set(record.targetMessageId, [before])
+				}
+				latest.set(record.targetMessageId, recordedContent(record))
+			}
+		},
+		result: async ({ latest, earlier }) => {
+			const resolved = new Map<MessageId, Message>()
+			for (const [id, entry] of latest) {
+				// Copied: the map this is read from is shared with the next call.
+				const content = entry.spill
+					? (JSON.parse(await log.readSpill(entry.spill)) as Message)
+					: structuredClone(entry.content)
+				resolved.set(id, withMessageId(content, id))
+			}
+			// A snapshot: the arrays are advanced in place by the next call. The
+			// entries in them are never changed once made.
+			const held = new Map<MessageId, readonly RecordedContent[]>()
+			for (const [id, list] of earlier) held.set(id, [...list])
+			return {
+				latest: resolved,
+				async heldBeforeAnEdit(id, message) {
+					for (const entry of held.get(id) ?? []) {
+						const content = entry.spill
+							? (JSON.parse(await log.readSpill(entry.spill)) as Message)
+							: entry.content
+						if (sameStoredContent(content, message)) return true
+					}
+					return false
+				},
+			}
+		},
+	})
 }
 
 /**

package/src/public-runtime.ts

@@ -1775,6 +1775,7 @@ export {
 	ExternalRefSchema,
 	IgnorableRecordSchema,
 	MessageRecordSchema,
+	MessageEditedRecordSchema,
 	MessageReplacedRecordSchema,
 	OriginSchema,
 	OutcomeProgressWrittenRecordSchema,

package/src/runtime/query/cancelled-before-start.ts

@@ -86,7 +86,7 @@ export async function* settlePreStartCancellation(
 
 	const push = (message: Message, ids: ReadonlyMap<Message, MessageId>): void => {
 		const messageId = ids.get(message)
-		ctx.recorder.pushMessage(message, messageId ? { messageId } : {})
+		ctx.recorder.pushMessage(message, { ...(messageId ? { messageId } : {}), restored: true })
 	}
 	try {
 		if (selectedResumeState) {

package/src/runtime/query/checkpoint.ts

@@ -822,7 +822,8 @@ async function readRecordedMessage(
 		}
 		if (
 			(entry.type === 'message' && entry.messageId === messageId) ||
-			(entry.type === 'message_replaced' && entry.targetMessageId === messageId)
+			((entry.type === 'message_replaced' || entry.type === 'message_edited') &&
+				entry.targetMessageId === messageId)
 		) {
 			found = { content: entry.content, ...(entry.spill ? { spill: entry.spill } : {}) }
 		}

package/src/runtime/query/context.ts

@@ -92,6 +92,34 @@ export interface TurnContext {
 	trackingConfig: ActivityTrackingConfig
 }
 
+/**
+ * Forward `signal`'s abort to `controller` without keeping the controller, or
+ * anything the turn built around it, alive for the life of `signal`.
+ *
+ * The session's signal outlives every turn, and a listener on it is strongly
+ * held for as long as the signal is. A listener that closed over the turn's
+ * controller (and the configuration it was built from) kept each finished
+ * turn's whole object graph in memory, one more per turn. This one holds the
+ * controller through a `WeakRef`, lives in its own scope so the closure
+ * captures nothing else, and is removed once the controller is collected.
+ */
+function relayAbort(signal: AbortSignal, controller: AbortController): void {
+	const controllerRef = new WeakRef(controller)
+	const signalRef = new WeakRef(signal)
+	const relay = (): void => {
+		controllerRef.deref()?.abort(signalRef.deref()?.reason)
+	}
+	signal.addEventListener('abort', relay, { once: true })
+	relayCleanup.register(controller, { signalRef, relay })
+}
+
+const relayCleanup = new FinalizationRegistry<{
+	signalRef: WeakRef<AbortSignal>
+	relay: () => void
+}>(({ signalRef, relay }) => {
+	signalRef.deref()?.removeEventListener('abort', relay)
+})
+
 export class TurnContextFactory {
 	/**
 	 * The turn's one correlated logger, built once and handed to every
@@ -136,11 +164,7 @@ export class TurnContextFactory {
 			if (config.signal.aborted) {
 				abortController.abort(config.signal.reason)
 			} else {
-				config.signal.addEventListener(
-					'abort',
-					() => abortController.abort(config.signal?.reason),
-					{ once: true },
-				)
+				relayAbort(config.signal, abortController)
 			}
 		}
 
@@ -178,7 +202,10 @@ export class TurnContextFactory {
 			config.enableActivityTracking,
 		)
 		const activityStore = new ActivityStore(config.turnId, trackingConfig)
-		const planManager = new PlanManager({ sessionId: config.sessionId, turnId: config.turnId })
+		const planManager = new PlanManager({
+			sessionId: config.sessionId,
+			turnId: config.turnId,
+		})
 		const toolResultsDir =
 			config.storage.sessionDir === undefined
 				? undefined