@iowarp/clio-coder 0.4.4 → 0.4.5

package/src/domains/session/compaction/compact.ts

@@ -12,10 +12,21 @@
 
 import { streamSimple } from "../../../engine/ai.js";
 import type { EngineModel, Usage } from "../../../engine/types.js";
+import type { WorkingSetView } from "../../context/working-set/contract.js";
 import { foldWorkingSet } from "../../context/working-set/fold.js";
+import { projectWorkingSet } from "../../context/working-set/project.js";
 import { recallableRefListing } from "../../context/working-set/recall.js";
-import { extractReasoningTokens } from "../context-accounting.js";
-import type { CompactionUsage, SessionEntry } from "../entries.js";
+import { estimateAgentContextTokens, extractReasoningTokens } from "../context-accounting.js";
+import {
+	type CompactionUsage,
+	latestSkillContextState,
+	type PreservedUserContext,
+	type SessionEntry,
+	type SkillContextCheckpoint,
+	type SkillContextState,
+	skillContextContentHash,
+	verifiedSkillContextCheckpoint,
+} from "../entries.js";
 import { serializeConversation } from "./branch-summary.js";
 import { findCutPoint } from "./cut-point.js";
 import { DEFAULT_KEEP_RECENT_TOKENS, DEFAULT_RESERVE_TOKENS } from "./defaults.js";
