@xopcai/xopc 0.0.318 → 0.0.319

package/dist/src/agent/embedded/run-turn.js

@@ -16,7 +16,7 @@ import { wrapStreamFnForXopcExtensions } from "./xopc-stream-bridge.js";
 import { acquireEmbeddedSessionRunner, evictEmbeddedSessionRunner } from "./session-runner.js";
 import { projectContextForModel } from "../memory/context-budget.js";
 import { createSqliteTranscriptRuntime } from "./transcript-runtime.js";
-import { ContextRecoveryError, assessContext, recoverContext } from "../memory/context-recovery.js";
+import { assessContext, recoverContext } from "../memory/context-recovery.js";
 import { resolveCompactionPolicy } from "../memory/compaction-policy.js";
 import { buildPromptCacheSnapshot, observePromptCacheSnapshot } from "../../providers/prompt-cache-observability.js";
 import { isPromptCacheExpired, recordPromptCacheTouch } from "../../providers/prompt-cache-lifecycle.js";
@@ -24,7 +24,7 @@ import { markTurnToolResult } from "../memory/turn-provenance.js";
 import { RepositoryInstructions } from "../coding/repository-instructions.js";
 import { RunVerification } from "../coding/run-verification.js";
 import { withDelegationScope } from "../orchestration/delegation-scope.js";
-import { getCurrentSystemPrompt, getCurrentTools } from "@earendil-works/pi-ai";
+import { createAssistantMessageEventStream, getCurrentSystemPrompt, getCurrentTools, isRecoverableLength } from "@earendil-works/pi-ai";
 //#region src/agent/embedded/run-turn.ts
 init_connection_wait_repository();
 init_logger();
@@ -88,53 +88,141 @@ function userMessageToPromptText(message) {
 	}).map((block) => block.text).join("");
 	return "";
 }
