@markusylisiurunen/tau 0.3.79 → 0.3.80

package/dist/core/session/compaction.js

@@ -1,465 +1,97 @@
-import { Buffer } from "node:buffer";
 import { isSystemCompactionContinuation } from "../../protocol/system_message.js";
-import { buildCompactionUserMessage, formatHistoryForCompaction, truncateToolRecoveryResults, } from "../utils/compact.js";
+import { buildCompactionUserMessage } from "../utils/compact.js";
 import { extractAssistantText } from "../utils/messages.js";
-import { bytesToTokens, estimateMessageTokens } from "../utils/token.js";
-import { truncateForTokens } from "../utils/truncate.js";
-import { formatTauUserText, getSummaryCompactionMetadataFromMessage, hasAutoCompactionContinuationMetadata, hasToolRecoveryMetadata, stripTauUserMetadata, } from "../utils/user_metadata.js";
-const PRESERVED_USER_MESSAGE_MAX_TOKENS = 20_000;
-const RETAINED_TOOL_RESULT_MAX_TOKENS = 8_192;
-const PRESERVED_USER_MESSAGE_IDS_OPEN_TAG = "<preserved-user-message-ids>";
-const PRESERVED_USER_MESSAGE_IDS_CLOSE_TAG = "</preserved-user-message-ids>";
-export const COMPACTION_SUMMARIZATION_SYSTEM_PROMPT = "You are a context compaction assistant. Your output will replace the conversation history for another assistant. Do not continue the conversation. Do not answer any conversation questions. Only output a structured handoff summary followed by the required preserved user message id block.";
-const COMPACTION_SUMMARIZATION_PROMPT = `The messages above are a conversation to compact. Create an information-dense context checkpoint summary that will replace the full conversation history. Another assistant should be able to continue the session from this summary as if the original conversation were still available.
+import { estimateMessageTokens } from "../utils/token.js";
+import { formatTauUserText, getSummaryCompactionMetadataFromMessage, hasAutoCompactionContinuationMetadata, hasToolRecoveryMetadata, } from "../utils/user_metadata.js";
+import { AUTO_COMPACTION_ARCHIVE_DOCUMENTATION, } from "./auto_compaction_archive.js";
+const COMPACTION_SUMMARIZATION_PROMPT = `You are pausing your current work to compact your own conversation and free space in your context window. The conversation you can see now will be replaced with the compaction summary you write. After that, you will continue as the same agent in the same session, working on the same task, but without the full earlier conversation available.
 
-If a [System prompt] block is present, use it as context for interpreting the conversation. Do not summarize it as part of the conversation history.
+Write a compaction summary of the conversation: what the user asked for, what has been done and learned, and what remains to be done. It should also give you the handoff you will need to resume that work as smoothly as possible. Your next continuation should be able to understand what the user wants, where the work stands, and what to do next from the compaction summary alone. Think through what you would otherwise forget: important constraints, evidence, decisions and their rationale, unresolved questions, and unfinished work. Preserve what will let you continue without reconstructing the conversation, repeating completed work, or asking the user to explain it again. Recent messages may also remain, but treat them as additional detail rather than something your compaction summary depends on. Some overlap is expected.
 
-Use this structure as a strong default, not a rigid form. Preserve the same continuity-critical concerns, but reorganize, combine, omit, or add sections when another structure would produce a clearer handoff. Project-specific sections and concise prose are allowed. The <preserved-user-message-ids> block remains required and must appear exactly once at the end.
+Preserve continuity-critical information in compact form:
+- The current objective, still-relevant original requests, and user constraints, preferences, and corrections.
+- Confirmed progress, current work, blockers, and the next concrete actions.
+- Decisions and their useful rationale, including rejected approaches when they matter for continuation.
+- Evidence needed to resume: exact paths, identifiers, commands, important errors, and verification status.
+- Uncertainties, unverified assumptions, pending validation, and the difference between attempted work and confirmed outcomes.
+- For unfinished tool work, the request being pursued, results already received, and what remains to interpret or do. Do not repeat completed tool calls just because the earlier exchange is no longer visible.
 
-## Goal
-[What the user is currently trying to accomplish. If the goal changed, briefly note the shift.]
+Incorporate still-relevant information from any previous compaction summary. Remove information that is clearly obsolete or superseded. Collapse tangents and repetition unless they affect the work. When a detail may matter later, preserve it concisely rather than omitting it solely for brevity.
 