@@ -87,6 +98,43 @@ In addition to that carried-forward context, summarize ONLY the active-turn deta
 
 Do NOT answer the user. Do NOT summarize unrelated older history.`;
 
+/** Validate the history checkpoint, never the intentionally different split-turn prompt. */
+function validateHistorySummary(text: string): void {
+	const required = [
+		"## Goal",
+		"## Constraints & Preferences",
+		"## Progress",
+		"### Done",
+		"### In Progress",
+		"### Blocked",
+		"## Key Decisions",
+		"## Next Steps",
+		"## Critical Context",
+	];
+	const headings: string[] = [];
+	let fence: { character: string; length: number } | undefined;
+	for (const line of text.split(/\r?\n/)) {
+		const fenceMatch = /^ {0,3}(`{3,}|~{3,})(.*)$/.exec(line);
+		if (fenceMatch) {
+			const marker = fenceMatch[1] ?? "";
+			if (!fence) fence = { character: marker[0] ?? "", length: marker.length };
+			else if (marker[0] === fence.character && marker.length >= fence.length && !fenceMatch[2]?.trim()) fence = undefined;
+			continue;
+		}
+		if (fence) continue;
+		const heading = /^ {0,3}(#{2,3})[ \t]+(.+?)(?:[ \t]+#+)?[ \t]*$/.exec(line);
+		if (heading) {
+			const normalized = `${heading[1]} ${heading[2]}`;
+			if (required.includes(normalized)) headings.push(normalized);
+		}
+	}
+	if (fence || headings.length !== required.length || headings.some((heading, index) => heading !== required[index])) {
+		throw new Error(
+			"compaction returned an incomplete history checkpoint: required headings must appear in order outside code fences; checkpoint was not saved",
+		);
+	}
+}
+
 /** One invoked summary stream, including failed calls that produce no checkpoint. */
 export interface CompactionCallObservation {
 	outcome: "success" | "error" | "aborted";
@@ -96,8 +144,17 @@ export interface CompactionCallObservation {
 }
 
 export interface CompactInput {
-	/** Ordered session entries to compact. The caller reads these from the session domain. */
+	/** Ordered active-path session entries to compact; returned cut indexes address this same array. */
 	entries: ReadonlyArray<SessionEntry>;
+	/** Authoritative main-agent selection; omitted for unknown legacy state. */
+	skillContextState?: SkillContextState | null;
+	/** Pure source-test seam. Production uses the existing summary stream. */
+	summarize?: (request: {
+		systemPrompt: string;
+		userText: string;
+		maxTokens: number;
+	}) => Promise<{ text: string; usage?: unknown }>;
+
 	/** Resolved orchestrator or compaction-override model. */
 	model: EngineModel;
 	/** API key for the model. Optional because local engines accept a fallback handled upstream. */
@@ -114,11 +171,15 @@ export interface CompactInput {
 	reserveTokens?: number;
 	/** Override the built-in keep-recent default (DEFAULT_KEEP_RECENT_TOKENS). */
 	keepRecentTokens?: number;
+	/** Carry this user message verbatim if removed; defaults to the latest operator turn for manual compaction. */
+	preserveUserTurnId?: string;
 	/** Accounting observer; called once per invoked stream, including failures. */
 	onCall?: (call: CompactionCallObservation) => void;
 }
 
 export interface CompactResult {
+	skillContext?: SkillContextCheckpoint;
+	userContext?: PreservedUserContext;
 	/** Generated summary text. Empty when there was nothing to summarize. */
 	summary: string;
 	/**
@@ -191,6 +252,157 @@ function findTurnStartForProtection(
 	return -1;
 }
 
+/** Recover only complete, uniquely paired historical main-agent loads. Never consult current disk. */
+export function captureSkillContext(
+	entries: ReadonlyArray<SessionEntry>,
+	selection: SkillContextState | undefined,
+): SkillContextCheckpoint | undefined {
+	if (!selection || selection.unknown) return undefined;
+	const newestSelected = Math.max(
+		-1,
+		...selection.activationRefs.map((ref) => entries.findIndex((entry) => entry.turnId === ref)),
+	);
+	if (
+		selection.activationRefs.length > 0 &&
+		entries
+			.slice(newestSelected + 1)
+			.some((entry) => entry.kind === "skillActivation" && entry.activation.runId === undefined)
+	)
+		return undefined;
+	const skills: SkillContextCheckpoint["skills"] = [];
+	for (const ref of selection.activationRefs) {
+		const matches = entries.filter((entry) => entry.turnId === ref);
+		const entry = matches[0];
+		if (matches.length !== 1 || entry?.kind !== "skillActivation") return undefined;
+		const activation = entry.activation;
+		if (
+			activation.runId !== undefined ||
+			activation.triggeredBy !== "tool" ||
+			!activation.turnId ||
+			activation.drift === "mismatch"
+		)
+			return undefined;
+		// A later load with the same name supersedes this receipt, even if the later evidence is incomplete.
+		if (
+			entries
+				.slice(entries.indexOf(entry) + 1)
+				.some(
+					(later) =>
+						later.kind === "skillActivation" &&
+						later.activation.runId === undefined &&
+						later.activation.name === activation.name,
+				)
+		)
+			return undefined;
+		const request = entries.find((candidate) => candidate.turnId === activation.turnId);
+		if (request?.kind !== "message" || request.role !== "user") return undefined;
+		const start = entries.indexOf(request);
+		const next = entries.findIndex(
+			(candidate, index) => index > start && candidate.kind === "message" && candidate.role === "user",
+		);
+		const turn = entries.slice(start, next < 0 ? undefined : next);
+		if (!turn.includes(entry)) return undefined;
+		const calls = turn.filter((candidate) => {
+			if (candidate.kind !== "message" || candidate.role !== "tool_call") return false;
+			const payload = payloadObject(candidate.payload);
+			const args = payloadObject(payload?.args);
+			return payload?.name === "context" && args?.scope === "skills" && args.name === activation.name;
+		});
+		if (calls.length !== 1) return undefined;
+		const call = calls[0];
+		if (call?.kind !== "message") return undefined;
+		const callId = payloadObject(call.payload)?.toolCallId;
+		if (typeof callId !== "string" || !callId) return undefined;
+		const assistant = turn.find((candidate) => candidate.turnId === call.parentTurnId);
+		if (
+			assistant?.kind !== "message" ||
+			assistant.role !== "assistant" ||
+			!contentBlocks(assistant.payload).some(
+				(block) =>
+					block.type === "toolCall" &&
+					block.id === callId &&
+					block.name === "context" &&
+					JSON.stringify(block.arguments) === JSON.stringify(payloadObject(call.payload)?.args),
+			)
+		)
+			return undefined;
+		const results = entries.filter(
+			(candidate) =>
+				candidate.kind === "message" &&
+				candidate.role === "tool_result" &&
+				payloadObject(candidate.payload)?.toolCallId === callId,
+		);
+		const resultEntry = results[0];
+		if (
+			results.length !== 1 ||
+			resultEntry?.kind !== "message" ||
+			!turn.includes(resultEntry) ||
+			resultEntry.parentTurnId !== call.turnId ||
+			entry.parentTurnId !== request.turnId
+		)
+			return undefined;
+		const payload = payloadObject(resultEntry.payload);
+		const result = payloadObject(payload?.result);
+		const details = payloadObject(result?.details);
+		const observation = payloadObject(details?.observation);
+		const resultSummary = payloadObject(payload?.resultSummary);
+		const summaryObservation = payloadObject(resultSummary?.observation);
+		const sourceInfo = payloadObject(details?.sourceInfo);
+		if (
+			payload?.toolName !== "context" ||
+			payload.isError !== false ||
+			payload.outcome !== "ok" ||
+			details?.kind !== "ok" ||
+			observation?.truncated !== false ||
+			details.workingSet !== undefined ||
+			details.contextCompaction !== undefined ||
+			resultSummary?.truncated !== false ||
+			summaryObservation?.truncated === true ||
+			details.name !== activation.name ||
+			details.path !== activation.filePath ||
+			details.hash !== activation.hash ||
+			details.source !== activation.source ||
+			details.sourceOrigin !== activation.sourceOrigin ||
+			sourceInfo?.path !== activation.filePath ||
+			sourceInfo.scope !== details.scope ||
+			sourceInfo.source !== activation.sourceOrigin ||
+			(details.drift !== undefined && details.drift !== "match") ||
+			details.drift !== activation.drift ||
+			!Array.isArray(result?.content) ||
+			!result.content.every((block: unknown) => {
+				const obj = payloadObject(block);
+				return obj?.type === "text" && typeof obj.text === "string";
+			})
+		)
+			return undefined;
+		const content = result.content as Array<{ type: "text"; text: string }>;
+		const text = content.map((block) => block.text).join("\n");
+		if (
+			observation.shownBytes !== Buffer.byteLength(text, "utf8") ||
+			observation.totalBytes !== observation.shownBytes ||
+			resultSummary?.bytes !== observation.shownBytes
+		)
+			return undefined;
+		const requestPayload = payloadObject(request.payload);
+		const operatorText = requestPayload?.operatorText;
+		const requestText =
+			typeof operatorText === "string" && operatorText.trim().length > 0 ? operatorText : requestPayload?.text;
+		if (typeof requestText !== "string") return undefined;
+		skills.push({
+			activationRef: ref,
+			requestRef: request.turnId,
+			callRef: call.turnId,
+			resultRef: resultEntry.turnId,
+			activation: structuredClone(activation),
+			requestText,
+			content: structuredClone(content),
+			contentHash: skillContextContentHash(content),
+		});
+	}
+	const checkpoint = { version: 1 as const, skills };
+	return verifiedSkillContextCheckpoint(checkpoint) ? checkpoint : undefined;
+}
+
 function buildPreviousContextPrefix(previousContextText: string): string {
 	const trimmed = previousContextText.trim();
 	return trimmed.length > 0 ? `<previous-context>\n${trimmed}\n</previous-context>\n\n` : "";
@@ -320,20 +532,30 @@ function formatFileOperations(fileOps: FileOperations): string {
 	return sections.length > 0 ? `\n\n${sections.join("\n\n")}` : "";
 }
 
-function formatRecallableRefs(entries: ReadonlyArray<SessionEntry>, firstKeptEntryIndex: number): string {
+function formatRecallableRefs(
+	entries: ReadonlyArray<SessionEntry>,
+	firstKeptEntryIndex: number,
+	view: WorkingSetView,
+): string {
 	const entryIndexes = new Map<string, number>();
 	for (let index = 0; index < entries.length; index += 1) {
 		const entry = entries[index];
 		if (entry) entryIndexes.set(entry.turnId, index);
 	}
-	const view = foldWorkingSet(entries);
 	const evictedBeforeCut = new Map(
 		[...view.evicted].filter(([ref]) => (entryIndexes.get(ref) ?? Number.POSITIVE_INFINITY) < firstKeptEntryIndex),
 	);
 	const listing = recallableRefListing(entries, { ...view, evicted: evictedBeforeCut });
-	if (listing.refs.length === 0) return "";
+	if (
+		listing.refs.length === 0 &&
+		!entries.slice(0, firstKeptEntryIndex).some((entry) => entry.kind === "message" && entry.role === "tool_result")
+	)
+		return "";
 	const rows = [...listing.refs];
 	if (listing.remaining > 0) rows.push(`and ${listing.remaining} more`);
+	rows.push(
+		'Preview only. Persisted original tool results removed by this summary are also recallable. Discover all active-path results with context(scope="recall", limit=8, offset=0), omitting ref; query filters path/tool/ref terms. Follow nextOffset, then recall the selected ref.',
+	);
 	return `\n\n<recallable-refs>\n${rows.join("\n")}\n</recallable-refs>`;
 }
 
@@ -411,13 +633,36 @@ async function runSummaryStream(
 		systemPrompt,
 		messages: [buildUserMessage(userText)],
 	};
+	// Price the complete serialized request, including templates, previous
+	// context, custom instructions and message overhead. This is the shared
+	// estimate, not provider-exact tokenization; never truncate constraints to
+	// make an oversized projected conversation fit.
+	const estimatedInput = estimateAgentContextTokens(context);
+	const contextWindow = input.model.contextWindow;
+	if (!Number.isFinite(contextWindow) || contextWindow <= 0) {
+		throw new Error("compaction requires a positive finite model context window");
+	}
+	if (estimatedInput + maxTokens > contextWindow) {
+		throw new Error(
+			`compaction estimated input ${estimatedInput} tokens plus output ${maxTokens} tokens exceeds model context window ${contextWindow}; use a larger compaction model or reduce the working set`,
+		);
+	}
 
+	input.signal?.throwIfAborted();
 	const timestamp = new Date().toISOString();
 	const started = performance.now();
 	let usage: unknown;
 	let reported: Record<string, unknown> = {};
 	let outcome: CompactionCallObservation["outcome"] = "error";
 	try {
+		if (input.summarize) {
+			const response = await input.summarize({ systemPrompt, userText, maxTokens });
+			usage = response.usage;
+			reported = retainReportedUsage(reported, usage);
+			input.signal?.throwIfAborted();
+			outcome = "success";
+			return { text: response.text.trim(), usage };
+		}
 		// Summarization requests thinking off, as its resolver does. Bare stream
 		// infers an active level from model.reasoning and would undo that choice.
 		const events = streamSimple(
@@ -434,6 +679,11 @@ async function runSummaryStream(
 			}
 			if (event.type === "done") {
 				usage = event.message.usage ?? usage;
+				reported = retainReportedUsage(reported, usage);
+				input.signal?.throwIfAborted();
+				if (event.reason === "length" || event.message.stopReason === "length") {
+					throw new Error("compaction summary reached the model output limit; incomplete checkpoint was not saved");
+				}
 				outcome = "success";
 				return { text: textFromAssistant(event.message).trim(), usage };
 			}
@@ -465,6 +715,12 @@ async function runSummaryStream(
 export async function compact(input: CompactInput): Promise<CompactResult> {
 	const reserveTokens = input.reserveTokens ?? DEFAULT_RESERVE_TOKENS;
 	const keepRecentTokens = input.keepRecentTokens ?? DEFAULT_KEEP_RECENT_TOKENS;
+	// Apply the same ledger decisions as live replay before pricing or
+	// serializing any slice, including the prior checkpoint's retained suffix.
+	// Projection preserves positions and turn IDs; cuts still address the raw
+	// input, which remains untouched and available for exact recall.
+	const workingSet = foldWorkingSet(input.entries);
+	const entries = projectWorkingSet(input.entries, workingSet);
 	// Iterative compaction: when a prior `compactionSummary` exists, the
 	// summary is canonical history. Restrict the cut search and the new-history
 	// slice to entries strictly after that boundary; the canonical summary and
@@ -472,29 +728,89 @@ export async function compact(input: CompactInput): Promise<CompactResult> {
 	// than rediscovering already-compacted raw history. Mirrors pi-coding-agent's
 	// `boundaryStart = prevCompactionIndex + 1` and `usageStart = prevCompactionIndex`
 	// in compaction.ts:619-628.
-	const prevCompactionIndex = findLatestCompactionIndex(input.entries);
+	const prevCompactionIndex = findLatestCompactionIndex(entries);
 	const boundaryStart = prevCompactionIndex + 1;
-	const protectedStart = findLatestSkillActivationProtectionStart(input.entries, boundaryStart);
+	const selection =
+		input.skillContextState === null ? undefined : (input.skillContextState ?? latestSkillContextState(input.entries));
+	let skillContext = captureSkillContext(input.entries, selection);
+	const priorCheckpoint = entries[prevCompactionIndex];
+	// An explicit-off checkpoint carries an empty skill list: nothing was
+	// retained, so nothing needs re-verification and later unknown state must
+	// not block compaction forever.
+	const priorSkillContext =
+		priorCheckpoint?.kind === "compactionSummary" &&
+		priorCheckpoint.skillContext !== undefined &&
+		priorCheckpoint.skillContext.skills.length > 0
+			? priorCheckpoint.skillContext
+			: undefined;
+	// A typed checkpoint is not regenerated from summary prose. Failure to verify
+	// its original receipts prevents another destructive pass.
+	if (priorSkillContext !== undefined && !skillContext) {
+		throw new Error("cannot verify preserved skill context; retaining the existing checkpoint");
+	}
+	if (priorSkillContext !== undefined) {
+		if (!verifiedSkillContextCheckpoint(priorSkillContext)) throw new Error("invalid preserved skill checkpoint");
+		for (const previous of priorSkillContext.skills) {
+			const current = skillContext?.skills.find((skill) => skill.activationRef === previous.activationRef);
+			if (current && JSON.stringify(current) !== JSON.stringify(previous)) {
+				throw new Error("preserved skill context no longer matches its captured receipt");
+			}
+		}
+	}
+	if (skillContext && priorSkillContext !== undefined) {
+		skillContext = {
+			version: 1,
+			skills: skillContext.skills.map((skill) =>
+				structuredClone(
+					priorSkillContext.skills.find((previous) => previous.activationRef === skill.activationRef) ?? skill,
+				),
+			),
+		};
+	}
+	// A legacy checkpoint (no typed field) never adjudicated older activations,
+	// so the fallback clamp stays fail-closed across its boundary. A typed
+	// checkpoint already retained or explicitly dropped everything before it.
+	const legacyPriorCheckpoint =
+		priorCheckpoint?.kind === "compactionSummary" && priorCheckpoint.skillContext === undefined;
+	const protectedStart = skillContext
+		? null
+		: findLatestSkillActivationProtectionStart(entries, legacyPriorCheckpoint ? 0 : boundaryStart);
 	const usageStart = prevCompactionIndex >= 0 ? prevCompactionIndex : 0;
-	const usageEntries = input.entries.slice(usageStart);
+	const usageEntries = entries.slice(usageStart);
 	const lastUsage = getLastAssistantUsage(usageEntries);
 	const tokensBefore = calculateContextTokens(usageEntries, lastUsage);
-	const rawCut = findCutPoint(input.entries, keepRecentTokens, { startIndex: boundaryStart });
+	const rawCut = findCutPoint(entries, keepRecentTokens, { startIndex: boundaryStart });
 	const cut =
 		protectedStart !== null && rawCut.firstKeptEntryIndex > protectedStart
 			? { firstKeptEntryIndex: protectedStart, turnStartIndex: -1, isSplitTurn: false }
 			: rawCut;
 	const historyEnd = cut.isSplitTurn ? cut.turnStartIndex : cut.firstKeptEntryIndex;
-	const pre = input.entries.slice(boundaryStart, Math.max(boundaryStart, historyEnd));
+	const pre = entries.slice(boundaryStart, Math.max(boundaryStart, historyEnd));
 	const turnPrefix = cut.isSplitTurn
-		? input.entries.slice(Math.max(boundaryStart, cut.turnStartIndex), cut.firstKeptEntryIndex)
+		? entries.slice(Math.max(boundaryStart, cut.turnStartIndex), cut.firstKeptEntryIndex)
 		: [];
-	const previousContextEntries = priorCompactionContextEntries(input.entries, prevCompactionIndex);
+	const previousContextEntries = priorCompactionContextEntries(entries, prevCompactionIndex);
 	const previousContextText = serializeConversation(previousContextEntries);
-	const fileOps = extractFileOps([...previousContextEntries, ...pre, ...turnPrefix]);
+	const fileOps = extractFileOps([
+		...priorCompactionContextEntries(input.entries, prevCompactionIndex),
+		...input.entries.slice(boundaryStart, cut.firstKeptEntryIndex),
+	]);
 	const firstKept = input.entries[cut.firstKeptEntryIndex] ?? null;
-
-	if (pre.length === 0 && turnPrefix.length === 0) {
+	// The newest complete exchange can begin immediately after the checkpoint.
+	// Its earlier retained suffix is still live context, even though it sits
+	// before boundaryStart in the append-only ledger. Summarize that suffix
+	// with the canonical prior summary instead of declaring nothing to compact.
+	// Never use this path to cross a protected cut or to re-summarize a bare
+	// checkpoint with no retained work; the caller still enforces request fit.
+	const priorSuffix = previousContextEntries.slice(1);
+	const summarizePriorSuffix =
+		pre.length === 0 &&
+		turnPrefix.length === 0 &&
+		firstKept !== null &&
+		cut.firstKeptEntryIndex >= boundaryStart &&
+		priorSuffix.some((entry) => entry.kind === "message" || entry.kind === "bashExecution");
+
+	if (pre.length === 0 && turnPrefix.length === 0 && !summarizePriorSuffix) {
 		return {
 			summary: "",
 			firstKeptEntryIndex: cut.firstKeptEntryIndex,
@@ -506,15 +822,25 @@ export async function compact(input: CompactInput): Promise<CompactResult> {
 	}
 
 	const systemPrompt = input.systemPrompt ?? COMPACTION_SYSTEM_PROMPT;
-	const maxTokens = Math.max(1024, Math.floor(reserveTokens * 0.8));
+	if (!Number.isFinite(reserveTokens) || reserveTokens <= 0) {
+		throw new Error("compaction requires a positive finite reserve token budget");
+	}
+	if (!Number.isFinite(input.model.maxTokens) || input.model.maxTokens < 1) {
+		throw new Error("compaction requires a positive finite model output token limit");
+	}
+	const maxTokens = Math.min(Math.floor(input.model.maxTokens), Math.max(1024, Math.floor(reserveTokens * 0.8)));
 	const summaryParts: string[] = [];
 	let usage: CompactionUsage | undefined;
-	if (pre.length > 0) {
-		const conversationText = serializeConversation(pre);
-		const userText = buildUserText(conversationText, input.instructions, previousContextText);
+	if (pre.length > 0 || summarizePriorSuffix) {
+		const conversationText = serializeConversation(summarizePriorSuffix ? priorSuffix : pre);
+		const previousText = summarizePriorSuffix
+			? serializeConversation(previousContextEntries.slice(0, 1))
+			: previousContextText;
+		const userText = buildUserText(conversationText, input.instructions, previousText);
 		const historySummary = await runSummaryStream(input, userText, systemPrompt, maxTokens);
 		usage = addCompactionUsage(usage, historySummary.usage);
 		if (historySummary.text.length === 0) throw new Error("compaction returned an empty history summary");
+		validateHistorySummary(historySummary.text);
 		summaryParts.push(historySummary.text);
 	}
 	if (turnPrefix.length > 0) {
@@ -526,9 +852,44 @@ export async function compact(input: CompactInput): Promise<CompactResult> {
 		summaryParts.push(`**Turn Context (split turn):**\n\n${prefixSummary.text}`);
 	}
 
+	// A generated split summary is not a reliable copy of the active request.
+	// Keep it in the canonical checkpoint so live replay and resume agree.
+	let userContext: PreservedUserContext | undefined =
+		priorCheckpoint?.kind === "compactionSummary" ? priorCheckpoint.userContext : undefined;
+	// Manual compaction has no live active-turn hint after a turn settles.
+	// Preserve the latest operator request if the split removes it as well.
+	let activeUserIndex = -1;
+	for (let index = entries.length - 1; index >= 0; index--) {
+		const entry = entries[index];
+		if (
+			entry?.kind === "message" &&
+			entry.role === "user" &&
+			(input.preserveUserTurnId === undefined || entry.turnId === input.preserveUserTurnId)
+		) {
+			activeUserIndex = index;
+			break;
+		}
+	}
+	const activeUser =
+		activeUserIndex >= 0 && activeUserIndex < cut.firstKeptEntryIndex ? entries[activeUserIndex] : undefined;
+	if (activeUser?.kind === "message" && activeUser.payload && typeof activeUser.payload === "object") {
+		const payload = activeUser.payload;
+		// Composed text can contain transient reminders. Reassert only the
+		// operator's canonical words when present, without normalizing them.
+		const operatorText = "operatorText" in payload ? payload.operatorText : undefined;
+		const text =
+			typeof operatorText === "string" && operatorText.trim().length > 0
+				? operatorText
+				: "text" in payload && typeof payload.text === "string"
+					? payload.text
+					: null;
+		if (text !== null) userContext = { turnId: activeUser.turnId, text };
+	}
+
 	const summary = `${summaryParts.join("\n\n---\n\n").trim()}${formatFileOperations(fileOps)}${formatRecallableRefs(
 		input.entries,
 		cut.firstKeptEntryIndex,
+		workingSet,
 	)}`.trim();
 
 	return {
@@ -536,9 +897,11 @@ export async function compact(input: CompactInput): Promise<CompactResult> {
 		firstKeptEntryIndex: cut.firstKeptEntryIndex,
 		firstKeptTurnId: firstKept?.turnId ?? null,
 		tokensBefore,
-		messagesSummarized: pre.length + turnPrefix.length,
+		messagesSummarized: pre.length + turnPrefix.length + (summarizePriorSuffix ? priorSuffix.length : 0),
 		isSplitTurn: cut.isSplitTurn,
 		...(usage !== undefined ? { usage } : {}),
+		...(skillContext !== undefined ? { skillContext } : {}),
+		...(userContext !== undefined ? { userContext } : {}),
 	};
 }
 

package/src/domains/session/compaction/cut-point.ts

@@ -52,11 +52,11 @@ function findTurnStartIndex(entries: ReadonlyArray<SessionEntry>, entryIndex: nu
 	return -1;
 }
 
-/** Entries we can cut at. `tool_result` is the only role we must NOT cut at. */
+/** Entries we can cut at. Tool rows must stay with their assistant declaration. */
 function isValidCutPoint(entry: SessionEntry): boolean {
 	switch (entry.kind) {
 		case "message":
-			return entry.role !== "tool_result";
+			return entry.role !== "tool_result" && entry.role !== "tool_call";
 		case "bashExecution":
 		case "custom":
 		case "skillActivation":
@@ -88,6 +88,36 @@ function findValidCutPoints(entries: ReadonlyArray<SessionEntry>, startIndex: nu
 	return cuts;
 }
 
+/** Retain the assistant declaration and its entire tool batch when the tail alone exceeds the budget. */
+function findToolBatchStart(
+	entries: ReadonlyArray<SessionEntry>,
+	resultIndex: number,
+	startIndex: number,
+	endIndex: number,
+): number {
+	for (let index = resultIndex - 1; index >= startIndex; index--) {
+		const entry = entries[index];
+		if (entry?.kind !== "message") continue;
+		if (entry.role === "user") break;
+		if (entry.role !== "assistant") continue;
+		const payload = entry.payload as { content?: unknown } | null;
+		if (!Array.isArray(payload?.content)) break;
+		const callIds = new Set<string>();
+		for (const block of payload.content) {
+			if (block?.type === "toolCall" && typeof block.id === "string") callIds.add(block.id);
+		}
+		if (callIds.size === 0) break;
+		for (let tail = index + 1; tail < endIndex; tail++) {
+			const result = entries[tail];
+			if (result?.kind !== "message" || result.role !== "tool_result") continue;
+			const id = (result.payload as { toolCallId?: unknown } | null)?.toolCallId;
+			if (typeof id !== "string" || !callIds.has(id)) return -1;
+		}
+		return index;
+	}
+	return -1;
+}
+
 /**
  * Find the cut point that keeps at least `keepRecentTokens` tokens in the
  * retained suffix. Never cuts at a `tool_result`. When walking forward from
@@ -131,14 +161,21 @@ export function findCutPoint(
 					break;
 				}
 			}
+			// No newer cut exists inside a final tool-result batch. Snap back to
+			// its assistant, not the whole user turn or an individual call row.
+			// The suffix may exceed the target; the continuation guard still
+			// checks whether summarizing older work actually made the request fit.
+			if (cutIndex === -1 && entry.kind === "message" && (entry.role === "tool_result" || entry.role === "tool_call")) {
+				cutIndex = findToolBatchStart(entries, i, startIndex, endIndex);
+			}
 			break;
 		}
 	}
 
 	if (cutIndex === -1) {
-		// Walker never crossed keepRecentTokens, or crossed but found no valid
-		// cut at/after the stop index (all valid cuts precede the tool_result
-		// tail). Prefer the newest turn start so older turns still feed the
+		// Walker never crossed keepRecentTokens, or found neither a newer cut
+		// nor a verifiable assistant declaration for the final result batch.
+		// Prefer the newest turn start so older turns still feed the
 		// summary prompt. Absent any turn start, fall back to the oldest valid
 		// cut. That matches the pre-fix behavior, so pre stays empty and the
 		// orchestrator reports nothing to compact.

package/src/domains/session/compaction/tokens.ts

@@ -62,7 +62,15 @@ function estimateCustom(entry: CustomEntry): number {
 }
 
 function estimateSummary(entry: BranchSummaryEntry | CompactionSummaryEntry): number {
-	return ceilChars(entry.summary.length);
+	let tokens = ceilChars(entry.summary.length);
+	if (entry.kind !== "compactionSummary") return tokens;
+	if (entry.userContext) tokens += ceilChars(entry.userContext.text.length + 40) + 4;
+	for (const skill of entry.skillContext?.skills ?? []) {
+		tokens += ceilChars(skill.requestText.length + 40) + 4;
+		tokens += ceilChars(JSON.stringify(skill.activation).length + 32) + 4;
+		for (const block of skill.content) tokens += ceilChars(block.text.length) + 4;
+	}
+	return tokens;
 }
 
 /**