-async function maybeRecoverContextOverflow(params) {
-	const errorMessage = getAssistantTurnErrorMessage(params.agent);
-	if (!errorMessage || !isContextOverflowError(errorMessage)) return false;
-	const messages = stripTrailingErrorAssistantMessages(params.agent.state.messages);
-	log.warn({
-		conversationId: params.conversationId,
+function lastAssistantMessage(messages) {
+	for (let index = messages.length - 1; index >= 0; index -= 1) {
+		const message = messages[index];
+		if (message?.role === "assistant") return message;
+	}
+}
+function discardedAttempt(message) {
+	return {
+		assistantTimestamp: message.timestamp,
+		provider: message.provider,
+		model: message.model,
+		toolCallIds: message.content.flatMap((block) => block.type === "toolCall" ? [block.id] : [])
+	};
+}
+function isRecoverableLengthForModel(message, model) {
+	return message.provider === model.provider && message.model === model.id && isRecoverableLength(message, model.maxTokens ?? 0);
+}
+function withRecoveredMessages(current, recovered) {
+	return [...current.filter((message) => message.role === "system"), ...recovered.filter((message) => message.role !== "system")];
+}
+function createContextErrorStream(model, errorMessage) {
+	const stream = createAssistantMessageEventStream();
+	const error = {
+		role: "assistant",
+		content: [],
+		api: model.api,
+		provider: model.provider,
+		model: model.id,
+		usage: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			totalTokens: 0,
+			cost: {
+				input: 0,
+				output: 0,
+				cacheRead: 0,
+				cacheWrite: 0,
+				total: 0
+			}
+		},
+		stopReason: "error",
 		errorMessage,
-		messageCount: messages.length
-	}, "Provider rejected the context window; compacting and retrying the same turn");
-	params.onEvent?.({
-		type: "compaction",
-		status: "started"
+		timestamp: Date.now()
+	};
+	stream.push({
+		type: "error",
+		reason: "error",
+		error
 	});
+	stream.end(error);
+	return stream;
+}
+async function recoverRunContext(params) {
+	let started = false;
 	const summaryModel = params.policy.model ? (await import("../../providers/index.js")).resolveModel(params.policy.model) : params.model;
-	const recovered = await recoverContext({
-		conversationId: params.conversationId,
-		transcript: params.transcriptRuntime,
-		policy: params.policy,
-		budget: {
-			contextWindow: params.model.contextWindow ?? 128e3,
-			systemPrompt: params.systemPrompt,
-			tools: params.agent.state.tools,
-			reserveTokens: params.policy.reserveTokens,
-			triggerThreshold: params.policy.triggerThreshold,
-			minToolResultKeepChars: params.policy.minToolResultKeepChars
-		},
-		summaryModel,
-		fallbackModels: summaryModel === params.model ? [] : [params.model],
-		signal: params.abortSignal,
-		providerRejected: true,
-		preserveLastUser: true
-	}).catch((error) => {
-		params.onEvent?.({
+	try {
+		const recovered = await recoverContext({
+			conversationId: params.conversationId,
+			transcript: params.transcriptRuntime,
+			policy: params.policy,
+			budget: {
+				contextWindow: params.model.contextWindow ?? 128e3,
+				systemPrompt: params.systemPrompt,
+				tools: params.agent.state.tools,
+				reserveTokens: params.policy.reserveTokens,
+				triggerThreshold: params.policy.triggerThreshold,
+				minToolResultKeepChars: params.policy.minToolResultKeepChars
+			},
+			summaryModel,
+			fallbackModels: summaryModel === params.model ? [] : [params.model],
+			signal: params.abortSignal,
+			providerRejected: params.providerRejected,
+			forceOnTrigger: true,
+			preserveLastUser: params.providerRejected,
+			discardedAttempt: params.discardedAttempt,
+			onCompactionStart: () => {
+				if (started) return;
+				started = true;
+				params.onEvent?.({
+					type: "compaction",
+					status: "started"
+				});
+			}
+		});
+		if (recovered.status === "compacted") params.onEvent?.({
+			type: "compaction",
+			status: "completed",
+			tokensBefore: recovered.result?.tokensBefore,
+			tokensAfter: recovered.result?.tokensAfter,
+			summary: recovered.result?.summary.slice(0, 200)
+		});
+		else if (started) params.onEvent?.({
+			type: "compaction",
+			status: "skipped"
+		});
+		return recovered;
+	} catch (error) {
+		if (started) params.onEvent?.({
 			type: "compaction",
 			status: "skipped"
 		});
 		throw error;
+	}
+}
+async function maybeRecoverInterruptedContext(params) {
+	const assistant = lastAssistantMessage(params.agent.state.messages);
+	const errorMessage = getAssistantTurnErrorMessage(params.agent);
+	const overflow = !!errorMessage && isContextOverflowError(errorMessage);
+	const recoverableLength = !!assistant && isRecoverableLengthForModel(assistant, params.model);
+	if (!overflow && !recoverableLength) return false;
+	if (recoverableLength && (!params.policy.enabled || params.recoveryState.interruptedAttempts >= 1)) {
+		log.warn({
+			conversationId: params.conversationId,
+			attempts: params.recoveryState.interruptedAttempts
+		}, "Truncated response recovery is unavailable or already exhausted");
+		return false;
+	}
+	if (recoverableLength) params.recoveryState.interruptedAttempts += 1;
+	const messages = stripTrailingErrorAssistantMessages(params.agent.state.messages);
+	log.warn({
+		conversationId: params.conversationId,
+		errorMessage,
+		messageCount: messages.length,
+		reason: recoverableLength ? "length" : "context_overflow"
+	}, recoverableLength ? "Assistant response was truncated; compacting and retrying the same turn once" : "Provider rejected the context window; compacting and retrying the same turn");
+	const recovered = await recoverRunContext({
+		...params,
+		providerRejected: true,
+		discardedAttempt: recoverableLength && assistant ? discardedAttempt(assistant) : void 0
 	});
 	params.agent.state.messages = stripTrailingErrorAssistantMessages(recovered.messages);
+	params.onContextRecovered?.();
 	params.abortSignal?.throwIfAborted();
-	params.onEvent?.({
-		type: "compaction",
-		status: "completed",
-		tokensBefore: recovered.result?.tokensBefore,
-		tokensAfter: recovered.result?.tokensAfter,
-		summary: recovered.result?.summary.slice(0, 200)
-	});
 	await params.agent.continue();
 	await params.agent.waitForIdle();
 	return true;
@@ -154,6 +242,8 @@ async function runXopcEmbeddedTurn(params) {
 	let unsubscribe;
 	let quarantineRunner = false;
 	let runLease;
+	let restorePrepareNextTurn;
+	let restorePrepareRequest;
 	try {
 		runLease = acquireEmbeddedRunLease({
 			conversationId,
@@ -185,6 +275,83 @@ async function runXopcEmbeddedTurn(params) {
 		}
 		session.agent.state.messages = stripTrailingErrorAssistantMessages(await transcriptRuntime.loadMessages());
 		runner.piSm.setActiveTurnId?.(runId);
+		const recoveryState = { interruptedAttempts: 0 };
+		let useAuthoritativeProjection = false;
+		const basePrepareNextTurn = session.agent.prepareNextTurnWithContext;
+		const inTurnPrepareNextTurn = async (turn, signal) => {
+			const prepared = await basePrepareNextTurn?.(turn, signal);
+			const currentContext = prepared?.context ?? turn.context;
+			const recoverableLength = isRecoverableLengthForModel(turn.message, resolvedModel);
+			if (recoverableLength && (!compactionPolicy.enabled || recoveryState.interruptedAttempts >= 1)) return prepared;
+			if (recoverableLength) recoveryState.interruptedAttempts += 1;
+			try {
+				const recovered = await recoverRunContext({
+					agent: session.agent,
+					model: resolvedModel,
+					conversationId,
+					transcriptRuntime,
+					policy: compactionPolicy,
+					systemPrompt: [systemPrompt, rootInstructions].filter(Boolean).join("\n\n"),
+					abortSignal: signal ?? runAbortSignal,
+					onEvent,
+					providerRejected: recoverableLength,
+					discardedAttempt: recoverableLength ? discardedAttempt(turn.message) : void 0
+				});
+				useAuthoritativeProjection ||= recovered.status === "compacted";
+				return {
+					...prepared,
+					context: {
+						...currentContext,
+						messages: withRecoveredMessages(currentContext.messages, recovered.messages)
+					}
+				};
+			} catch (error) {
+				if (signal?.aborted || runAbortSignal.aborted) throw error;
+				log.error({
+					err: error,
+					conversationId,
+					runId,
+					phase: "prepare_next_turn"
+				}, "In-turn context recovery failed; the next request will use the guarded provider path");
+				return prepared;
+			}
+		};
+		session.agent.prepareNextTurnWithContext = inTurnPrepareNextTurn;
+		restorePrepareNextTurn = () => {
+			if (session.agent.prepareNextTurnWithContext === inTurnPrepareNextTurn) session.agent.prepareNextTurnWithContext = basePrepareNextTurn;
+		};
+		const basePrepareRequest = session.agent.prepareRequest;
+		const authoritativePrepareRequest = async (request, signal) => {
+			const prepared = await basePrepareRequest?.(request, signal);
+			const currentContext = prepared?.context ?? request.context;
+			if (!useAuthoritativeProjection) return {
+				...prepared,
+				context: currentContext
+			};
+			try {
+				const messages = await transcriptRuntime.loadMessages();
+				return {
+					...prepared,
+					context: {
+						...currentContext,
+						messages: withRecoveredMessages(currentContext.messages, messages)
+					}
+				};
+			} catch (error) {
+				if (signal?.aborted || runAbortSignal.aborted) throw error;
+				log.error({
+					err: error,
+					conversationId,
+					runId,
+					phase: "prepare_request"
+				}, "Failed to refresh the authoritative compacted projection");
+				return prepared;
+			}
+		};
+		session.agent.prepareRequest = authoritativePrepareRequest;
+		restorePrepareRequest = () => {
+			if (session.agent.prepareRequest === authoritativePrepareRequest) session.agent.prepareRequest = basePrepareRequest;
+		};
 		const streamFnWithXopcExtensions = wrapStreamFnForXopcExtensions(session.agent.streamFunction, params.promptCachePolicy);
 		const loggingStreamFn = (streamModel, context, options) => {
 			instructions.acknowledge();
@@ -239,7 +406,17 @@ async function runXopcEmbeddedTurn(params) {
 				reserveTokens: compactionPolicy.reserveTokens,
 				minToolResultKeepChars: compactionPolicy.minToolResultKeepChars
 			}, compactionPolicy.maxActiveTranscriptBytes);
-			if (!assessed.fits) throw new ContextRecoveryError("unrecoverable", `Context budget exceeded before provider request (${assessed.evaluation.estimatedTokens}/${assessed.evaluation.hardLimitTokens} tokens)`);
+			if (!assessed.fits) {
+				const errorMessage = `Context budget exceeded before provider request (${assessed.evaluation.estimatedTokens}/${assessed.evaluation.hardLimitTokens} tokens)`;
+				log.error({
+					conversationId,
+					runId,
+					phase: "provider_preflight",
+					estimatedTokens: assessed.evaluation.estimatedTokens,
+					hardLimitTokens: assessed.evaluation.hardLimitTokens
+				}, errorMessage);
+				return createContextErrorStream(streamModel, errorMessage);
+			}
 			effectiveContext = {
 				...effectiveContext,
 				messages: assessed.messages
@@ -350,6 +527,13 @@ async function runXopcEmbeddedTurn(params) {
 		session.agent.finishTurn = async (context, signal) => {
 			const baseDecision = await baseFinishTurn?.(context, signal);
 			if (baseDecision && baseDecision.action === "end") return { action: "end" };
+			if (context.message && isRecoverableLengthForModel(context.message, resolvedModel) && recoveryState.interruptedAttempts >= 1) {
+				log.warn({
+					conversationId,
+					runId
+				}, "Stopping after the bounded truncated-response recovery attempt");
+				return { action: "end" };
+			}
 			policyStopped ||= params.turnPolicy?.shouldStopAfterTurn(context) ?? false;
 			if (policyStopped || connectionStopped || clarificationStopped) return { action: "end" };
 			if (baseDecision && baseDecision.action === "continue") return { action: "continue" };
@@ -397,7 +581,7 @@ async function runXopcEmbeddedTurn(params) {
 					log,
 					signal: runAbortSignal
 				});
-				await maybeRecoverContextOverflow({
+				await maybeRecoverInterruptedContext({
 					agent: session.agent,
 					model: resolvedModel,
 					conversationId,
@@ -405,7 +589,11 @@ async function runXopcEmbeddedTurn(params) {
 					policy: compactionPolicy,
 					systemPrompt: [systemPrompt, rootInstructions].filter(Boolean).join("\n\n"),
 					abortSignal: runAbortSignal,
-					onEvent
+					onEvent,
+					recoveryState,
+					onContextRecovered: () => {
+						useAuthoritativeProjection = true;
+					}
 				});
 				const pending = await verification.pendingContext();
 				if ((params.verifyChanges ?? false) && pending && !policyStopped && !runAbortSignal.aborted && !isAssistantTurnFailed(session.agent) && !isAssistantTurnAborted(session.agent)) {
@@ -456,6 +644,10 @@ async function runXopcEmbeddedTurn(params) {
 			};
 		} finally {
 			session.agent.finishTurn = baseFinishTurn;
+			restorePrepareNextTurn();
+			restorePrepareNextTurn = void 0;
+			restorePrepareRequest();
+			restorePrepareRequest = void 0;
 			runAbortSignal.removeEventListener("abort", abortListener);
 		}
 	} catch (err) {
@@ -494,6 +686,8 @@ async function runXopcEmbeddedTurn(params) {
 			errorMessage: em
 		};
 	} finally {
+		restorePrepareNextTurn?.();
+		restorePrepareRequest?.();
 		runLease?.release();
 		unsubscribe?.();
 		try {

package/dist/src/agent/memory/compaction-ledger.d.ts

@@ -1,6 +1,9 @@
 import { type CompactionHandover } from '../../session/compaction-types.js';
 import type { TranscriptSourceEntry } from '../../storage/sqlite/transcript-repository.js';
 export type { CompactionAudit, CompactionHandover, CompactionHandoverItem, HandoverItemKind, } from '../../session/compaction-types.js';
+export declare const MAX_HANDOVER_ITEMS = 120;
+/** Normalize legacy or model-produced ledgers into the bounded durable form. */
+export declare function consolidateCompactionHandover(handover: CompactionHandover): CompactionHandover;
 /** Apply a bounded model-produced delta to the trusted local handover. */
 export declare function applyCompactionHandoverDelta(params: {
     text: string;

package/dist/src/agent/memory/compaction-ledger.js

@@ -4,6 +4,32 @@ import { z } from "zod";
 //#region src/agent/memory/compaction-ledger.ts
 init_compaction_types();
 const MAX_HANDOVER_ITEMS = 120;
+const MAX_HANDOVER_DELTA_ITEMS = 480;
+const MAX_SOURCE_REFS_PER_ITEM = 12;
+const COMPLETED_KIND_BUDGET = {
+	objective: 4,
+	decision: 24,
+	pending_user_ask: 2,
+	todo: 4,
+	constraint: 4,
+	file_change: 28,
+	tool_outcome: 24,
+	failure: 8,
+	current_state: 12,
+	next_action: 4
+};
+const ACTIVE_KIND_PRIORITY = {
+	pending_user_ask: 10,
+	objective: 9,
+	constraint: 8,
+	decision: 7,
+	failure: 6,
+	todo: 5,
+	next_action: 4,
+	current_state: 3,
+	file_change: 2,
+	tool_outcome: 1
+};
 const RawHandoverUpsertSchema = z.object({
 	id: z.string().min(1).max(64).optional(),
 	kind: z.enum(HANDOVER_ITEM_KINDS),
@@ -16,7 +42,7 @@ const RawHandoverUpsertSchema = z.object({
 	sourceSeqs: z.array(z.number().int().positive()).min(1),
 	identifiers: z.array(z.string().max(256)).max(20).default([])
 }).strict();
-const RawHandoverDeltaSchema = z.object({ upserts: z.array(RawHandoverUpsertSchema).max(MAX_HANDOVER_ITEMS) }).strict();
+const RawHandoverDeltaSchema = z.object({ upserts: z.array(RawHandoverUpsertSchema).max(MAX_HANDOVER_DELTA_ITEMS) }).strict();
 function extractJsonObject(text) {
 	const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/i)?.[1]?.trim();
 	if (fenced) return fenced;
@@ -25,8 +51,86 @@ function extractJsonObject(text) {
 	if (start < 0 || end <= start) throw new Error("Compaction model did not return a JSON object");
 	return text.slice(start, end + 1);
 }
-function itemId(kind, text, seqs) {
-	return createHash("sha256").update(`${kind}\0${text.trim()}\0${[...seqs].sort((a, b) => a - b).join(",")}`).digest("hex").slice(0, 20);
+function normalizeSemanticText(text) {
+	return text.normalize("NFKC").replace(/\s+/g, " ").trim().replace(/[.!?。！？]+$/u, "");
+}
+function normalizeIdentifiers(identifiers) {
+	return [...new Set(identifiers.map((value) => value.normalize("NFKC").trim()).filter(Boolean))].sort((left, right) => left.localeCompare(right));
+}
+function semanticKey(item) {
+	return `${item.kind}\0${normalizeSemanticText(item.text)}\0${normalizeIdentifiers(item.identifiers).join("\0")}`;
+}
+function itemId(kind, text, identifiers) {
+	return createHash("sha256").update(`${kind}\0${normalizeSemanticText(text)}\0${normalizeIdentifiers(identifiers).join("\0")}`).digest("hex").slice(0, 20);
+}
+function newestSourceSeq(item) {
+	return item.sources.reduce((latest, source) => Math.max(latest, source.seq), 0);
+}
+function mergeSources(previous, incoming) {
+	const bySeq = new Map(previous.map((source) => [source.seq, source]));
+	for (const source of incoming) bySeq.set(source.seq, source);
+	const sorted = [...bySeq.values()].sort((left, right) => left.seq - right.seq);
+	if (sorted.length <= MAX_SOURCE_REFS_PER_ITEM) return sorted;
+	return [sorted[0], ...sorted.slice(-(MAX_SOURCE_REFS_PER_ITEM - 1))];
+}
+function mergeSemanticDuplicate(previous, incoming) {
+	return {
+		...newestSourceSeq(incoming) >= newestSourceSeq(previous) ? incoming : previous,
+		id: previous.id,
+		sources: mergeSources(previous.sources, incoming.sources),
+		identifiers: normalizeIdentifiers([...previous.identifiers, ...incoming.identifiers]).slice(0, 20)
+	};
+}
+function compareRetentionPriority(left, right) {
+	const status = Number(right.status === "active") - Number(left.status === "active");
+	if (status !== 0) return status;
+	const kind = ACTIVE_KIND_PRIORITY[right.kind] - ACTIVE_KIND_PRIORITY[left.kind];
+	if (kind !== 0) return kind;
+	const recency = newestSourceSeq(right) - newestSourceSeq(left);
+	if (recency !== 0) return recency;
+	return left.id.localeCompare(right.id);
+}
+function consolidateItems(items) {
+	const bySemanticKey = /* @__PURE__ */ new Map();
+	const keyOrder = [];
+	for (const item of items) {
+		if (item.status === "superseded") continue;
+		const key = semanticKey(item);
+		const existing = bySemanticKey.get(key);
+		if (existing) bySemanticKey.set(key, mergeSemanticDuplicate(existing, item));
+		else {
+			keyOrder.push(key);
+			bySemanticKey.set(key, {
+				...item,
+				sources: mergeSources([], item.sources),
+				identifiers: normalizeIdentifiers(item.identifiers).slice(0, 20)
+			});
+		}
+	}
+	const deduplicated = keyOrder.map((key) => bySemanticKey.get(key));
+	const completedByKind = /* @__PURE__ */ new Map();
+	for (const item of deduplicated) {
+		if (item.status !== "completed") continue;
+		const group = completedByKind.get(item.kind) ?? [];
+		group.push(item);
+		completedByKind.set(item.kind, group);
+	}
+	const allowedCompleted = /* @__PURE__ */ new Set();
+	for (const [kind, group] of completedByKind) {
+		group.sort((left, right) => newestSourceSeq(right) - newestSourceSeq(left) || left.id.localeCompare(right.id));
+		for (const item of group.slice(0, COMPLETED_KIND_BUDGET[kind])) allowedCompleted.add(item.id);
+	}
+	const perKindBounded = deduplicated.filter((item) => item.status === "active" || allowedCompleted.has(item.id));
+	if (perKindBounded.length <= 120) return perKindBounded;
+	const retainedIds = new Set([...perKindBounded].sort(compareRetentionPriority).slice(0, 120).map((item) => item.id));
+	return perKindBounded.filter((item) => retainedIds.has(item.id));
+}
+/** Normalize legacy or model-produced ledgers into the bounded durable form. */
+function consolidateCompactionHandover(handover) {
+	return {
+		...handover,
+		items: consolidateItems(handover.items)
+	};
 }
 /** Apply a bounded model-produced delta to the trusted local handover. */
 function applyCompactionHandoverDelta(params) {
@@ -37,36 +141,32 @@ function applyCompactionHandoverDelta(params) {
 	}]));
 	for (const item of params.current?.items ?? []) for (const source of item.sources) sourceBySeq.set(source.seq, source);
 	const items = new Map((params.current?.items ?? []).map((item) => [item.id, item]));
-	const seenIds = /* @__PURE__ */ new Set();
 	for (const item of parsed.upserts) {
-		const seqs = [...new Set(item.sourceSeqs)].sort((a, b) => a - b);
-		const sources = seqs.map((seq) => {
+		const sources = [...new Set(item.sourceSeqs)].sort((a, b) => a - b).map((seq) => {
 			const source = sourceBySeq.get(seq);
 			if (!source || seq > params.sourceThroughSeq) throw new Error(`Compaction handover references unavailable source seq ${seq}`);
 			return source;
 		});
 		const text = item.text.trim();
-		const id = item.id ?? itemId(item.kind, text, seqs);
+		const identifiers = normalizeIdentifiers(item.identifiers);
+		const id = item.id ?? itemId(item.kind, text, identifiers);
 		if (item.id && !items.has(item.id)) throw new Error(`Compaction handover updates unknown item ${item.id}`);
-		if (seenIds.has(id)) throw new Error(`Compaction handover repeats item ${id}`);
-		seenIds.add(id);
+		const previousItem = items.get(id);
 		items.set(id, {
 			id,
 			kind: item.kind,
 			text,
 			status: item.status,
-			sources,
-			identifiers: [...new Set(item.identifiers.map((value) => value.trim()).filter(Boolean))]
+			sources: mergeSources(previousItem?.sources ?? [], sources),
+			identifiers: normalizeIdentifiers([...previousItem?.identifiers ?? [], ...identifiers]).slice(0, 20)
 		});
 	}
-	const retained = [...items.values()].filter((item) => item.status !== "superseded");
-	if (retained.length > MAX_HANDOVER_ITEMS) throw new Error(`Compaction handover exceeds ${MAX_HANDOVER_ITEMS} durable items`);
-	return {
+	return consolidateCompactionHandover({
 		version: 1,
 		sourceThroughSeq: params.sourceThroughSeq,
 		...params.previousBoundaryId ? { previousBoundaryId: params.previousBoundaryId } : {},
-		items: retained
-	};
+		items: [...items.values()]
+	});
 }
 const SUMMARY_GROUPS = [
 	{
@@ -115,14 +215,17 @@ function renderCompactionHandover(handover) {
 	return sections.join("\n\n");
 }
 function handoverForPrompt(handover) {
-	return { items: handover?.items.map((item) => ({
-		id: item.id,
-		kind: item.kind,
-		text: item.text,
-		status: item.status,
-		sourceSeqs: item.sources.map((source) => source.seq),
-		identifiers: item.identifiers
-	})) ?? [] };
+	return {
+		maxItems: 120,
+		items: (handover ? consolidateCompactionHandover(handover) : void 0)?.items.map((item) => ({
+			id: item.id,
+			kind: item.kind,
+			text: item.text,
+			status: item.status,
+			sourceSeqs: item.sources.map((source) => source.seq),
+			identifiers: item.identifiers
+		})) ?? []
+	};
 }
 //#endregion
-export { applyCompactionHandoverDelta, handoverForPrompt, renderCompactionHandover };
+export { MAX_HANDOVER_ITEMS, applyCompactionHandoverDelta, consolidateCompactionHandover, handoverForPrompt, renderCompactionHandover };

package/dist/src/agent/memory/compaction.d.ts

@@ -47,6 +47,18 @@ export interface CompactionExecutionOptions {
     fallbackModels?: Array<Model<Api>>;
     signal?: AbortSignal;
     checkpoint?: CompactionCheckpointStore;
+    /**
+     * Persist the failed attempt for audit, but replace it with a safe marker
+     * while building the handover. This prevents a truncated response and
+     * its synthetic tool results from becoming model-visible again later.
+     */
+    discardedAttempt?: CompactionDiscardedAttempt;
+}
+export interface CompactionDiscardedAttempt {
+    assistantTimestamp: number;
+    provider?: string;
+    model?: string;
+    toolCallIds?: string[];
 }
 export interface CompactionCheckpoint {
     version: 1;