neoctl 0.2.30 → 0.2.32

package/dist/context/compaction.js

@@ -1,17 +1,18 @@
-import { createTextMessage } from "../types/messages.js";
+import { createTextMessage, withoutThinkingBlocks } from "../types/messages.js";
 import { estimateTextTokens } from "../core/context-metrics.js";
 import { buildImageRegistry, extractRegistryFromBoundary, mergeImageRegistries, formatImageRegistryForContext } from "../core/image-registry.js";
 import { resolveImageBlockDataLengthSync } from "../core/image-storage.js";
 export const CLEARED_TOOL_RESULT_CONTENT = "[Old tool result content cleared]";
+const COMPACT_USER_MESSAGE_MAX_TOKENS = 20_000;
 export class DeterministicCompactor {
     async compact(messages, options = {}) {
         const micro = microCompactIfNeeded(messages, options);
-        const auto = autoCompactIfNeeded(micro.messages, options);
-        const snipped = snipCompactIfNeeded(auto.messages, options);
-        if (snipped.changed)
-            return mergeResults([micro, auto, snipped], snipped.reason);
+        const auto = autoCompactIfNeeded(micro.messages, options, messages);
         if (auto.changed)
-            return mergeResults([micro, auto], auto.reason);
+            return auto;
+        const snipped = snipCompactIfNeeded(micro.messages, options);
+        if (snipped.changed)
+            return mergeResults([micro, snipped], snipped.reason);
         if (micro.changed)
             return micro;
         return { messages: [...messages], changed: false, reason: "none" };
@@ -24,87 +25,53 @@ export class DeterministicCompactor {
     }
     async reactiveCompact(messages, error, options = {}) {
         const micro = microCompactIfNeeded(messages, options);
-        const reactive = reactiveCompactWithSummary(micro.messages, `Reactive compact after model context error: ${error.message}`, options);
-        return micro.changed ? mergeResults([micro, reactive], reactive.reason) : reactive;
+        const reactive = reactiveCompactWithSummary(messages, micro.messages, `Reactive compact after model context error: ${error.message}`, options);
+        return reactive;
     }
 }
 export class ModelDrivenCompactor {
     modelGateway;
-    fallback = new DeterministicCompactor();
     constructor(modelGateway) {
         this.modelGateway = modelGateway;
     }
     async compact(messages, options = {}) {
-        const micro = microCompactIfNeeded(messages, options);
-        const auto = await this.modelAutoCompactIfNeeded(micro.messages, options);
-        const snipped = snipCompactIfNeeded(auto.messages, options);
-        if (snipped.changed)
-            return mergeResults([micro, auto, snipped], snipped.reason);
-        if (auto.changed)
-            return mergeResults([micro, auto], auto.reason);
-        if (micro.changed)
-            return micro;
-        return { messages: [...messages], changed: false, reason: "none" };
-    }
-    async manualCompact(messages, options = {}) {
-        const splitIndex = computeKeepRecentSplit(messages, options);
-        const recent = messages.slice(splitIndex);
-        const older = messages.slice(0, splitIndex);
-        if (older.length === 0)
+        if (!shouldCompactForBudget(messages, options, options.autoCompactMaxChars)) {
             return { messages: [...messages], changed: false, reason: "none" };
-        try {
-            const summary = await this.summarizeWithModel(older, MANUAL_COMPACT_INSTRUCTIONS, options);
-            return buildCompactionResult(messages, recent, summary, "manualcompact", true);
-        }
-        catch {
-            return this.fallback.manualCompact?.(messages, options) ?? manualCompactWithSummary(messages, options);
         }
+        return this.createCheckpoint(messages, "autocompact", options);
+    }
+    async manualCompact(messages, options = {}) {
+        return this.createCheckpoint(messages, "manualcompact", options);
     }
     async pureCompact(messages, options = {}) {
         return pureCompactWithSanitizedSummary(messages, options);
     }
-    async reactiveCompact(messages, error, options = {}) {
-        const micro = microCompactIfNeeded(messages, options);
-        const splitIndex = computeKeepRecentSplit(micro.messages, options);
-        const recent = micro.messages.slice(splitIndex);
-        const older = micro.messages.slice(0, splitIndex);
-        try {
-            const summary = await this.summarizeWithModel(older, buildReactiveCompactInstruction(error), options);
-            const reactive = buildCompactionResult(micro.messages, recent, summary, "reactive_compact", true);
-            return micro.changed ? mergeResults([micro, reactive], reactive.reason) : reactive;
-        }
-        catch {
-            const fallback = await this.fallback.reactiveCompact(micro.messages, error, options);
-            return micro.changed ? mergeResults([micro, fallback], fallback.reason) : fallback;
-        }
+    async reactiveCompact(messages, _error, options = {}) {
+        return this.createCheckpoint(messages, "reactive_compact", options);
     }
-    async modelAutoCompactIfNeeded(messages, options) {
-        if (!shouldCompactForBudget(messages, options, options.autoCompactMaxChars ?? 50000)) {
-            return { messages: [...messages], changed: false, reason: "none" };
-        }
-        const splitIndex = computeKeepRecentSplit(messages, options);
-        const recent = messages.slice(splitIndex);
-        const older = messages.slice(0, splitIndex);
-        if (older.length === 0)
-            return { messages: [...messages], changed: false, reason: "none" };
+    async createCheckpoint(messages, reason, options) {
+        if (messages.length === 0)
+            return { messages: [], changed: false, reason: "none" };
         try {
-            const summary = await this.summarizeWithModel(older, AUTO_COMPACT_INSTRUCTIONS, options);
-            return buildCompactionResult(messages, recent, summary, "autocompact", true);
+            const summary = await this.summarizeWithModel(messages, CHECKPOINT_COMPACT_INSTRUCTIONS, options);
+            return buildCompactionResult(messages, summary, reason, true, options);
         }
         catch {
-            return autoCompactIfNeeded(messages, options);
+            return checkpointCompactWithSummary(messages, options, reason);
         }
     }
     async summarizeWithModel(messages, instructions, options) {
-        const transcript = serializeTranscriptForSummary(messages, options.summaryMaxChars ?? 12000);
-        if (!transcript.trim())
+        const compactMessages = prepareMessagesForModelSummary(messages, instructions);
+        if (compactMessages.length === 1)
             return "No earlier conversation content required preservation.";
-        let text = "";
+        let streamedText = "";
+        let finalAssistantText = "";
+        let completed = false;
         for await (const event of this.modelGateway.stream({
             model: options.compactModel,
-            instructions,
-            messages: [createTextMessage("user", transcript)],
+            messages: compactMessages,
             tools: [],
+            toolChoice: "none",
             stream: true,
             maxOutputTokens: options.compactMaxOutputTokens ?? 2500,
             queryOrigin: "compact",
@@ -113,18 +80,22 @@ export class ModelDrivenCompactor {
             },
         })) {
             if (event.type === "assistant_delta")
-                text += event.text;
+                streamedText += event.text;
             if (event.type === "assistant_message")
-                text += extractText(event.message);
+                finalAssistantText = extractText(event.message).trim() || finalAssistantText;
+            if (event.type === "response_completed")
+                completed = true;
+            if (event.type === "response_incomplete")
+                throw new Error(`Model compaction response was incomplete: ${event.reason ?? "unknown reason"}`);
             if (event.type === "error")
                 throw event.error;
         }
-        const summary = text.trim();
+        if (!completed)
+            throw new Error("Model compaction stream ended before completion");
+        const summary = (finalAssistantText || streamedText).trim();
         if (!summary)
             throw new Error("Model compaction produced an empty summary");
-        return summary.length > (options.summaryMaxChars ?? 6000)
-            ? `${summary.slice(0, options.summaryMaxChars ?? 6000)}\n- ...model summary truncated...`
-            : summary;
+        return summary;
     }
 }
 export class NoopCompactor {
@@ -160,6 +131,40 @@ export class ManualOnlyCompactor {
         return { messages: [...messages], changed: false, reason: "none" };
     }
 }
+export function withCompactionReport(result, sourceMessages) {
+    if (!result.changed || result.report)
+        return result;
+    const reason = result.reason && result.reason !== "none" ? result.reason : "autocompact";
+    const boundary = findLastCompactBoundary(result.messages);
+    const boundaryText = boundary ? extractText(boundary) : "";
+    const continuationState = extractCompactState(boundaryText) || result.summary || "";
+    const imageRegistry = boundary?.metadata?.imageRegistry;
+    const report = {
+        reason,
+        summary: result.summary || continuationState,
+        continuationState,
+        sourceMessages: Math.max(0, Math.round(sourceMessages)),
+        preservedUserMessages: result.messages.filter((message) => message.metadata?.compactPreservedUser === true).length,
+        newWindowMessages: result.messages.length,
+        charsFreed: Math.max(0, result.charsFreed ?? result.tokensFreed ?? 0),
+        modelDriven: boundary?.metadata?.modelDriven === true,
+        imageCount: Array.isArray(imageRegistry?.images) ? imageRegistry.images.length : 0,
+    };
+    return {
+        ...result,
+        messages: result.messages.map((message) => message === boundary
+            ? { ...message, metadata: { ...message.metadata, compactionReport: report } }
+            : message),
+        report,
+    };
+}
+function findLastCompactBoundary(messages) {
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        if (messages[index].metadata?.compactBoundary === true)
+            return messages[index];
+    }
+    return undefined;
+}
 export function estimateMessagesChars(messages) {
     return messages.reduce((total, message) => total + serializeMessage(message).length, 0);
 }
@@ -234,20 +239,17 @@ export function microCompactIfNeeded(messages, options = {}) {
         tokensFreed: freed,
     };
 }
-export function autoCompactIfNeeded(messages, options = {}) {
+export function autoCompactIfNeeded(messages, options = {}, sourceMessages = messages) {
     const maxChars = options.autoCompactMaxChars ?? 50000;
     if (!shouldCompactForBudget(messages, options, maxChars))
         return { messages: [...messages], changed: false, reason: "none" };
-    const splitIndex = computeKeepRecentSplit(messages, options);
-    const recent = messages.slice(splitIndex);
-    const older = messages.slice(0, splitIndex);
-    if (older.length === 0)
-        return { messages: [...messages], changed: false, reason: "none" };
-    const summary = buildHistorySummary(older, options.summaryMaxChars ?? 5000);
-    return buildCompactionResult(messages, recent, summary, "autocompact", false);
+    if (sourceMessages.length === 0)
+        return { messages: [], changed: false, reason: "none" };
+    const summary = buildCheckpointFallbackSummary(sourceMessages, options.summaryMaxChars ?? 5000);
+    return buildCompactionResult(sourceMessages, summary || "No conversation content was available to summarize.", "autocompact", false, options, messages);
 }
 function computeKeepRecentSplit(messages, options, fallbackCount) {
-    const tokenBudget = options.keepRecentTokenBudget;
+    const tokenBudget = options.keepRecentTokenBudget ?? defaultRecentTokenBudget(options.contextWindowTokens);
     const keepCount = fallbackCount ?? options.keepRecentMessages ?? 8;
     if (!tokenBudget)
         return Math.max(0, messages.length - keepCount);
@@ -265,23 +267,20 @@ function shouldCompactForBudget(messages, options, fallbackMaxChars, triggerRati
         const triggerRatio = triggerRatioOverride ?? options.autoCompactTriggerRatio ?? 0.92;
         return options.estimatedInputTokens / options.contextWindowTokens >= triggerRatio;
     }
-    return estimateMessagesChars(messages) > fallbackMaxChars;
+    return fallbackMaxChars !== undefined && estimateMessagesChars(messages) > fallbackMaxChars;
 }
 function manualCompactWithSummary(messages, options) {
-    const splitIndex = computeKeepRecentSplit(messages, options);
-    const recent = messages.slice(splitIndex);
-    const older = messages.slice(0, splitIndex);
-    if (older.length === 0)
-        return { messages: [...messages], changed: false, reason: "none" };
-    const summary = buildHistorySummary(older, options.summaryMaxChars ?? 6000);
-    return buildCompactionResult(messages, recent, summary || "No older messages were available to summarize.", "manualcompact", false);
+    return checkpointCompactWithSummary(messages, options, "manualcompact");
+}
+function checkpointCompactWithSummary(messages, options, reason) {
+    if (messages.length === 0)
+        return { messages: [], changed: false, reason: "none" };
+    const summary = buildCheckpointFallbackSummary(messages, options.summaryMaxChars ?? 6000);
+    return buildCompactionResult(messages, summary || "No conversation content was available to summarize.", reason, false, options);
 }
-function reactiveCompactWithSummary(messages, heading, options) {
-    const splitIndex = computeKeepRecentSplit(messages, options);
-    const recent = messages.slice(splitIndex);
-    const older = messages.slice(0, splitIndex);
-    const summary = buildHistorySummary(older, options.summaryMaxChars ?? 6000);
-    return buildCompactionResult(messages, recent, `${heading}\n\n${summary || "No older messages were available to summarize."}`, "reactive_compact", false);
+function reactiveCompactWithSummary(sourceMessages, messagesForSelection, heading, options) {
+    const summary = buildCheckpointFallbackSummary(sourceMessages, options.summaryMaxChars ?? 6000);
+    return buildCompactionResult(sourceMessages, `${heading}\n\n${summary || "No conversation content was available to summarize."}`, "reactive_compact", false, options, messagesForSelection);
 }
 function pureCompactWithSanitizedSummary(messages, options) {
     if (messages.length === 0)
@@ -299,68 +298,111 @@ function pureCompactWithSanitizedSummary(messages, options) {
         tokensFreed: freed,
     };
 }
-function extractPersistentFacts(messages) {
-    const facts = [];
-    for (const message of messages) {
-        if (message.metadata?.compactBoundary) {
-            const text = extractText(message);
-            const existingFacts = text.match(/(?<=Persistent facts:\n)([\s\S]*?)(?=\n(?:Working context:|<\/compact_state>))/);
-            if (existingFacts) {
-                for (const line of existingFacts[1].split("\n")) {
-                    const trimmed = line.trim();
-                    if (trimmed && trimmed !== "- ...summary truncated...")
-                        facts.push(trimmed);
-                }
-            }
-            continue;
-        }
-        for (const block of message.blocks) {
-            if (block.type === "text") {
-                const text = block.text;
-                if (message.role === "user") {
-                    if (/\b(must|require|constraint|never|always|important|rule)\b/i.test(text)) {
-                        facts.push(`- User constraint: ${text.replace(/\s+/g, " ").trim().slice(0, 200)}`);
-                    }
-                }
-                if (/\b(error|fail|exception|bug)\b/i.test(text) && message.role !== "progress") {
-                    const errorLine = text.split("\n").find((l) => /error|fail|exception|bug/i.test(l));
-                    if (errorLine)
-                        facts.push(`- Error encountered: ${errorLine.trim().slice(0, 200)}`);
-                }
-                if (/\b(decide|chosen|approach|architecture|design|agreed)\b/i.test(text) && message.role === "assistant") {
-                    facts.push(`- Decision: ${text.replace(/\s+/g, " ").trim().slice(0, 200)}`);
-                }
-            }
-            if (block.type === "tool_result" && !block.ok) {
-                facts.push(`- Failed tool: ${block.name} (${serializeToolOutput(block.output).slice(0, 150)})`);
-            }
-        }
-    }
-    return dedupeLines(facts).slice(0, 30);
-}
-function buildCompactionResult(originalMessages, recentMessages, summary, reason, modelDriven) {
+function buildCompactionResult(originalMessages, summary, reason, modelDriven, options, messagesForSelection = originalMessages) {
     const label = reason === "autocompact"
         ? "Auto compacted earlier conversation."
         : reason === "manualcompact"
             ? "Manually compacted earlier conversation."
             : "Reactive compacted earlier conversation.";
-    const persistentFacts = extractPersistentFacts(originalMessages);
-    const layeredSummary = persistentFacts.length > 0
-        ? `Persistent facts:\n${persistentFacts.join("\n")}\n\nWorking context:\n${summary}`
-        : summary;
     const imageRegistry = buildMergedImageRegistry(originalMessages);
-    const boundary = createCompactionBoundaryMessage(`${label}\n\n${layeredSummary}`, reason, modelDriven, imageRegistry);
-    const compacted = [boundary, ...recentMessages];
+    const preservedUsers = selectRecentUserMessages(messagesForSelection, options.keepRecentTokenBudget ?? COMPACT_USER_MESSAGE_MAX_TOKENS);
+    const boundary = createCompactionBoundaryMessage(`${label}\n\n${summary}`, reason, modelDriven, imageRegistry);
+    const compacted = [...preservedUsers, boundary];
     const freed = Math.max(0, estimateMessagesChars(originalMessages) - estimateMessagesChars(compacted));
     return {
         messages: compacted,
-        summary: layeredSummary,
+        summary,
         changed: true,
         reason,
         charsFreed: freed,
         tokensFreed: freed,
     };
 }
+function selectRecentUserMessages(messages, tokenBudget) {
+    if (tokenBudget <= 0)
+        return [];
+    const users = messages.filter(isRealUserMessage);
+    const selected = [];
+    let remaining = tokenBudget;
+    for (let index = users.length - 1; index >= 0 && remaining > 0; index -= 1) {
+        const message = users[index];
+        const tokens = estimateMessageTokens(message);
+        if (tokens <= remaining) {
+            selected.push(markPreservedUserMessage(message));
+            remaining -= tokens;
+            continue;
+        }
+        const truncated = truncateUserMessageToTokenBudget(message, remaining);
+        if (truncated)
+            selected.push(markPreservedUserMessage(truncated));
+        break;
+    }
+    return selected.reverse();
+}
+function isRealUserMessage(message) {
+    return message.role === "user" && message.isMeta !== true && message.metadata?.compactBoundary !== true;
+}
+function estimateMessageTokens(message) {
+    return estimateTextTokens(serializeMessage(message));
+}
+function markPreservedUserMessage(message) {
+    return {
+        ...message,
+        blocks: message.blocks.map((block) => ({ ...block })),
+        metadata: { ...message.metadata, compactPreservedUser: true },
+    };
+}
+function truncateUserMessageToTokenBudget(message, maxTokens) {
+    if (maxTokens <= 0)
+        return undefined;
+    const marker = "[... user message truncated for compaction token budget ...]";
+    const textLength = message.blocks.reduce((total, block) => total + (block.type === "text" ? block.text.length : 0), 0);
+    if (textLength === 0)
+        return undefined;
+    let low = 0;
+    let high = textLength;
+    let best;
+    while (low <= high) {
+        const mid = Math.floor((low + high) / 2);
+        const blocks = truncateUserBlocks(message.blocks, mid, marker);
+        if (estimateTextTokens(blocks.map(serializeBlock).join("\n")) <= maxTokens) {
+            best = blocks;
+            low = mid + 1;
+        }
+        else {
+            high = mid - 1;
+        }
+    }
+    return best ? { ...message, blocks: best } : undefined;
+}
+function truncateUserBlocks(blocks, textChars, marker) {
+    const result = [];
+    let remaining = textChars;
+    let markerInserted = false;
+    for (const block of blocks) {
+        if (block.type !== "text") {
+            result.push({ ...block });
+            continue;
+        }
+        if (remaining <= 0)
+            continue;
+        const kept = block.text.slice(0, remaining);
+        remaining -= kept.length;
+        if (kept)
+            result.push({ type: "text", text: kept });
+    }
+    for (let index = result.length - 1; index >= 0; index -= 1) {
+        const block = result[index];
+        if (block.type !== "text")
+            continue;
+        result[index] = { type: "text", text: `${block.text.trimEnd()}\n${marker}` };
+        markerInserted = true;
+        break;
+    }
+    if (!markerInserted)
+        result.unshift({ type: "text", text: marker });
+    return result;
+}
 function buildMergedImageRegistry(messages) {
     const previousRegistry = extractRegistryFromBoundary(messages);
     const currentRegistry = buildImageRegistry(messages);
@@ -405,6 +447,10 @@ function renderInternalContinuationState(summary, reason) {
         "</compact_state>",
     ].join("\n");
 }
+function extractCompactState(text) {
+    const match = /<compact_state>\s*([\s\S]*?)\s*<\/compact_state>/i.exec(text);
+    return match?.[1]?.trim() ?? "";
+}
 function normalizeSummaryForInternalState(summary) {
     return summary
         .split(/\r?\n/)
@@ -412,6 +458,141 @@ function normalizeSummaryForInternalState(summary) {
         .join("\n")
         .trim();
 }
+function buildCheckpointFallbackSummary(messages, maxChars) {
+    const previousState = findLatestCheckpointState(messages);
+    const runtimeContext = messages
+        .filter((message) => message.isMeta === true && (message.metadata?.runtimeContext === true || message.metadata?.userContext === true || message.metadata?.systemContext === true))
+        .map(extractText)
+        .filter(Boolean)
+        .at(-1);
+    const userContext = messages
+        .filter(isRealUserMessage)
+        .map((message) => summarizeMessageText(message, 700))
+        .filter(Boolean)
+        .slice(-12);
+    const assistantProgress = messages
+        .filter((message) => message.role === "assistant" && message.isApiErrorMessage !== true)
+        .map((message) => summarizeMessageText(message, 700))
+        .filter(Boolean)
+        .slice(-10);
+    const references = collectContinuationReferences(messages).slice(0, 24);
+    const toolActivity = summarizeFallbackToolActivity(messages);
+    const sections = [
+        formatFallbackSection("User goals, constraints, and requests", userContext),
+        formatFallbackSection("Assistant progress and decisions", assistantProgress),
+        previousState ? `Previous checkpoint state:\n${truncateSummaryText(previousState, 2400)}` : "",
+        runtimeContext ? `Runtime context:\n${truncateSummaryText(runtimeContext, 900)}` : "",
+        references.length > 0 ? `Critical references:\n${references.map((reference) => `- ${reference}`).join("\n")}` : "",
+        toolActivity ? `Tool activity relevant to continuation:\n${toolActivity}` : "",
+    ].filter(Boolean);
+    const nextStep = "Next step: continue from the latest unresolved user request using the checkpoint state above; verify the current workspace before making further changes.";
+    return fitSummarySectionsWithFooter(sections, nextStep, maxChars);
+}
+function findLatestCheckpointState(messages) {
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const message = messages[index];
+        if (message.metadata?.compactBoundary !== true)
+            continue;
+        return extractCompactState(extractText(message)) || extractText(message);
+    }
+    return "";
+}
+function summarizeMessageText(message, maxChars) {
+    const parts = message.blocks.flatMap((block) => {
+        if (block.type === "text")
+            return [block.text];
+        if (block.type === "image")
+            return [`[image: ${block.label ?? "unlabeled"}, ${block.mimeType}]`];
+        return [];
+    });
+    return truncateSummaryText(parts.join("\n").replace(/\s+/g, " ").trim(), maxChars);
+}
+function collectContinuationReferences(messages) {
+    const references = [];
+    const patterns = [
+        /[A-Za-z]:[\\/](?:[^\s"'`<>|]+[\\/]?)+/g,
+        /(?:^|\s)(\/(?:[^\s"'`<>]+\/?)+)/g,
+        /https?:\/\/[^\s"'`<>]+/g,
+        /\b[0-9a-f]{7,40}\b/gi,
+        /\b(?:task|session|request|response|artifact|turn|thread)[-_ ]?id\s*[:=]\s*[^\s,;]+/gi,
+    ];
+    for (const message of messages) {
+        for (const block of message.blocks) {
+            const text = block.type === "text"
+                ? block.text
+                : block.type === "tool_use"
+                    ? serializeToolOutput(block.input)
+                    : block.type === "tool_result"
+                        ? serializeToolOutput(block.output)
+                        : "";
+            for (const pattern of patterns) {
+                pattern.lastIndex = 0;
+                for (const match of text.matchAll(pattern)) {
+                    const value = (match[1] ?? match[0]).trim().replace(/[),.;:]+$/, "");
+                    if (value)
+                        references.push(value);
+                }
+            }
+        }
+    }
+    return dedupeLines(references).slice(-24);
+}
+function summarizeFallbackToolActivity(messages) {
+    const successful = [];
+    const failedByName = new Map();
+    for (const message of messages) {
+        for (const block of message.blocks) {
+            if (block.type !== "tool_result")
+                continue;
+            if (block.ok) {
+                const output = serializeToolOutput(block.output).replace(/\s+/g, " ").trim();
+                if (output && output !== CLEARED_TOOL_RESULT_CONTENT) {
+                    successful.push(`- ${block.name}: ${truncateSummaryText(output, 320)}`);
+                }
+            }
+            else {
+                failedByName.set(block.name, (failedByName.get(block.name) ?? 0) + 1);
+            }
+        }
+    }
+    const lines = successful.slice(-6);
+    if (failedByName.size > 0) {
+        const counts = [...failedByName.entries()].map(([name, count]) => `${name} ×${count}`).join(", ");
+        lines.push(`- Some tool attempts failed (${counts}); individual transient errors were omitted. Re-check only if still relevant.`);
+    }
+    return lines.join("\n");
+}
+function formatFallbackSection(title, items) {
+    if (items.length === 0)
+        return "";
+    return `${title}:\n${items.map((item) => `- ${item}`).join("\n")}`;
+}
+function truncateSummaryText(text, maxChars) {
+    if (text.length <= maxChars)
+        return text;
+    if (maxChars <= 1)
+        return "…".slice(0, maxChars);
+    return `${text.slice(0, maxChars - 1).trimEnd()}…`;
+}
+function fitSummarySectionsWithFooter(sections, footer, maxChars) {
+    if (maxChars <= 0)
+        return "";
+    if (maxChars <= footer.length)
+        return truncateSummaryText(footer, maxChars);
+    const footerWithSeparator = `\n\n${footer}`;
+    const bodyBudget = maxChars - footerWithSeparator.length;
+    let body = "";
+    for (const section of sections) {
+        const separator = body ? "\n\n" : "";
+        const remaining = bodyBudget - body.length - separator.length;
+        if (remaining <= 0)
+            break;
+        body += separator + truncateSummaryText(section, remaining);
+        if (section.length > remaining)
+            break;
+    }
+    return body ? `${body}${footerWithSeparator}` : footer;
+}
 function scoreMessageImportance(message) {
     let score = 1;
     if (message.metadata?.compactBoundary)
@@ -505,7 +686,7 @@ function buildSmartMessageSummary(message) {
         else if (block.type === "image") {
             const label = block.label ? `"${block.label}"` : "unlabeled";
             const stored = block.storage?.path ? ", stored payload available via image registry" : "";
-            parts.push(`[image omitted from text compaction: ${label}, ${block.mimeType}${stored}; use load_image by id/label for visual inspection]`);
+            parts.push(`[image omitted from text compaction: ${label}, ${block.mimeType}${stored}; use image_inspect by id/label for visual inspection]`);
         }
         else if (block.type === "tool_result") {
             parts.push(extractStructuredToolResult(block));
@@ -618,38 +799,58 @@ function summarizePathForPureState(value) {
     const tail = parts.slice(Math.max(0, parts.length - 3)).join("/");
     return tail ? `[path:${tail}]` : "[path]";
 }
-function serializeTranscriptForSummary(messages, maxChars) {
-    const lines = messages.flatMap((message) => {
-        const content = serializeMessageForSummary(message).trim();
-        if (!content)
-            return [];
-        const metadata = [
-            message.providerMessageId ? `provider=${message.providerMessageId}` : undefined,
-            message.requestId ? `request=${message.requestId}` : undefined,
-            message.isMeta ? "meta" : undefined,
-        ].filter(Boolean).join(" ");
-        return [`<message role="${message.role}"${metadata ? ` ${metadata}` : ""}>\n${content}\n</message>`];
+function prepareMessagesForModelSummary(messages, instructions) {
+    const history = withoutThinkingBlocks(messages)
+        .filter((message) => message.role !== "progress" && message.role !== "tombstone")
+        .map(normalizeMessageForModelSummary);
+    const compactInstruction = {
+        ...createTextMessage("user", instructions),
+        isMeta: true,
+        metadata: { compactInstruction: true },
+    };
+    return [...history, compactInstruction];
+}
+function normalizeMessageForModelSummary(message) {
+    let changed = false;
+    const blocks = message.blocks.map((block) => {
+        if (block.type === "image") {
+            changed = true;
+            const storage = block.storage?.path ? `; stored payload=${block.storage.path}` : "";
+            return {
+                type: "text",
+                text: `[Historical image: ${block.label ?? "unlabeled"}, ${block.mimeType}${storage}. Pixels are omitted from compaction input; preserve the image reference if it may still matter.]`,
+            };
+        }
+        if (block.type === "tool_result") {
+            const output = serializeToolOutput(block.output);
+            const normalizedOutput = summarizeToolResultForModelSummary(output);
+            if (normalizedOutput !== output) {
+                changed = true;
+                return { ...block, output: normalizedOutput };
+            }
+        }
+        return { ...block };
     });
-    const joined = lines.join("\n\n");
-    return joined.length > maxChars ? joined.slice(Math.max(0, joined.length - maxChars)) : joined;
+    return changed
+        ? { ...message, blocks, metadata: { ...message.metadata, compactInputNormalized: true } }
+        : { ...message, blocks };
+}
+function summarizeToolResultForModelSummary(output) {
+    const maxChars = 12_000;
+    if (output.length <= maxChars)
+        return output;
+    const edgeChars = Math.floor((maxChars - 160) / 2);
+    return [
+        `[Tool result normalized for compaction: ${output.length} chars total]`,
+        "Head:",
+        output.slice(0, edgeChars),
+        "Tail:",
+        output.slice(-edgeChars),
+    ].join("\n");
 }
 function serializeMessage(message) {
     return message.blocks.map(serializeBlock).join("\n");
 }
-function serializeMessageForSummary(message) {
-    if (message.metadata?.compactBoundary === true)
-        return extractText(message) || "[compact boundary]";
-    return message.blocks
-        .map((block) => {
-        if (block.type !== "tool_result")
-            return serializeBlock(block);
-        const output = serializeToolOutput(block.output);
-        if (output === CLEARED_TOOL_RESULT_CONTENT)
-            return `tool_result ${block.name}: ${CLEARED_TOOL_RESULT_CONTENT}`;
-        return `tool_result ${block.name}: ${summarizeToolOutput(output)}`;
-    })
-        .join("\n");
-}
 function serializeBlock(block) {
     if (block.type === "text")
         return block.text;
@@ -670,11 +871,6 @@ function serializeBlock(block) {
 function serializeToolOutput(output) {
     return typeof output === "string" ? output : JSON.stringify(output);
 }
-function summarizeToolOutput(output) {
-    if (output.length <= 800)
-        return output;
-    return `[large tool result: ${output.length} chars, head: ${output.slice(0, 400)}]`;
-}
 function collectToolResultIds(messages) {
     const ids = [];
     for (const message of messages) {
@@ -691,21 +887,16 @@ function extractText(message) {
         .map((block) => block.text)
         .join("\n");
 }
-function buildReactiveCompactInstruction(error) {
-    return `${AUTO_COMPACT_INSTRUCTIONS}\n\nThe previous model request failed because the prompt was too long. Preserve enough task state to continue after this error. Error: ${error.message}`;
-}
-const MANUAL_COMPACT_INSTRUCTIONS = [
-    "Summarize the earlier agent conversation for continuation after a user-requested context compaction.",
-    "Preserve: user goals and constraints, decisions made, files or commands mentioned, completed work, pending work, task ids, important tool results, and any errors or blockers.",
-    "Drop: repetitive logs, transient progress chatter, and irrelevant wording.",
-    "Return concise plain text labels, not Markdown headings. Use labels like Goal:, Constraints:, Work completed:, Important facts:, Pending work:, Open risks:.",
-    "Do not include final-answer prose; this summary is an internal continuation state only.",
-].join("\n");
-const AUTO_COMPACT_INSTRUCTIONS = [
-    "Summarize the earlier agent conversation for continuation after context compaction.",
-    "Preserve: user goals and constraints, decisions made, files or commands mentioned, completed work, pending work, task ids, important tool results, and any errors or blockers.",
-    "Drop: repetitive logs, transient progress chatter, and irrelevant wording.",
-    "Return concise plain text labels, not Markdown headings. Use labels like Goal:, Constraints:, Work completed:, Important facts:, Pending work:, Open risks:.",
-    "Do not include final-answer prose; this summary is an internal continuation state only.",
+function defaultRecentTokenBudget(contextWindowTokens) {
+    if (!contextWindowTokens)
+        return undefined;
+    return Math.max(4_000, Math.min(20_000, Math.floor(contextWindowTokens * 0.15)));
+}
+const CHECKPOINT_COMPACT_INSTRUCTIONS = [
+    "You are performing a CONTEXT CHECKPOINT COMPACTION. Create a handoff summary for another LLM that will resume the task without access to the earlier transcript.",
+    "Include the current goal, progress, and key decisions; important context, constraints, and user preferences; completed work and validation status; what remains to be done with clear next steps; and any critical files, paths, identifiers, commands, data, examples, or references needed to continue.",
+    "Use task continuity and current relevance to decide what to preserve. Report tool activity through durable findings and current consequences, not as a chronological call log. Include errors only when they remain relevant as blockers, risks, unresolved failures, or important lessons.",
+    "Treat any earlier compaction summary as prior handoff state. Merge it with later developments, preserve still-valid constraints, and replace stale or superseded status with the newest known state instead of repeating both.",
+    "Be concise, structured, and specific enough for the next LLM to continue immediately. Use the conversation's primary language when practical. Do not invent facts, do not continue the task, and do not write a user-facing final answer.",
 ].join("\n");
 //# sourceMappingURL=compaction.js.map