@psnext/slingcli 2.4.20260520-3 → 2.4.20260520-4

package/node_modules/@earendil-works/pi-agent-core/dist/harness/compaction/branch-summarization.js

@@ -1,37 +1,15 @@
-/**
- * Branch summarization for tree navigation.
- *
- * When navigating to a different point in the session tree, this generates
- * a summary of the branch being left so context isn't lost.
- */
 import { completeSimple } from "@earendil-works/pi-ai";
 import { convertToLlm, createBranchSummaryMessage, createCompactionSummaryMessage, createCustomMessage, } from "../messages.js";
-import { estimateTokens } from "./compaction.js";
-import { computeFileLists, createFileOps, extractFileOpsFromMessage, formatFileOperations, SUMMARIZATION_SYSTEM_PROMPT, serializeConversation, } from "./utils.js";
-// ============================================================================
-// Entry Collection
-// ============================================================================
-/**
- * Collect entries that should be summarized when navigating from one position to another.
- *
- * Walks from oldLeafId back to the common ancestor with targetId, collecting entries
- * along the way. Does NOT stop at compaction boundaries - those are included and their
- * summaries become context.
- *
- * @param session - Session manager (read-only access)
- * @param oldLeafId - Current position (where we're navigating from)
- * @param targetId - Target position (where we're navigating to)
- * @returns Entries to summarize and the common ancestor
- */
+import { BranchSummaryError, err, ok, SessionError } from "../types.js";
+import { estimateTokens, SUMMARIZATION_SYSTEM_PROMPT } from "./compaction.js";
+import { computeFileLists, createFileOps, extractFileOpsFromMessage, formatFileOperations, serializeConversation, } from "./utils.js";
+/** Collect entries that should be summarized before navigating to a different session tree entry. */
 export async function collectEntriesForBranchSummary(session, oldLeafId, targetId) {
-    // If no old position, nothing to summarize
     if (!oldLeafId) {
         return { entries: [], commonAncestorId: null };
     }
-    // Find common ancestor (deepest node that's on both paths)
     const oldPath = new Set((await session.getBranch(oldLeafId)).map((e) => e.id));
     const targetPath = await session.getBranch(targetId);
-    // targetPath is root-first, so iterate backwards to find deepest common ancestor
     let commonAncestorId = null;
     for (let i = targetPath.length - 1; i >= 0; i--) {
         if (oldPath.has(targetPath[i].id)) {
@@ -39,31 +17,21 @@ export async function collectEntriesForBranchSummary(session, oldLeafId, targetI
             break;
         }
     }
-    // Collect entries from old leaf back to common ancestor
     const entries = [];
     let current = oldLeafId;
     while (current && current !== commonAncestorId) {
         const entry = await session.getEntry(current);
         if (!entry)
-            break;
+            throw new SessionError("invalid_session", `Entry ${current} not found`);
         entries.push(entry);
         current = entry.parentId;
     }
-    // Reverse to get chronological order
     entries.reverse();
     return { entries, commonAncestorId };
 }
-// ============================================================================
-// Entry to Message Conversion
-// ============================================================================
-/**
- * Extract AgentMessage from a session entry.
- * Similar to getMessageFromEntry in compaction.ts but also handles compaction entries.
- */
 function getMessageFromEntry(entry) {
     switch (entry.type) {
         case "message":
-            // Skip tool results - context is in assistant's tool call
             if (entry.message.role === "toolResult")
                 return undefined;
             return entry.message;
@@ -73,35 +41,20 @@ function getMessageFromEntry(entry) {
             return createBranchSummaryMessage(entry.summary, entry.fromId, entry.timestamp);
         case "compaction":
             return createCompactionSummaryMessage(entry.summary, entry.tokensBefore, entry.timestamp);
-        // These don't contribute to conversation content
         case "thinking_level_change":
         case "model_change":
         case "custom":
         case "label":
         case "session_info":
+        case "leaf":
             return undefined;
     }
 }
-/**
- * Prepare entries for summarization with token budget.
- *
- * Walks entries from NEWEST to OLDEST, adding messages until we hit the token budget.
- * This ensures we keep the most recent context when the branch is too long.
- *
- * Also collects file operations from:
- * - Tool calls in assistant messages
- * - Existing branch_summary entries' details (for cumulative tracking)
- *
- * @param entries - Entries in chronological order
- * @param tokenBudget - Maximum tokens to include (0 = no limit)
- */
+/** Prepare branch entries for summarization within an optional token budget. */
 export function prepareBranchEntries(entries, tokenBudget = 0) {
     const messages = [];
     const fileOps = createFileOps();
     let totalTokens = 0;
-    // First pass: collect file ops from ALL entries (even if they don't fit in token budget)
-    // This ensures we capture cumulative file tracking from nested branch summaries
-    // Only extract from pi-generated summaries (fromHook !== true), not extension-generated ones
     for (const entry of entries) {
         if (entry.type === "branch_summary" && !entry.fromHook && entry.details) {
             const details = entry.details;
@@ -110,32 +63,26 @@ export function prepareBranchEntries(entries, tokenBudget = 0) {
                     fileOps.read.add(f);
             }
             if (Array.isArray(details.modifiedFiles)) {
-                // Modified files go into both edited and written for proper deduplication
                 for (const f of details.modifiedFiles) {
                     fileOps.edited.add(f);
                 }
             }
         }
     }
-    // Second pass: walk from newest to oldest, adding messages until token budget
     for (let i = entries.length - 1; i >= 0; i--) {
         const entry = entries[i];
         const message = getMessageFromEntry(entry);
         if (!message)
             continue;
-        // Extract file ops from assistant messages (tool calls)
         extractFileOpsFromMessage(message, fileOps);
         const tokens = estimateTokens(message);
-        // Check budget before adding
         if (tokenBudget > 0 && totalTokens + tokens > tokenBudget) {
-            // If this is a summary entry, try to fit it anyway as it's important context
             if (entry.type === "compaction" || entry.type === "branch_summary") {
                 if (totalTokens < tokenBudget * 0.9) {
                     messages.unshift(message);
                     totalTokens += tokens;
                 }
             }
-            // Stop - we've hit the budget
             break;
         }
         messages.unshift(message);
@@ -143,9 +90,6 @@ export function prepareBranchEntries(entries, tokenBudget = 0) {
     }
     return { messages, fileOps, totalTokens };
 }
-// ============================================================================
-// Summary Generation
-// ============================================================================
 const BRANCH_SUMMARY_PREAMBLE = `The user explored a different conversation branch before returning here.
 Summary of that exploration:
 
@@ -178,26 +122,17 @@ Use this EXACT format:
 1. [What should happen next to continue this work]
 
 Keep each section concise. Preserve exact file paths, function names, and error messages.`;
-/**
- * Generate a summary of abandoned branch entries.
- *
- * @param entries - Session entries to summarize (chronological order)
- * @param options - Generation options
- */
+/** Generate a summary for abandoned branch entries. */
 export async function generateBranchSummary(entries, options) {
     const { model, apiKey, headers, signal, customInstructions, replaceInstructions, reserveTokens = 16384 } = options;
-    // Token budget = context window minus reserved space for prompt + response
     const contextWindow = model.contextWindow || 128000;
     const tokenBudget = contextWindow - reserveTokens;
     const { messages, fileOps } = prepareBranchEntries(entries, tokenBudget);
     if (messages.length === 0) {
-        return { summary: "No content to summarize" };
+        return ok({ summary: "No content to summarize", readFiles: [], modifiedFiles: [] });
     }
-    // Transform to LLM-compatible messages, then serialize to text
-    // Serialization prevents the model from treating it as a conversation to continue
     const llmMessages = convertToLlm(messages);
     const conversationText = serializeConversation(llmMessages);
-    // Build prompt
     let instructions;
     if (replaceInstructions && customInstructions) {
         instructions = customInstructions;
@@ -216,28 +151,24 @@ export async function generateBranchSummary(entries, options) {
             timestamp: Date.now(),
         },
     ];
-    // Call LLM for summarization
     const response = await completeSimple(model, { systemPrompt: SUMMARIZATION_SYSTEM_PROMPT, messages: summarizationMessages }, { apiKey, headers, signal, maxTokens: 2048 });
-    // Check if aborted or errored
     if (response.stopReason === "aborted") {
-        return { aborted: true };
+        return err(new BranchSummaryError("aborted", response.errorMessage || "Branch summary aborted"));
     }
     if (response.stopReason === "error") {
-        return { error: response.errorMessage || "Summarization failed" };
+        return err(new BranchSummaryError("summarization_failed", `Branch summary failed: ${response.errorMessage || "Unknown error"}`));
     }
     let summary = response.content
         .filter((c) => c.type === "text")
         .map((c) => c.text)
         .join("\n");
-    // Prepend preamble to provide context about the branch summary
     summary = BRANCH_SUMMARY_PREAMBLE + summary;
-    // Compute file lists and append to summary
     const { readFiles, modifiedFiles } = computeFileLists(fileOps);
     summary += formatFileOperations(readFiles, modifiedFiles);
-    return {
+    return ok({
         summary: summary || "No summary generated",
         readFiles,
         modifiedFiles,
-    };
+    });
 }
 //# sourceMappingURL=branch-summarization.js.map

package/node_modules/@earendil-works/pi-agent-core/dist/harness/compaction/compaction.js

@@ -1,23 +1,21 @@
-/**
- * Context compaction for long sessions.
- *
- * Pure functions for compaction logic. The session manager handles I/O,
- * and after compaction the session is reloaded.
- */
 import { completeSimple } from "@earendil-works/pi-ai";
 import { convertToLlm, createBranchSummaryMessage, createCompactionSummaryMessage, createCustomMessage, } from "../messages.js";
 import { buildSessionContext } from "../session/session.js";
-import { computeFileLists, createFileOps, extractFileOpsFromMessage, formatFileOperations, SUMMARIZATION_SYSTEM_PROMPT, serializeConversation, } from "./utils.js";
-/**
- * Extract file operations from messages and previous compaction entries.
- */
+import { CompactionError, err, ok } from "../types.js";
+import { computeFileLists, createFileOps, extractFileOpsFromMessage, formatFileOperations, serializeConversation, } from "./utils.js";
+function safeJsonStringify(value) {
+    try {
+        return JSON.stringify(value) ?? "undefined";
+    }
+    catch {
+        return "[unserializable]";
+    }
+}
 function extractFileOperations(messages, entries, prevCompactionIndex) {
     const fileOps = createFileOps();
-    // Collect from previous compaction's details (if pi-generated)
     if (prevCompactionIndex >= 0) {
         const prevCompaction = entries[prevCompactionIndex];
         if (!prevCompaction.fromHook && prevCompaction.details) {
-            // fromHook field kept for session file compatibility
             const details = prevCompaction.details;
             if (Array.isArray(details.readFiles)) {
                 for (const f of details.readFiles)
@@ -29,19 +27,11 @@ function extractFileOperations(messages, entries, prevCompactionIndex) {
             }
         }
     }
-    // Extract from tool calls in messages
     for (const msg of messages) {
         extractFileOpsFromMessage(msg, fileOps);
     }
     return fileOps;
 }
-// ============================================================================
-// Message Extraction
-// ============================================================================
-/**
- * Extract AgentMessage from an entry if it produces one.
- * Returns undefined for entries that don't contribute to LLM context.
- */
 function getMessageFromEntry(entry) {
     if (entry.type === "message") {
         return entry.message;
@@ -63,25 +53,16 @@ function getMessageFromEntryForCompaction(entry) {
     }
     return getMessageFromEntry(entry);
 }
+/** Default compaction settings used by the harness. */
 export const DEFAULT_COMPACTION_SETTINGS = {
     enabled: true,
     reserveTokens: 16384,
     keepRecentTokens: 20000,
 };
-// ============================================================================
-// Token calculation
-// ============================================================================
-/**
- * Calculate total context tokens from usage.
- * Uses the native totalTokens field when available, falls back to computing from components.
- */
+/** Calculate total context tokens from provider usage. */
 export function calculateContextTokens(usage) {
     return usage.totalTokens || usage.input + usage.output + usage.cacheRead + usage.cacheWrite;
 }
-/**
- * Get usage from an assistant message if available.
- * Skips aborted and error messages as they don't have valid usage data.
- */
 function getAssistantUsage(msg) {
     if (msg.role === "assistant" && "usage" in msg) {
         const assistantMsg = msg;
@@ -91,9 +72,7 @@ function getAssistantUsage(msg) {
     }
     return undefined;
 }
-/**
- * Find the last non-aborted assistant message usage from session entries.
- */
+/** Return usage from the last successful assistant message in session entries. */
 export function getLastAssistantUsage(entries) {
     for (let i = entries.length - 1; i >= 0; i--) {
         const entry = entries[i];
@@ -113,10 +92,7 @@ function getLastAssistantUsageInfo(messages) {
     }
     return undefined;
 }
-/**
- * Estimate context tokens from messages, using the last assistant usage when available.
- * If there are messages after the last usage, estimate their tokens with estimateTokens.
- */
+/** Estimate context tokens for messages using provider usage when available. */
 export function estimateContextTokens(messages) {
     const usageInfo = getLastAssistantUsageInfo(messages);
     if (!usageInfo) {
@@ -143,21 +119,13 @@ export function estimateContextTokens(messages) {
         lastUsageIndex: usageInfo.index,
     };
 }
-/**
- * Check if compaction should trigger based on context usage.
- */
+/** Return whether context usage exceeds the configured compaction threshold. */
 export function shouldCompact(contextTokens, contextWindow, settings) {
     if (!settings.enabled)
         return false;
     return contextTokens > contextWindow - settings.reserveTokens;
 }
-// ============================================================================
-// Cut point detection
-// ============================================================================
-/**
- * Estimate token count for a message using chars/4 heuristic.
- * This is conservative (overestimates tokens).
- */
+/** Estimate token count for one message using a conservative character heuristic. */
 export function estimateTokens(message) {
     let chars = 0;
     switch (message.role) {
@@ -185,7 +153,7 @@ export function estimateTokens(message) {
                     chars += block.thinking.length;
                 }
                 else if (block.type === "toolCall") {
-                    chars += block.name.length + JSON.stringify(block.arguments).length;
+                    chars += block.name.length + safeJsonStringify(block.arguments).length;
                 }
             }
             return Math.ceil(chars / 4);
@@ -201,7 +169,7 @@ export function estimateTokens(message) {
                         chars += block.text.length;
                     }
                     if (block.type === "image") {
-                        chars += 4800; // Estimate images as 4000 chars, or 1200 tokens
+                        chars += 4800;
                     }
                 }
             }
@@ -219,13 +187,6 @@ export function estimateTokens(message) {
     }
     return 0;
 }
-/**
- * Find valid cut points: indices of user, assistant, custom, or bashExecution messages.
- * Never cut at tool results (they must follow their tool call).
- * When we cut at an assistant message with tool calls, its tool results follow it
- * and will be kept.
- * BashExecutionMessage is treated like a user message (user-initiated context).
- */
 function findValidCutPoints(entries, startIndex, endIndex) {
     const cutPoints = [];
     for (let i = startIndex; i < endIndex; i++) {
@@ -255,24 +216,19 @@ function findValidCutPoints(entries, startIndex, endIndex) {
             case "custom_message":
             case "label":
             case "session_info":
+            case "leaf":
                 break;
         }
-        // branch_summary and custom_message are user-role messages, valid cut points
         if (entry.type === "branch_summary" || entry.type === "custom_message") {
             cutPoints.push(i);
         }
     }
     return cutPoints;
 }
-/**
- * Find the user message (or bashExecution) that starts the turn containing the given entry index.
- * Returns -1 if no turn start found before the index.
- * BashExecutionMessage is treated like a user message for turn boundaries.
- */
+/** Find the user-visible message that starts the turn containing an entry. */
 export function findTurnStartIndex(entries, entryIndex, startIndex) {
     for (let i = entryIndex; i >= startIndex; i--) {
         const entry = entries[i];
-        // branch_summary and custom_message are user-role messages, can start a turn
         if (entry.type === "branch_summary" || entry.type === "custom_message") {
             return i;
         }
@@ -285,40 +241,21 @@ export function findTurnStartIndex(entries, entryIndex, startIndex) {
     }
     return -1;
 }
-/**
- * Find the cut point in session entries that keeps approximately `keepRecentTokens`.
- *
- * Algorithm: Walk backwards from newest, accumulating estimated message sizes.
- * Stop when we've accumulated >= keepRecentTokens. Cut at that point.
- *
- * Can cut at user OR assistant messages (never tool results). When cutting at an
- * assistant message with tool calls, its tool results come after and will be kept.
- *
- * Returns CutPointResult with:
- * - firstKeptEntryIndex: the entry index to start keeping from
- * - turnStartIndex: if cutting mid-turn, the user message that started that turn
- * - isSplitTurn: whether we're cutting in the middle of a turn
- *
- * Only considers entries between `startIndex` and `endIndex` (exclusive).
- */
+/** Find the compaction cut point that keeps approximately the requested recent-token budget. */
 export function findCutPoint(entries, startIndex, endIndex, keepRecentTokens) {
     const cutPoints = findValidCutPoints(entries, startIndex, endIndex);
     if (cutPoints.length === 0) {
         return { firstKeptEntryIndex: startIndex, turnStartIndex: -1, isSplitTurn: false };
     }
-    // Walk backwards from newest, accumulating estimated message sizes
     let accumulatedTokens = 0;
-    let cutIndex = cutPoints[0]; // Default: keep from first message (not header)
+    let cutIndex = cutPoints[0];
     for (let i = endIndex - 1; i >= startIndex; i--) {
         const entry = entries[i];
         if (entry.type !== "message")
             continue;
-        // Estimate this message's size
         const messageTokens = estimateTokens(entry.message);
         accumulatedTokens += messageTokens;
-        // Check if we've exceeded the budget
         if (accumulatedTokens >= keepRecentTokens) {
-            // Find the closest valid cut point at or after this entry
             for (let c = 0; c < cutPoints.length; c++) {
                 if (cutPoints[c] >= i) {
                     cutIndex = cutPoints[c];
@@ -328,21 +265,16 @@ export function findCutPoint(entries, startIndex, endIndex, keepRecentTokens) {
             break;
         }
     }
-    // Scan backwards from cutIndex to include any non-message entries (bash, settings, etc.)
     while (cutIndex > startIndex) {
         const prevEntry = entries[cutIndex - 1];
-        // Stop at session header or compaction boundaries
         if (prevEntry.type === "compaction") {
             break;
         }
         if (prevEntry.type === "message") {
-            // Stop if we hit any message
             break;
         }
-        // Include this non-message entry (bash, settings change, etc.)
         cutIndex--;
     }
-    // Determine if this is a split turn
     const cutEntry = entries[cutIndex];
     const isUserMessage = cutEntry.type === "message" && cutEntry.message.role === "user";
     const turnStartIndex = isUserMessage ? -1 : findTurnStartIndex(entries, cutIndex, startIndex);
@@ -352,9 +284,9 @@ export function findCutPoint(entries, startIndex, endIndex, keepRecentTokens) {
         isSplitTurn: !isUserMessage && turnStartIndex !== -1,
     };
 }
-// ============================================================================
-// Summarization
-// ============================================================================
+export const SUMMARIZATION_SYSTEM_PROMPT = `You are a context summarization assistant. Your task is to read a conversation between a user and an AI coding assistant, then produce a structured summary following the exact format specified.
+
+Do NOT continue the conversation. Do NOT respond to any questions in the conversation. ONLY output the structured summary.`;
 const SUMMARIZATION_PROMPT = `The messages above are a conversation to summarize. Create a structured context checkpoint summary that another LLM will use to continue the work.
 
 Use this EXACT format:
@@ -425,22 +357,15 @@ Use this EXACT format:
 - [Preserve important context, add new if needed]
 
 Keep each section concise. Preserve exact file paths, function names, and error messages.`;
-/**
- * Generate a summary of the conversation using the LLM.
- * If previousSummary is provided, uses the update prompt to merge.
- */
+/** Generate or update a conversation summary for compaction. */
 export async function generateSummary(currentMessages, model, reserveTokens, apiKey, headers, signal, customInstructions, previousSummary, thinkingLevel) {
-    const maxTokens = Math.floor(0.8 * reserveTokens);
-    // Use update prompt if we have a previous summary, otherwise initial prompt
+    const maxTokens = Math.min(Math.floor(0.8 * reserveTokens), model.maxTokens > 0 ? model.maxTokens : Number.POSITIVE_INFINITY);
     let basePrompt = previousSummary ? UPDATE_SUMMARIZATION_PROMPT : SUMMARIZATION_PROMPT;
     if (customInstructions) {
         basePrompt = `${basePrompt}\n\nAdditional focus: ${customInstructions}`;
     }
-    // Serialize conversation to text so model doesn't try to continue it
-    // Convert to LLM messages first (handles custom types like bashExecution, custom, etc.)
     const llmMessages = convertToLlm(currentMessages);
     const conversationText = serializeConversation(llmMessages);
-    // Build the prompt with conversation wrapped in tags
     let promptText = `<conversation>\n${conversationText}\n</conversation>\n\n`;
     if (previousSummary) {
         promptText += `<previous-summary>\n${previousSummary}\n</previous-summary>\n\n`;
@@ -457,18 +382,22 @@ export async function generateSummary(currentMessages, model, reserveTokens, api
         ? { maxTokens, signal, apiKey, headers, reasoning: thinkingLevel }
         : { maxTokens, signal, apiKey, headers };
     const response = await completeSimple(model, { systemPrompt: SUMMARIZATION_SYSTEM_PROMPT, messages: summarizationMessages }, completionOptions);
+    if (response.stopReason === "aborted") {
+        return err(new CompactionError("aborted", response.errorMessage || "Summarization aborted"));
+    }
     if (response.stopReason === "error") {
-        throw new Error(`Summarization failed: ${response.errorMessage || "Unknown error"}`);
+        return err(new CompactionError("summarization_failed", `Summarization failed: ${response.errorMessage || "Unknown error"}`));
     }
     const textContent = response.content
         .filter((c) => c.type === "text")
         .map((c) => c.text)
         .join("\n");
-    return textContent;
+    return ok(textContent);
 }
+/** Prepare session entries for compaction, or return undefined when compaction is not applicable. */
 export function prepareCompaction(pathEntries, settings) {
-    if (pathEntries.length > 0 && pathEntries[pathEntries.length - 1].type === "compaction") {
-        return undefined;
+    if (pathEntries.length === 0 || pathEntries[pathEntries.length - 1].type === "compaction") {
+        return ok(undefined);
     }
     let prevCompactionIndex = -1;
     for (let i = pathEntries.length - 1; i >= 0; i--) {
@@ -488,21 +417,18 @@ export function prepareCompaction(pathEntries, settings) {
     const boundaryEnd = pathEntries.length;
     const tokensBefore = estimateContextTokens(buildSessionContext(pathEntries).messages).tokens;
     const cutPoint = findCutPoint(pathEntries, boundaryStart, boundaryEnd, settings.keepRecentTokens);
-    // Get UUID of first kept entry
     const firstKeptEntry = pathEntries[cutPoint.firstKeptEntryIndex];
     if (!firstKeptEntry?.id) {
-        return undefined; // Session needs migration
+        return err(new CompactionError("invalid_session", "First kept entry has no UUID - session may need migration"));
     }
     const firstKeptEntryId = firstKeptEntry.id;
     const historyEnd = cutPoint.isSplitTurn ? cutPoint.turnStartIndex : cutPoint.firstKeptEntryIndex;
-    // Messages to summarize (will be discarded after summary)
     const messagesToSummarize = [];
     for (let i = boundaryStart; i < historyEnd; i++) {
         const msg = getMessageFromEntryForCompaction(pathEntries[i]);
         if (msg)
             messagesToSummarize.push(msg);
     }
-    // Messages for turn prefix summary (if splitting a turn)
     const turnPrefixMessages = [];
     if (cutPoint.isSplitTurn) {
         for (let i = cutPoint.turnStartIndex; i < cutPoint.firstKeptEntryIndex; i++) {
@@ -511,15 +437,13 @@ export function prepareCompaction(pathEntries, settings) {
                 turnPrefixMessages.push(msg);
         }
     }
-    // Extract file operations from messages and previous compaction
     const fileOps = extractFileOperations(messagesToSummarize, pathEntries, prevCompactionIndex);
-    // Also extract file ops from turn prefix if splitting
     if (cutPoint.isSplitTurn) {
         for (const msg of turnPrefixMessages) {
             extractFileOpsFromMessage(msg, fileOps);
         }
     }
-    return {
+    return ok({
         firstKeptEntryId,
         messagesToSummarize,
         turnPrefixMessages,
@@ -528,11 +452,8 @@ export function prepareCompaction(pathEntries, settings) {
         previousSummary,
         fileOps,
         settings,
-    };
+    });
 }
-// ============================================================================
-// Main compaction function
-// ============================================================================
 const TURN_PREFIX_SUMMARIZATION_PROMPT = `This is the PREFIX of a turn that was too large to keep. The SUFFIX (recent work) is retained.
 
 Summarize the prefix to provide context for the retained suffix:
@@ -547,51 +468,44 @@ Summarize the prefix to provide context for the retained suffix:
 - [Information needed to understand the retained recent work]
 
 Be concise. Focus on what's needed to understand the kept suffix.`;
-/**
- * Generate summaries for compaction using prepared data.
- * Returns CompactionResult - SessionManager adds uuid/parentUuid when saving.
- *
- * @param preparation - Pre-calculated preparation from prepareCompaction()
- * @param customInstructions - Optional custom focus for the summary
- */
 export { serializeConversation } from "./utils.js";
+/** Generate compaction summary data from prepared session history. */
 export async function compact(preparation, model, apiKey, headers, customInstructions, signal, thinkingLevel) {
     const { firstKeptEntryId, messagesToSummarize, turnPrefixMessages, isSplitTurn, tokensBefore, previousSummary, fileOps, settings, } = preparation;
-    // Generate summaries (can be parallel if both needed) and merge into one
+    if (!firstKeptEntryId) {
+        return err(new CompactionError("invalid_session", "First kept entry has no UUID - session may need migration"));
+    }
     let summary;
     if (isSplitTurn && turnPrefixMessages.length > 0) {
-        // Generate both summaries in parallel
         const [historyResult, turnPrefixResult] = await Promise.all([
             messagesToSummarize.length > 0
                 ? generateSummary(messagesToSummarize, model, settings.reserveTokens, apiKey, headers, signal, customInstructions, previousSummary, thinkingLevel)
-                : Promise.resolve("No prior history."),
+                : Promise.resolve(ok("No prior history.")),
             generateTurnPrefixSummary(turnPrefixMessages, model, settings.reserveTokens, apiKey, headers, signal, thinkingLevel),
         ]);
-        // Merge into single summary
-        summary = `${historyResult}\n\n---\n\n**Turn Context (split turn):**\n\n${turnPrefixResult}`;
+        if (!historyResult.ok)
+            return err(historyResult.error);
+        if (!turnPrefixResult.ok)
+            return err(turnPrefixResult.error);
+        summary = `${historyResult.value}\n\n---\n\n**Turn Context (split turn):**\n\n${turnPrefixResult.value}`;
     }
     else {
-        // Just generate history summary
-        summary = await generateSummary(messagesToSummarize, model, settings.reserveTokens, apiKey, headers, signal, customInstructions, previousSummary, thinkingLevel);
+        const summaryResult = await generateSummary(messagesToSummarize, model, settings.reserveTokens, apiKey, headers, signal, customInstructions, previousSummary, thinkingLevel);
+        if (!summaryResult.ok)
+            return err(summaryResult.error);
+        summary = summaryResult.value;
     }
-    // Compute file lists and append to summary
     const { readFiles, modifiedFiles } = computeFileLists(fileOps);
     summary += formatFileOperations(readFiles, modifiedFiles);
-    if (!firstKeptEntryId) {
-        throw new Error("First kept entry has no UUID - session may need migration");
-    }
-    return {
+    return ok({
         summary,
         firstKeptEntryId,
         tokensBefore,
         details: { readFiles, modifiedFiles },
-    };
+    });
 }
-/**
- * Generate a summary for a turn prefix (when splitting a turn).
- */
 async function generateTurnPrefixSummary(messages, model, reserveTokens, apiKey, headers, signal, thinkingLevel) {
-    const maxTokens = Math.floor(0.5 * reserveTokens); // Smaller budget for turn prefix
+    const maxTokens = Math.min(Math.floor(0.5 * reserveTokens), model.maxTokens > 0 ? model.maxTokens : Number.POSITIVE_INFINITY);
     const llmMessages = convertToLlm(messages);
     const conversationText = serializeConversation(llmMessages);
     const promptText = `<conversation>\n${conversationText}\n</conversation>\n\n${TURN_PREFIX_SUMMARIZATION_PROMPT}`;
@@ -605,12 +519,15 @@ async function generateTurnPrefixSummary(messages, model, reserveTokens, apiKey,
     const response = await completeSimple(model, { systemPrompt: SUMMARIZATION_SYSTEM_PROMPT, messages: summarizationMessages }, model.reasoning && thinkingLevel && thinkingLevel !== "off"
         ? { maxTokens, signal, apiKey, headers, reasoning: thinkingLevel }
         : { maxTokens, signal, apiKey, headers });
+    if (response.stopReason === "aborted") {
+        return err(new CompactionError("aborted", response.errorMessage || "Turn prefix summarization aborted"));
+    }
     if (response.stopReason === "error") {
-        throw new Error(`Turn prefix summarization failed: ${response.errorMessage || "Unknown error"}`);
+        return err(new CompactionError("summarization_failed", `Turn prefix summarization failed: ${response.errorMessage || "Unknown error"}`));
     }
-    return response.content
+    return ok(response.content
         .filter((c) => c.type === "text")
         .map((c) => c.text)
-        .join("\n");
+        .join("\n"));
 }
 //# sourceMappingURL=compaction.js.map