-## Constraints & Preferences
-- [Constraints, preferences, or requirements from the user]
-- [Use "(none)" when nothing explicit exists]
+Choose the structure that best supports your continuation. Goal, Constraints, Progress, Decisions, Next actions, and Critical context can be useful headings, but are not a required form. Record actionable conclusions and rationale, not a transcript of internal thinking. The base system instructions remain available separately; do not spend the compaction summary reproducing them.
 
-## Progress
-### Done
-- [x] [Completed tasks and confirmed outcomes]
+Do not include large verbatim chunks from user messages, pasted documents, or tool output. Summarize the relevant requirements and findings.
 
-### In Progress
-- [ ] [Current work in progress]
+Output only the compaction summary.
 
-### Blocked
-- [Open blockers, or "(none)"]
-
-## Key Decisions
-- **[Decision]**: [Brief rationale]
-
-## Next Steps
-1. [Ordered next action]
-
-## Critical Context
-- [Concrete details needed to resume: file paths, function names, commands, errors, test/build status, assumptions]
-
-<preserved-user-message-ids>
-[JSON array of history entry id strings for user messages to copy verbatim into the compaction summary. Use [] when no candidate should be copied verbatim.]
-</preserved-user-message-ids>
-
-Rules:
-- Preserve as much continuity-critical context as possible while removing tokens.
-- Optimize for continuing the work, not retrospectively describing the conversation.
-- The Goal section must preserve the user's current objective and any still-relevant original request, even if it appears early in the conversation.
-- Keep each section information-dense and focused; do not omit useful details solely for brevity.
-- When unsure whether a detail may matter later, preserve it in compact form.
-- Preserve the current state of the work: files touched, commands run, test/build status, known failures, unverified assumptions, and pending validation.
-- Distinguish attempted work from confirmed outcomes.
-- If goals evolved over time, capture the current goal and briefly note the change.
-- Collapse tangents, retries, and pleasantries unless they materially affect decisions, blockers, or next steps.
-- Select preserved user message ids only from <user-message-candidates>. The candidates with source "conversation" are identified inline in <conversation> by matching [User id="..."] markers. Select user messages whose exact wording is likely needed to continue, such as standing goals, constraints, corrections, explicit instructions, and recent actionable requests. Omit resolved, repetitive, superseded, or conversational messages. Keep the selected messages under roughly 20,000 tokens total.
-- Preserve exact file paths, function names, commands, and error messages.
-- Treat the suggested headings as a checklist, not a form to fill mechanically. Add project-specific sections, combine or omit empty subsections, and use prose or tables when they communicate the handoff more clearly.`;
-const COMPACTION_UPDATE_SUMMARIZATION_PROMPT = `The messages above are new conversation messages to incorporate into the existing summary in <previous-summary> tags. The updated summary will replace the prior summary plus these new messages as the session's continuity context.
-
-If a [System prompt] block is present, use it as context for interpreting the new conversation messages. Do not summarize it as part of the conversation history.
-
-Update the existing structured summary with these rules:
-- Preserve all still-relevant information from the previous summary.
-- Add new progress, decisions, and context from the new messages.
-- Move items from In Progress to Done when completed.
-- Update Next Steps based on the current state.
-- Remove only information that is clearly obsolete, superseded, or irrelevant to continuing the session.
-
-Use the previous summary's structure when it remains clear, but reorganize it when the conversation has changed enough that another structure would produce a better handoff. Preserve the same continuity-critical concerns. You may combine, omit, or add sections, use project-specific headings, and mix concise prose with lists. The <preserved-user-message-ids> block remains required and must appear exactly once at the end.
-
-## Goal
-[Preserve and extend goals as needed. If the goal shifted, reflect the latest goal and note the change briefly.]
-
-## Constraints & Preferences
-- [Preserve and extend constraints]
-
-## Progress
-### Done
-- [x] [Previously done and newly completed]
-
-### In Progress
-- [ ] [Current work]
-
-### Blocked
-- [Current blockers, or "(none)"]
-
-## Key Decisions
-- **[Decision]**: [Brief rationale]
-
-## Next Steps
-1. [Updated ordered actions]
-
-## Critical Context
-- [Concrete details needed to resume: file paths, function names, commands, errors, test/build status, assumptions]
-
-<preserved-user-message-ids>
-[JSON array of history entry id strings for user messages to copy verbatim into the compaction summary. Use [] when no candidate should be copied verbatim.]
-</preserved-user-message-ids>
-
-Rules:
-- Preserve as much continuity-critical context as possible while removing tokens.
-- Optimize for continuing the work, not retrospectively describing the conversation.
-- The Goal section must preserve the user's current objective and any still-relevant original request, even if it appears early in the conversation.
-- Keep each section information-dense and focused; do not omit useful details solely for brevity.
-- When unsure whether a detail may matter later, preserve it in compact form.
-- Preserve the current state of the work: files touched, commands run, test/build status, known failures, unverified assumptions, and pending validation.
-- Distinguish attempted work from confirmed outcomes.
-- If goals evolved over time, capture the current goal and briefly note the change.
-- Collapse tangents, retries, and pleasantries unless they materially affect decisions, blockers, or next steps.
-- Select preserved user message ids only from <user-message-candidates>. The candidates with source "conversation" are identified inline in <conversation> by matching [User id="..."] markers. Select user messages whose exact wording is likely needed to continue, such as standing goals, constraints, corrections, explicit instructions, and recent actionable requests. Omit resolved, repetitive, superseded, or conversational messages. Keep the selected messages under roughly 20,000 tokens total.
-- Preserve exact file paths, function names, commands, and error messages.
-- Treat the suggested headings as a checklist, not a form to fill mechanically. Add project-specific sections, combine or omit empty subsections, and use prose or tables when they communicate the handoff more clearly.`;
-export function prepareSessionCompaction(entries, options) {
-    const latestCompaction = findLatestCompactionEntry(entries);
-    const entriesToSummarize = entries
-        .slice(latestCompaction.index + 1)
-        .filter((entry) => !isCompactionContinuation(entry.message));
-    const messagesToSummarize = entriesToSummarize.map((entry) => entry.message);
-    const historyEntryIds = buildHistoryEntryIdMap(entriesToSummarize);
-    const formattedConversation = formatHistoryForCompaction(messagesToSummarize, {
-        historyEntryIds,
-    });
-    if (!formattedConversation) {
+Do not answer the latest request, perform more work, or call tools.`;
+export function prepareSessionCompaction(entries) {
+    const latestCompactionIndex = findLatestCompactionIndex(entries);
+    const activeEntries = entries.filter((entry) => !isCompactionContinuation(entry.message));
+    if (!entries
+        .slice(latestCompactionIndex + 1)
+        .some((entry) => !isCompactionContinuation(entry.message))) {
         return undefined;
     }
-    const formattedHistory = formatHistoryForCompaction(messagesToSummarize, {
-        systemPrompt: options.systemPrompt,
-        historyEntryIds,
-    });
     return {
-        previousSummary: latestCompaction.summary,
-        messagesToSummarize,
-        formattedHistory,
-        userMessageCandidates: collectUserMessageCandidates(entriesToSummarize, latestCompaction.preservedUserMessages),
+        messagesToSummarize: activeEntries.map((entry) => entry.message),
     };
 }
-export function buildSessionCompactionPrompt(args) {
-    const { preparation, guidance } = args;
-    let summaryPrompt = `<conversation>\n${preparation.formattedHistory}\n</conversation>\n\n`;
-    if (preparation.previousSummary?.trim()) {
-        summaryPrompt += `<previous-summary>\n${preparation.previousSummary.trim()}\n</previous-summary>\n\n`;
-    }
-    if (preparation.userMessageCandidates.length > 0) {
-        summaryPrompt += `<user-message-candidates>\n${formatUserMessageCandidates(preparation.userMessageCandidates)}\n</user-message-candidates>\n\n`;
-    }
-    summaryPrompt += preparation.previousSummary
-        ? COMPACTION_UPDATE_SUMMARIZATION_PROMPT
+export function buildSessionCompactionPrompt(args = {}) {
+    const guidance = args.guidance?.trim();
+    return guidance
+        ? `${COMPACTION_SUMMARIZATION_PROMPT}\n\nAdditional compaction summary focus: ${guidance}`
         : COMPACTION_SUMMARIZATION_PROMPT;
-    const guidanceBlock = guidance?.trim();
-    if (guidanceBlock) {
-        summaryPrompt += `\n\nAdditional focus: ${guidanceBlock}`;
-    }
-    return summaryPrompt;
 }
 export function buildSessionCompactionMessage(args) {
     const lastAssistantMessage = args.mode === "with-last-assistant"
         ? extractLastAssistantMessage(args.messagesToSummarize)
         : undefined;
-    const summary = buildCompactionSummary({
-        summary: args.summary,
-        preservedUserMessages: args.preservedUserMessages,
-    });
     return {
         compactionMessage: buildCompactionUserMessage({
-            summary,
+            summary: args.summary,
             lastAssistantMessage,
         }),
         includedLastAssistant: Boolean(lastAssistantMessage),
     };
 }
-export function buildCompactionSummary(args) {
-    const summary = args.summary.trim();
-    if (args.preservedUserMessages.length === 0) {
-        return summary;
-    }
-    const preserved = args.preservedUserMessages
-        .map((message) => `<user-message id="${escapeXmlAttribute(message.id)}">\n${message.text}\n</user-message>`)
-        .join("\n\n");
-    return `${summary}\n\n## Preserved User Messages\nUse these original user messages as verbatim continuity anchors. Treat them as preserved user intent selected from the compacted history by history entry id.\n\n<preserved-user-messages>\n${preserved}\n</preserved-user-messages>`;
-}
-export function parseCompactionSummaryResponse(args) {
-    const { summary, selectedIds } = extractSelectedUserMessageIds(args.response, {
-        requireSelectionBlock: args.userMessageCandidates.length > 0,
-    });
-    if (!summary) {
-        throw new Error("compaction summary response did not include a summary");
-    }
-    const candidatesById = new Map(args.userMessageCandidates.map((message) => [message.id, message]));
-    const seenIds = new Set();
-    const selectedCandidates = [];
-    for (const id of selectedIds) {
-        const candidate = candidatesById.get(id);
-        if (!candidate) {
-            continue;
-        }
-        if (seenIds.has(id)) {
-            throw new Error(`compaction summary selected duplicate preserved user message id '${id}'`);
-        }
-        seenIds.add(id);
-        selectedCandidates.push(candidate);
-    }
-    return {
-        summary,
-        preservedUserMessages: fitPreservedUserMessages(selectedCandidates),
-    };
-}
-function extractSelectedUserMessageIds(response, options) {
-    const text = response.trim();
-    const start = text.indexOf(PRESERVED_USER_MESSAGE_IDS_OPEN_TAG);
-    if (start < 0) {
-        if (options.requireSelectionBlock) {
-            throw new Error("compaction summary response did not include preserved user message ids");
-        }
-        return { summary: text, selectedIds: [] };
-    }
-    const contentStart = start + PRESERVED_USER_MESSAGE_IDS_OPEN_TAG.length;
-    const end = text.indexOf(PRESERVED_USER_MESSAGE_IDS_CLOSE_TAG, contentStart);
-    if (end < 0) {
-        throw new Error("compaction summary response did not close preserved user message ids");
-    }
-    if (text.indexOf(PRESERVED_USER_MESSAGE_IDS_OPEN_TAG, contentStart) >= 0) {
-        throw new Error("compaction summary response included multiple preserved user message id blocks");
-    }
-    const before = text.slice(0, start).trimEnd();
-    const after = text.slice(end + PRESERVED_USER_MESSAGE_IDS_CLOSE_TAG.length).trimStart();
-    const summary = [before, after].filter(Boolean).join("\n\n").trim();
-    let parsed;
-    try {
-        parsed = JSON.parse(text.slice(contentStart, end).trim());
-    }
-    catch (error) {
-        throw new Error(`invalid preserved user message id selection: ${error.message}`);
-    }
-    if (!Array.isArray(parsed) || parsed.some((id) => typeof id !== "string")) {
-        throw new Error("invalid preserved user message id selection: expected a JSON string array");
-    }
-    return { summary, selectedIds: parsed };
-}
-function fitPreservedUserMessages(candidates) {
-    const tokenCounts = candidates.map((candidate) => estimateTextTokens(candidate.text));
-    const totalTokens = tokenCounts.reduce((total, tokens) => total + tokens, 0);
-    if (totalTokens <= PRESERVED_USER_MESSAGE_MAX_TOKENS) {
-        return candidates.map((candidate) => ({ id: candidate.id, text: candidate.text }));
-    }
-    const targets = tokenCounts.map((tokens) => Math.max(1, Math.floor((tokens / totalTokens) * PRESERVED_USER_MESSAGE_MAX_TOKENS)));
-    let targetTotal = targets.reduce((total, tokens) => total + tokens, 0);
-    while (targetTotal > PRESERVED_USER_MESSAGE_MAX_TOKENS) {
-        let largestIndex = 0;
-        for (let index = 1; index < targets.length; index += 1) {
-            if (targets[index] > targets[largestIndex]) {
-                largestIndex = index;
-            }
-        }
-        if (targets[largestIndex] <= 1) {
-            break;
-        }
-        targets[largestIndex] = targets[largestIndex] - 1;
-        targetTotal -= 1;
-    }
-    return candidates.map((candidate, index) => {
-        const maxTokens = targets[index];
-        return {
-            id: candidate.id,
-            text: truncateForTokens(candidate.text, { maxTokens, strategy: "middle" }).content,
-        };
-    });
-}
-function buildHistoryEntryIdMap(entries) {
-    return new Map(entries.map((entry) => [entry.message, entry.id]));
-}
-function isAutoCompactionArchiveEntry(entry) {
-    const message = entry.message;
-    return !(message.role === "assistant" &&
-        (message.stopReason === "error" || message.stopReason === "aborted"));
-}
-function collectUserMessageCandidates(entries, previousMessages) {
-    const candidates = new Map();
-    for (const message of previousMessages) {
-        candidates.set(message.id, {
-            id: message.id,
-            text: message.text,
-            source: "previous-preserved",
-        });
-    }
-    for (const entry of entries) {
-        const text = extractPreservableUserText(entry.message);
-        if (!text) {
-            continue;
-        }
-        candidates.set(entry.id, { id: entry.id, text, source: "conversation" });
-    }
-    return [...candidates.values()];
-}
-function formatUserMessageCandidates(candidates) {
-    const records = candidates.map((message) => {
-        if (message.source === "conversation") {
-            return { id: message.id, source: message.source };
-        }
-        return { id: message.id, source: message.source, text: message.text };
-    });
-    return JSON.stringify(records, null, 2).replaceAll("<", "\\u003c");
-}
-function extractPreservableUserText(message) {
-    if (message.role !== "user") {
-        return undefined;
-    }
-    if (getSummaryCompactionMetadataFromMessage(message) ||
-        isCompactionContinuation(message) ||
-        hasToolRecoveryMetadata(message)) {
+export function prepareAutoCompaction(entries, settings) {
+    const preparation = prepareSessionCompaction(entries);
+    if (!preparation) {
         return undefined;
     }
-    const text = extractUserText(message);
-    return text.trim() ? text : undefined;
-}
-function extractUserText(message) {
-    if (typeof message.content === "string") {
-        return stripTauUserMetadata(message.content);
-    }
-    const parts = [];
-    for (const block of message.content) {
-        if (typeof block === "string") {
-            parts.push(block);
-        }
-        else if (block.type === "text") {
-            parts.push(block.text ?? "");
-        }
-    }
-    return stripTauUserMetadata(parts.join("\n"));
-}
-function escapeXmlAttribute(value) {
-    return value
-        .replaceAll("&", "&amp;")
-        .replaceAll('"', "&quot;")
-        .replaceAll("<", "&lt;")
-        .replaceAll(">", "&gt;");
-}
-function estimateTextTokens(text) {
-    return Math.max(1, bytesToTokens(Buffer.byteLength(text, "utf8")));
-}
-function boundRetainedEntry(entry) {
-    const message = structuredClone(entry.message);
-    if (message.role === "user" && hasToolRecoveryMetadata(message)) {
-        if (typeof message.content === "string") {
-            message.content = truncateToolRecoveryResults(message.content, RETAINED_TOOL_RESULT_MAX_TOKENS);
-        }
-        else {
-            for (const block of message.content) {
-                if (block.type === "text") {
-                    block.text = truncateToolRecoveryResults(block.text, RETAINED_TOOL_RESULT_MAX_TOKENS);
-                }
-            }
-        }
-        return { id: entry.id, message };
-    }
-    if (message.role !== "toolResult") {
-        return { id: entry.id, message };
-    }
-    const toolResult = message;
-    const text = toolResult.content
-        .filter((content) => content.type === "text")
-        .map((content) => content.text)
-        .join("\n");
-    const truncated = truncateForTokens(text, {
-        maxTokens: RETAINED_TOOL_RESULT_MAX_TOKENS,
-        strategy: "middle",
-    });
-    if (!truncated.truncated) {
-        return { id: entry.id, message };
-    }
-    const content = [];
-    let replacedText = false;
-    for (const block of toolResult.content) {
-        if (block.type !== "text") {
-            content.push(block);
-            continue;
-        }
-        if (!replacedText) {
-            content.push({ ...block, text: truncated.content });
-            replacedText = true;
-        }
-    }
-    return {
-        id: entry.id,
-        message: { ...toolResult, content },
-    };
-}
-export function prepareAutoCompaction(entries, settings) {
-    const latestCompaction = findLatestCompactionEntry(entries);
+    const latestCompactionIndex = findLatestCompactionIndex(entries);
     const cut = selectAutoCompactionCut(entries, {
-        startIndex: latestCompaction.index + 1,
+        startIndex: latestCompactionIndex + 1,
         keepRecentTokens: settings.keepRecentTokens,
     });
     if (!cut) {
         return undefined;
     }
-    const entriesToSummarize = entries
-        .slice(latestCompaction.index + 1, cut.startIndex)
-        .filter((entry) => !isCompactionContinuation(entry.message));
-    const messagesToSummarize = entriesToSummarize.map((entry) => entry.message);
-    const historyEntryIds = buildHistoryEntryIdMap(entriesToSummarize.filter(isAutoCompactionArchiveEntry));
-    const formattedConversation = formatHistoryForCompaction(messagesToSummarize, {
-        historyEntryIds,
-    });
-    if (!formattedConversation) {
-        return undefined;
-    }
-    const formattedHistory = formatHistoryForCompaction(messagesToSummarize, {
-        systemPrompt: settings.systemPrompt,
-        historyEntryIds,
-    });
-    const retainedEntries = entries
-        .slice(cut.startIndex)
-        .filter((entry) => !isCompactionContinuation(entry.message))
-        .map(boundRetainedEntry);
-    if (retainedEntries.length === 0) {
-        return undefined;
-    }
     return {
-        previousSummary: latestCompaction.summary,
-        retainedEntries,
+        ...preparation,
+        retainedEntries: entries
+            .slice(cut.startIndex)
+            .filter((entry) => !isCompactionContinuation(entry.message))
+            .map((entry) => structuredClone(entry)),
         cutType: cut.cutType,
-        formattedHistory,
-        userMessageCandidates: collectUserMessageCandidates(entriesToSummarize, latestCompaction.preservedUserMessages),
     };
 }
-const AUTO_COMPACTION_ARCHIVE_REFERENCE_GUIDANCE = `When best-effort archiving succeeds, the continuing assistant receives exact paths to a temporary text transcript and JSON snapshot of the pre-compaction context. Conversation records above that show an archive entry id can be recovered directly from the matching JSON file. When no entry id is available, the files also support discovery from distinctive evidence.
-
-Keep the summary independently useful. State continuity-critical goals, constraints, decisions, current state, blockers, and next steps directly. When exact or bulky details would be wasteful to reproduce, you may mention the relevant id as an auto-compaction archive entry id so the continuing assistant knows to use the supplied files, not the separate history tool. This is useful for long tool output, diagnostic logs, exact errors, payloads, and large code excerpts. Use such references sparingly and only for ids shown in the conversation.
-
-Good pattern: "The key failure is a missing RuntimeConfig field; the complete compiler output is in auto-compaction archive entry 'ARCHIVE_ENTRY_ID'."
-Bad pattern: "See archive entry 'ARCHIVE_ENTRY_ID' for what happened."`;
-export function buildAutoCompactionPrompt(preparation) {
-    const retainedContextGuidance = preparation.cutType === "split-turn"
-        ? `The retained context will begin in the middle of the latest assistant/tool turn. Add a "## Current Turn Handoff" section that clearly captures:
-- the original user request for this turn
-- work completed before the retained suffix
-- tool state and findings at the cut boundary
-- what the first retained message is continuing and what remains unresolved
-
-Place the section wherever it makes the handoff clearest. Preserve earlier session context elsewhere in the summary without duplicating the retained suffix.`
-        : "The retained context will include recent messages. Ensure the summary complements that retained context without duplicating unnecessary detail.";
-    const boundedRetainedContextGuidance = "Individual textual tool results and tool-recovery payloads in the retained context may be middle-truncated above the retention limit. Do not describe the retained context as exact or verbatim. When the pre-compaction archive is available, the continuing assistant can recover omitted output through a targeted lookup.";
+export function buildAutoCompactionPrompt() {
     return buildSessionCompactionPrompt({
-        preparation,
-        guidance: `${retainedContextGuidance}\n\n${boundedRetainedContextGuidance}\n\n${AUTO_COMPACTION_ARCHIVE_REFERENCE_GUIDANCE}`,
+        guidance: "After this compaction summary, some recent complete messages may remain, or there may be no retained messages. Do not rely on a particular retention boundary. After compaction, you will have access to a transcript archive of the conversation before this compaction: a readable .txt transcript, a structured .json snapshot, and an archive guide. The text transcript may truncate large tool results; the JSON snapshot retains full archived results but excludes assistant thinking. You can refer to this transcript archive for exact wording or bulky evidence instead of copying it into the summary. Include targeted instructions to revisit a relevant user message or other evidence when useful, explaining what to look for and why it matters. Use distinctive details such as the topic of a user request, a file path, a tool name, or an error. The continuation supplies the actual paths, so do not invent paths or entry IDs. Keep the essential context in the summary; the transcript archive is an additional way to recover details, not a substitute for a useful summary. This transcript archive is separate from the history tool's collection.",
     });
 }
+export const COMPACTION_CONTINUATION_GUIDANCE = `Your earlier conversation was compacted to keep this same session within the context limit, not to start a new task.
+The compaction summary supplies continuity. Any retained recent messages supply additional detail and may overlap with it. Compaction does not mean that work completed or that the user request changed.
+Resume from the compaction summary and any retained messages without repeating completed work. Recover missing evidence when it matters rather than guessing or asking the user to repeat information.`;
 export function buildAutoCompactionContinuationMessage(args) {
-    const lines = [
-        "The conversation context before this point has been compacted.",
-        "Earlier context is summarized in the compaction message above. Recent messages are retained after that summary, but large textual tool results and tool-recovery payloads may be middle-truncated.",
-        "Continue from the summary and retained context without asking the user to repeat information.",
-    ];
+    const lines = [COMPACTION_CONTINUATION_GUIDANCE];
     if (args.cutType === "split-turn") {
-        lines.push("The retained messages begin in the middle of the latest assistant/tool turn. The summary contains the original request and earlier tool work from that turn.");
+        lines.push("The retained suffix may begin partway through a user turn, or be empty. Use the compaction summary to understand earlier requests, prior tool work, and unfinished actions that are no longer visible.");
     }
     if (args.archive) {
-        lines.push("The summary and retained context should normally be sufficient. Temporary pre-compaction archive files are also available:", `- archive guide: ${args.archive.documentationPath}`, `- this compaction's text transcript: ${args.archive.textPath}`, `- this compaction's full JSON: ${args.archive.jsonPath}`, "Before continuing, ensure the archive guide's full contents are present in the current model context. If they are not already visible in full, read the guide now with an execution-environment file tool. This is required even when no archive lookup is currently planned.", "For details removed from this session by automatic compaction, use these execution-environment files rather than the separate history tool, whose collection may be stale, remotely replicated, truncated, or unavailable.", "The guide describes the archive format and adaptable, bounded lookup examples, including how to inspect earlier numbered pairs when needed.");
+        lines.push("The summary and retained context should normally be sufficient. The transcript archive from before this compaction is also available:", `- archive guide: ${args.archive.documentationPath}`, `- transcript archive (.txt): ${args.archive.textPath}`, `- transcript archive (.json): ${args.archive.jsonPath}`, "The archive guide is included below and remains available at the path above.", "For details removed from this session by automatic compaction, use this transcript archive rather than the separate history tool, whose collection may be stale, remotely replicated, truncated, or unavailable.", "The guide describes the archive format and adaptable, bounded lookup examples, including how to inspect earlier numbered pairs when needed.", "<transcript-archive-guide>", AUTO_COMPACTION_ARCHIVE_DOCUMENTATION, "</transcript-archive-guide>");
     }
     const hiddenSystemMessages = [...(args.systemMessages ?? []), lines.join("\n")];
     return {
@@ -481,109 +113,50 @@ export function selectAutoCompactionCut(entries, args) {
     if (entries.length === 0 || args.startIndex >= entries.length) {
         return undefined;
     }
-    const turnStarts = collectTurnStarts(entries, args.startIndex);
-    const latestTurnStart = turnStarts.at(-1) ?? findOngoingTurnStart(entries, args.startIndex);
-    if (latestTurnStart === undefined) {
-        return undefined;
-    }
-    const latestTurnTokens = estimateEntriesTokens(entries.slice(latestTurnStart));
-    if (latestTurnTokens <= args.keepRecentTokens) {
-        if (turnStarts.length === 0) {
-            return undefined;
+    let retainedTokens = 0;
+    let startIndex = entries.length;
+    for (let index = entries.length - 1; index >= args.startIndex; index -= 1) {
+        if (isCompactionContinuation(entries[index].message)) {
+            continue;
         }
-        let firstKeptTurn = latestTurnStart;
-        let totalTokens = latestTurnTokens;
-        for (let i = turnStarts.length - 2; i >= 0; i -= 1) {
-            const turnStart = turnStarts[i];
-            const nextTurnStart = turnStarts[i + 1];
-            const turnTokens = estimateEntriesTokens(entries.slice(turnStart, nextTurnStart));
-            if (totalTokens + turnTokens > args.keepRecentTokens) {
+        let groupStart = index;
+        if (entries[index].message.role === "toolResult") {
+            while (groupStart > args.startIndex) {
+                groupStart -= 1;
+                const message = entries[groupStart].message;
+                if (message.role === "assistant") {
+                    break;
+                }
+                if (message.role !== "toolResult" && !isCompactionContinuation(message)) {
+                    break;
+                }
+            }
+            if (entries[groupStart].message.role !== "assistant") {
                 break;
             }
-            firstKeptTurn = turnStart;
-            totalTokens += turnTokens;
         }
-        if (firstKeptTurn <= args.startIndex) {
-            return undefined;
+        const groupTokens = estimateEntriesTokens(entries.slice(groupStart, index + 1));
+        if (retainedTokens + groupTokens > args.keepRecentTokens) {
+            break;
         }
-        return { startIndex: firstKeptTurn, cutType: "turn-boundary" };
-    }
-    const splitStart = selectLatestTurnSplitStart(entries, {
-        turnStart: latestTurnStart,
-        keepRecentTokens: args.keepRecentTokens,
-    });
-    if (splitStart === undefined) {
-        return latestTurnStart > args.startIndex
-            ? { startIndex: latestTurnStart, cutType: "turn-boundary" }
-            : undefined;
+        retainedTokens += groupTokens;
+        startIndex = groupStart;
+        index = groupStart;
     }
-    if (splitStart <= args.startIndex) {
+    if (startIndex <= args.startIndex) {
         return undefined;
     }
-    return { startIndex: splitStart, cutType: "split-turn" };
+    const message = entries[startIndex]?.message;
+    const cutType = message?.role === "user" && !hasToolRecoveryMetadata(message) ? "turn-boundary" : "split-turn";
+    return { startIndex, cutType };
 }
-function findLatestCompactionEntry(entries) {
+function findLatestCompactionIndex(entries) {
     for (let index = entries.length - 1; index >= 0; index -= 1) {
-        const metadata = getSummaryCompactionMetadataFromMessage(entries[index].message);
-        if (metadata) {
-            const preservedUserMessages = metadata.preservedUserMessages.map((message) => ({
-                id: message.id,
-                text: message.text,
-            }));
-            return {
-                index,
-                summary: metadata.summary,
-                preservedUserMessages,
-            };
-        }
-    }
-    return { index: -1, preservedUserMessages: [] };
-}
-function collectTurnStarts(entries, startIndex) {
-    const starts = [];
-    for (let index = Math.max(0, startIndex); index < entries.length; index += 1) {
-        const message = entries[index].message;
-        if (message.role !== "user") {
-            continue;
-        }
-        if (getSummaryCompactionMetadataFromMessage(message) ||
-            isCompactionContinuation(message) ||
-            hasToolRecoveryMetadata(message)) {
-            continue;
-        }
-        starts.push(index);
-    }
-    return starts;
-}
-function findOngoingTurnStart(entries, startIndex) {
-    for (let index = Math.max(0, startIndex); index < entries.length; index += 1) {
-        if (!isCompactionContinuation(entries[index].message)) {
+        if (getSummaryCompactionMetadataFromMessage(entries[index].message)) {
             return index;
         }
     }
-    return undefined;
-}
-function selectLatestTurnSplitStart(entries, args) {
-    let retainedTokens = 0;
-    let latestAssistantBoundary;
-    let crossedBudget = false;
-    for (let index = entries.length - 1; index >= args.turnStart; index -= 1) {
-        const entry = entries[index];
-        if (isCompactionContinuation(entry.message)) {
-            continue;
-        }
-        retainedTokens += estimateMessageTokens(entry.message);
-        if (entry.message.role === "assistant") {
-            latestAssistantBoundary = index;
-        }
-        if (retainedTokens > args.keepRecentTokens) {
-            crossedBudget = true;
-        }
-        if (crossedBudget && latestAssistantBoundary !== undefined) {
-            return latestAssistantBoundary;
-        }
-    }
-    return latestAssistantBoundary;
+    return -1;
 }
 function estimateEntriesTokens(entries) {
     return entries.reduce((total, entry) => isCompactionContinuation(entry.message)