@dexto/core 1.5.3 → 1.5.5

package/dist/context/compaction/schemas.js

@@ -2,11 +2,31 @@ import "../../chunk-PTJYTZNU.js";
 import { z } from "zod";
 const CompactionConfigSchema = z.object({
   type: z.string().describe("Compaction provider type"),
-  enabled: z.boolean().default(true).describe("Enable or disable compaction")
+  enabled: z.boolean().default(true).describe("Enable or disable compaction"),
+  /**
+   * Maximum context tokens before compaction triggers.
+   * When set, overrides the model's context window for compaction threshold.
+   * Useful for capping context size below the model's maximum limit.
+   * Example: Set to 50000 to trigger compaction at 50K tokens even if
+   * the model supports 200K tokens.
+   */
+  maxContextTokens: z.number().positive().optional().describe(
+    "Maximum context tokens before compaction triggers. Overrides model context window when set."
+  ),
+  /**
+   * Percentage of context window that triggers compaction (0.0 to 1.0).
+   * Default is 0.9 (90%), leaving a 10% buffer to avoid context degradation.
+   * Set lower values to trigger compaction earlier.
+   * Example: 0.8 triggers compaction when 80% of context is used.
+   */
+  thresholdPercent: z.number().min(0.1).max(1).default(0.9).describe(
+    "Percentage of context window that triggers compaction (0.1 to 1.0, default 0.9)"
+  )
 }).passthrough().describe("Context compaction configuration");
 const DEFAULT_COMPACTION_CONFIG = {
   type: "reactive-overflow",
-  enabled: true
+  enabled: true,
+  thresholdPercent: 0.9
 };
 export {
   CompactionConfigSchema,

package/dist/context/compaction/strategies/reactive-overflow.cjs

@@ -26,15 +26,36 @@ var import_types = require("../../types.js");
 const DEFAULT_OPTIONS = {
   preserveLastNTurns: 2,
   maxSummaryTokens: 2e3,
-  summaryPrompt: `You are a conversation summarizer. Summarize the following conversation history concisely, focusing on:
-- What tasks were attempted and their outcomes
-- Current state and context the assistant needs to remember
-- Any important decisions or information discovered
-- What the user was trying to accomplish
+  summaryPrompt: `You are a conversation summarizer creating a structured summary for session continuation.
 
-Be concise but preserve essential context. Output only the summary, no preamble.
+Analyze the conversation and produce a summary in the following XML format:
 
-Conversation:
+<session_compaction>
+  <conversation_history>
+    A concise summary of what happened in the conversation:
+    - Tasks attempted and their outcomes (success/failure/in-progress)
+    - Important decisions made
+    - Key information discovered (file paths, configurations, errors encountered)
+    - Tools used and their results
+  </conversation_history>
+
+  <current_task>
+    The most recent task or instruction the user requested that may still be in progress.
+    Be specific - include the exact request and current status.
+  </current_task>
+
+  <important_context>
+    Critical state that must be preserved:
+    - File paths being worked on
+    - Variable values or configurations
+    - Error messages that need addressing
+    - Any pending actions or next steps
+  </important_context>
+</session_compaction>
+
+IMPORTANT: The assistant will continue working based on this summary. Ensure the current_task section clearly states what needs to be done next.
+
+Conversation to summarize:
 {conversation}`
 };
 class ReactiveOverflowStrategy {
@@ -63,15 +84,73 @@ class ReactiveOverflowStrategy {
       this.logger.debug("ReactiveOverflowStrategy: History too short, skipping compaction");
       return [];
     }
+    let existingSummaryIndex = -1;
+    for (let i = history.length - 1; i >= 0; i--) {
+      const msg = history[i];
+      if (msg?.metadata?.isSummary === true || msg?.metadata?.isSessionSummary === true) {
+        existingSummaryIndex = i;
+        break;
+      }
+    }
+    if (existingSummaryIndex !== -1) {
+      const messagesAfterSummary = history.slice(existingSummaryIndex + 1);
+      if (messagesAfterSummary.length <= 4) {
+        this.logger.debug(
+          `ReactiveOverflowStrategy: Only ${messagesAfterSummary.length} messages after existing summary, skipping re-compaction`
+        );
+        return [];
+      }
+      this.logger.info(
+        `ReactiveOverflowStrategy: Found existing summary at index ${existingSummaryIndex}, working with ${messagesAfterSummary.length} messages after it`
+      );
+      return this.compactSubset(messagesAfterSummary, history, existingSummaryIndex);
+    }
     const { toSummarize, toKeep } = this.splitHistory(history);
     if (toSummarize.length === 0) {
       this.logger.debug("ReactiveOverflowStrategy: No messages to summarize");
       return [];
     }
+    const currentTaskMessage = this.findCurrentTaskMessage(history);
     this.logger.info(
       `ReactiveOverflowStrategy: Summarizing ${toSummarize.length} messages, keeping ${toKeep.length}`
     );
-    const summary = await this.generateSummary(toSummarize);
+    const summary = await this.generateSummary(toSummarize, currentTaskMessage);
+    const summaryMessage = {
+      role: "assistant",
+      content: [{ type: "text", text: summary }],
+      timestamp: Date.now(),
+      metadata: {
+        isSummary: true,
+        summarizedAt: Date.now(),
+        originalMessageCount: toSummarize.length,
+        originalFirstTimestamp: toSummarize[0]?.timestamp,
+        originalLastTimestamp: toSummarize[toSummarize.length - 1]?.timestamp
+      }
+    };
+    return [summaryMessage];
+  }
+  /**
+   * Handle re-compaction when there's already a summary in history.
+   * Only summarizes messages AFTER the existing summary, preventing
+   * cascading summaries of summaries.
+   *
+   * @param messagesAfterSummary Messages after the existing summary
+   * @param fullHistory The complete history (for current task detection)
+   * @param existingSummaryIndex Index of the existing summary in fullHistory
+   * @returns Array with single summary message, or empty if nothing to summarize
+   */
+  async compactSubset(messagesAfterSummary, fullHistory, existingSummaryIndex) {
+    const { toSummarize, toKeep } = this.splitHistory(messagesAfterSummary);
+    if (toSummarize.length === 0) {
+      this.logger.debug("ReactiveOverflowStrategy: No messages to summarize in subset");
+      return [];
+    }
+    const currentTaskMessage = this.findCurrentTaskMessage(fullHistory);
+    this.logger.info(
+      `ReactiveOverflowStrategy (re-compact): Summarizing ${toSummarize.length} messages after existing summary, keeping ${toKeep.length}`
+    );
+    const summary = await this.generateSummary(toSummarize, currentTaskMessage);
+    const absoluteOriginalMessageCount = existingSummaryIndex + 1 + toSummarize.length;
     const summaryMessage = {
       role: "assistant",
       content: [{ type: "text", text: summary }],
@@ -79,16 +158,43 @@ class ReactiveOverflowStrategy {
       metadata: {
         isSummary: true,
         summarizedAt: Date.now(),
-        summarizedMessageCount: toSummarize.length,
+        originalMessageCount: absoluteOriginalMessageCount,
+        isRecompaction: true,
+        // Mark that this is a re-compaction
         originalFirstTimestamp: toSummarize[0]?.timestamp,
         originalLastTimestamp: toSummarize[toSummarize.length - 1]?.timestamp
       }
     };
     return [summaryMessage];
   }
+  /**
+   * Find the most recent user message that represents the current task.
+   * This helps preserve context about what the user is currently asking for.
+   */
+  findCurrentTaskMessage(history) {
+    for (let i = history.length - 1; i >= 0; i--) {
+      const msg = history[i];
+      if (msg?.role === "user") {
+        if (typeof msg.content === "string") {
+          return msg.content;
+        } else if (Array.isArray(msg.content)) {
+          const textParts = msg.content.filter(
+            (part) => part.type === "text"
+          ).map((part) => part.text).join("\n");
+          if (textParts.length > 0) {
+            return textParts;
+          }
+        }
+      }
+    }
+    return null;
+  }
   /**
    * Split history into messages to summarize and messages to keep.
    * Keeps the last N turns (user + assistant pairs) intact.
+   *
+   * For long agentic conversations with many tool calls, this also ensures
+   * we don't try to keep too many messages even within preserved turns.
    */
   splitHistory(history) {
     const turnsToKeep = this.options.preserveLastNTurns;
@@ -103,20 +209,25 @@ class ReactiveOverflowStrategy {
     }
     if (userMessageIndices.length > 0) {
       const splitIndex = userMessageIndices[0];
-      if (splitIndex !== void 0) {
-        if (splitIndex === 0) {
-          return {
-            toSummarize: [],
-            toKeep: history
-          };
-        }
+      if (splitIndex !== void 0 && splitIndex > 0) {
         return {
           toSummarize: history.slice(0, splitIndex),
           toKeep: history.slice(splitIndex)
         };
       }
     }
-    const keepCount = Math.min(4, history.length);
+    const minKeep = 3;
+    const maxKeepPercent = 0.2;
+    const keepCount = Math.max(minKeep, Math.floor(history.length * maxKeepPercent));
+    if (keepCount >= history.length) {
+      return {
+        toSummarize: [],
+        toKeep: history
+      };
+    }
+    this.logger.debug(
+      `splitHistory: Using fallback - keeping last ${keepCount} of ${history.length} messages`
+    );
     return {
       toSummarize: history.slice(0, -keepCount),
       toKeep: history.slice(-keepCount)
@@ -124,21 +235,36 @@ class ReactiveOverflowStrategy {
   }
   /**
    * Generate an LLM summary of the messages.
+   *
+   * @param messages Messages to summarize
+   * @param currentTask The most recent user message (current task context)
    */
-  async generateSummary(messages) {
+  async generateSummary(messages, currentTask) {
     const formattedConversation = this.formatMessagesForSummary(messages);
-    const prompt = this.options.summaryPrompt.replace("{conversation}", formattedConversation);
+    let conversationWithContext = formattedConversation;
+    if (currentTask) {
+      conversationWithContext += `
+
+--- CURRENT TASK (most recent user request) ---
+${currentTask}`;
+    }
+    const prompt = this.options.summaryPrompt.replace(
+      "{conversation}",
+      conversationWithContext
+    );
     try {
       const result = await (0, import_ai.generateText)({
         model: this.model,
         prompt,
         maxOutputTokens: this.options.maxSummaryTokens
       });
-      return `[Previous conversation summary]
+      return `[Session Compaction Summary]
 ${result.text}`;
     } catch (error) {
-      this.logger.error("ReactiveOverflowStrategy: Failed to generate summary", { error });
-      return this.createFallbackSummary(messages);
+      this.logger.error(
+        `ReactiveOverflowStrategy: Failed to generate summary - ${error instanceof Error ? error.message : String(error)}`
+      );
+      return this.createFallbackSummary(messages, currentTask);
     }
   }
   /**
@@ -174,7 +300,7 @@ ${result.text}`;
   /**
    * Create a fallback summary if LLM call fails.
    */
-  createFallbackSummary(messages) {
+  createFallbackSummary(messages, currentTask) {
     const userMessages = messages.filter((m) => m.role === "user");
     const assistantWithTools = messages.filter(
       (m) => (0, import_types.isAssistantMessage)(m) && !!m.toolCalls && m.toolCalls.length > 0
@@ -190,9 +316,25 @@ ${result.text}`;
         assistantWithTools.flatMap((m) => m.toolCalls.map((tc) => tc.function.name))
       )
     ].join(", ");
-    return `[Previous conversation summary - fallback]
-User discussed: ${userTopics || "various topics"}
-Tools used: ${toolsUsed || "none"}`;
+    let fallback = `[Session Compaction Summary - Fallback]
+<session_compaction>
+  <conversation_history>
+    User discussed: ${userTopics || "various topics"}
+    Tools used: ${toolsUsed || "none"}
+    Messages summarized: ${messages.length}
+  </conversation_history>`;
+    if (currentTask) {
+      fallback += `
+  <current_task>
+    ${currentTask.slice(0, 500)}${currentTask.length > 500 ? "..." : ""}
+  </current_task>`;
+    }
+    fallback += `
+  <important_context>
+    Note: This is a fallback summary due to LLM error. Context may be incomplete.
+  </important_context>
+</session_compaction>`;
+    return fallback;
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/context/compaction/strategies/reactive-overflow.d.ts

@@ -60,13 +60,35 @@ export declare class ReactiveOverflowStrategy implements ICompactionStrategy {
      * @returns Array with single summary message to add, or empty if nothing to summarize
      */
     compact(history: readonly InternalMessage[]): Promise<InternalMessage[]>;
+    /**
+     * Handle re-compaction when there's already a summary in history.
+     * Only summarizes messages AFTER the existing summary, preventing
+     * cascading summaries of summaries.
+     *
+     * @param messagesAfterSummary Messages after the existing summary
+     * @param fullHistory The complete history (for current task detection)
+     * @param existingSummaryIndex Index of the existing summary in fullHistory
+     * @returns Array with single summary message, or empty if nothing to summarize
+     */
+    private compactSubset;
+    /**
+     * Find the most recent user message that represents the current task.
+     * This helps preserve context about what the user is currently asking for.
+     */
+    private findCurrentTaskMessage;
     /**
      * Split history into messages to summarize and messages to keep.
      * Keeps the last N turns (user + assistant pairs) intact.
+     *
+     * For long agentic conversations with many tool calls, this also ensures
+     * we don't try to keep too many messages even within preserved turns.
      */
     private splitHistory;
     /**
      * Generate an LLM summary of the messages.
+     *
+     * @param messages Messages to summarize
+     * @param currentTask The most recent user message (current task context)
      */
     private generateSummary;
     /**

package/dist/context/compaction/strategies/reactive-overflow.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reactive-overflow.d.ts","sourceRoot":"","sources":["../../../../src/context/compaction/strategies/reactive-overflow.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,KAAK,aAAa,EAAE,MAAM,IAAI,CAAC;AACtD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AACvD,OAAO,KAAK,EAAE,eAAe,EAAY,MAAM,gBAAgB,CAAC;AAEhE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEhE;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACpC;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAE5B;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CAC1B;AAiBD;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,wBAAyB,YAAW,mBAAmB;IAChE,QAAQ,CAAC,IAAI,uBAAuB;IAEpC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgB;IACtC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoC;IAC5D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;gBAE1B,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,uBAAuB,YAAK,EAAE,MAAM,EAAE,YAAY;IAM7F;;;;;;;;;;OAUG;IACG,OAAO,CAAC,OAAO,EAAE,SAAS,eAAe,EAAE,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IA0C9E;;;OAGG;IACH,OAAO,CAAC,YAAY;IA2CpB;;OAEG;YACW,eAAe;IAmB7B;;OAEG;IACH,OAAO,CAAC,wBAAwB;IA2ChC;;OAEG;IACH,OAAO,CAAC,qBAAqB;CAiChC"}
+{"version":3,"file":"reactive-overflow.d.ts","sourceRoot":"","sources":["../../../../src/context/compaction/strategies/reactive-overflow.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,KAAK,aAAa,EAAE,MAAM,IAAI,CAAC;AACtD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AACvD,OAAO,KAAK,EAAE,eAAe,EAAY,MAAM,gBAAgB,CAAC;AAEhE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEhE;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACpC;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAE5B;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CAC1B;AAsCD;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,wBAAyB,YAAW,mBAAmB;IAChE,QAAQ,CAAC,IAAI,uBAAuB;IAEpC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgB;IACtC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoC;IAC5D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;gBAE1B,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,uBAAuB,YAAK,EAAE,MAAM,EAAE,YAAY;IAM7F;;;;;;;;;;OAUG;IACG,OAAO,CAAC,OAAO,EAAE,SAAS,eAAe,EAAE,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IAiF9E;;;;;;;;;OASG;YACW,aAAa;IAkD3B;;;OAGG;IACH,OAAO,CAAC,sBAAsB;IAuB9B;;;;;;OAMG;IACH,OAAO,CAAC,YAAY;IAwDpB;;;;;OAKG;YACW,eAAe;IAmC7B;;OAEG;IACH,OAAO,CAAC,wBAAwB;IA2ChC;;OAEG;IACH,OAAO,CAAC,qBAAqB;CA0DhC"}

package/dist/context/compaction/strategies/reactive-overflow.js

@@ -4,15 +4,36 @@ import { isAssistantMessage, isToolMessage } from "../../types.js";
 const DEFAULT_OPTIONS = {
   preserveLastNTurns: 2,
   maxSummaryTokens: 2e3,
-  summaryPrompt: `You are a conversation summarizer. Summarize the following conversation history concisely, focusing on:
-- What tasks were attempted and their outcomes
-- Current state and context the assistant needs to remember
-- Any important decisions or information discovered
-- What the user was trying to accomplish
+  summaryPrompt: `You are a conversation summarizer creating a structured summary for session continuation.
 
-Be concise but preserve essential context. Output only the summary, no preamble.
+Analyze the conversation and produce a summary in the following XML format:
 
-Conversation:
+<session_compaction>
+  <conversation_history>
+    A concise summary of what happened in the conversation:
+    - Tasks attempted and their outcomes (success/failure/in-progress)
+    - Important decisions made
+    - Key information discovered (file paths, configurations, errors encountered)
+    - Tools used and their results
+  </conversation_history>
+
+  <current_task>
+    The most recent task or instruction the user requested that may still be in progress.
+    Be specific - include the exact request and current status.
+  </current_task>
+
+  <important_context>
+    Critical state that must be preserved:
+    - File paths being worked on
+    - Variable values or configurations
+    - Error messages that need addressing
+    - Any pending actions or next steps
+  </important_context>
+</session_compaction>
+
+IMPORTANT: The assistant will continue working based on this summary. Ensure the current_task section clearly states what needs to be done next.
+
+Conversation to summarize:
 {conversation}`
 };
 class ReactiveOverflowStrategy {
@@ -41,15 +62,73 @@ class ReactiveOverflowStrategy {
       this.logger.debug("ReactiveOverflowStrategy: History too short, skipping compaction");
       return [];
     }
+    let existingSummaryIndex = -1;
+    for (let i = history.length - 1; i >= 0; i--) {
+      const msg = history[i];
+      if (msg?.metadata?.isSummary === true || msg?.metadata?.isSessionSummary === true) {
+        existingSummaryIndex = i;
+        break;
+      }
+    }
+    if (existingSummaryIndex !== -1) {
+      const messagesAfterSummary = history.slice(existingSummaryIndex + 1);
+      if (messagesAfterSummary.length <= 4) {
+        this.logger.debug(
+          `ReactiveOverflowStrategy: Only ${messagesAfterSummary.length} messages after existing summary, skipping re-compaction`
+        );
+        return [];
+      }
+      this.logger.info(
+        `ReactiveOverflowStrategy: Found existing summary at index ${existingSummaryIndex}, working with ${messagesAfterSummary.length} messages after it`
+      );
+      return this.compactSubset(messagesAfterSummary, history, existingSummaryIndex);
+    }
     const { toSummarize, toKeep } = this.splitHistory(history);
     if (toSummarize.length === 0) {
       this.logger.debug("ReactiveOverflowStrategy: No messages to summarize");
       return [];
     }
+    const currentTaskMessage = this.findCurrentTaskMessage(history);
     this.logger.info(
       `ReactiveOverflowStrategy: Summarizing ${toSummarize.length} messages, keeping ${toKeep.length}`
     );
-    const summary = await this.generateSummary(toSummarize);
+    const summary = await this.generateSummary(toSummarize, currentTaskMessage);
+    const summaryMessage = {
+      role: "assistant",
+      content: [{ type: "text", text: summary }],
+      timestamp: Date.now(),
+      metadata: {
+        isSummary: true,
+        summarizedAt: Date.now(),
+        originalMessageCount: toSummarize.length,
+        originalFirstTimestamp: toSummarize[0]?.timestamp,
+        originalLastTimestamp: toSummarize[toSummarize.length - 1]?.timestamp
+      }
+    };
+    return [summaryMessage];
+  }
+  /**
+   * Handle re-compaction when there's already a summary in history.
+   * Only summarizes messages AFTER the existing summary, preventing
+   * cascading summaries of summaries.
+   *
+   * @param messagesAfterSummary Messages after the existing summary
+   * @param fullHistory The complete history (for current task detection)
+   * @param existingSummaryIndex Index of the existing summary in fullHistory
+   * @returns Array with single summary message, or empty if nothing to summarize
+   */
+  async compactSubset(messagesAfterSummary, fullHistory, existingSummaryIndex) {
+    const { toSummarize, toKeep } = this.splitHistory(messagesAfterSummary);
+    if (toSummarize.length === 0) {
+      this.logger.debug("ReactiveOverflowStrategy: No messages to summarize in subset");
+      return [];
+    }
+    const currentTaskMessage = this.findCurrentTaskMessage(fullHistory);
+    this.logger.info(
+      `ReactiveOverflowStrategy (re-compact): Summarizing ${toSummarize.length} messages after existing summary, keeping ${toKeep.length}`
+    );
+    const summary = await this.generateSummary(toSummarize, currentTaskMessage);
+    const absoluteOriginalMessageCount = existingSummaryIndex + 1 + toSummarize.length;
     const summaryMessage = {
       role: "assistant",
       content: [{ type: "text", text: summary }],
@@ -57,16 +136,43 @@ class ReactiveOverflowStrategy {
       metadata: {
         isSummary: true,
         summarizedAt: Date.now(),
-        summarizedMessageCount: toSummarize.length,
+        originalMessageCount: absoluteOriginalMessageCount,
+        isRecompaction: true,
+        // Mark that this is a re-compaction
         originalFirstTimestamp: toSummarize[0]?.timestamp,
         originalLastTimestamp: toSummarize[toSummarize.length - 1]?.timestamp
       }
     };
     return [summaryMessage];
   }
+  /**
+   * Find the most recent user message that represents the current task.
+   * This helps preserve context about what the user is currently asking for.
+   */
+  findCurrentTaskMessage(history) {
+    for (let i = history.length - 1; i >= 0; i--) {
+      const msg = history[i];
+      if (msg?.role === "user") {
+        if (typeof msg.content === "string") {
+          return msg.content;
+        } else if (Array.isArray(msg.content)) {
+          const textParts = msg.content.filter(
+            (part) => part.type === "text"
+          ).map((part) => part.text).join("\n");
+          if (textParts.length > 0) {
+            return textParts;
+          }
+        }
+      }
+    }
+    return null;
+  }
   /**
    * Split history into messages to summarize and messages to keep.
    * Keeps the last N turns (user + assistant pairs) intact.
+   *
+   * For long agentic conversations with many tool calls, this also ensures
+   * we don't try to keep too many messages even within preserved turns.
    */
   splitHistory(history) {
     const turnsToKeep = this.options.preserveLastNTurns;
@@ -81,20 +187,25 @@ class ReactiveOverflowStrategy {
     }
     if (userMessageIndices.length > 0) {
       const splitIndex = userMessageIndices[0];
-      if (splitIndex !== void 0) {
-        if (splitIndex === 0) {
-          return {
-            toSummarize: [],
-            toKeep: history
-          };
-        }
+      if (splitIndex !== void 0 && splitIndex > 0) {
         return {
           toSummarize: history.slice(0, splitIndex),
           toKeep: history.slice(splitIndex)
         };
       }
     }
-    const keepCount = Math.min(4, history.length);
+    const minKeep = 3;
+    const maxKeepPercent = 0.2;
+    const keepCount = Math.max(minKeep, Math.floor(history.length * maxKeepPercent));
+    if (keepCount >= history.length) {
+      return {
+        toSummarize: [],
+        toKeep: history
+      };
+    }
+    this.logger.debug(
+      `splitHistory: Using fallback - keeping last ${keepCount} of ${history.length} messages`
+    );
     return {
       toSummarize: history.slice(0, -keepCount),
       toKeep: history.slice(-keepCount)
@@ -102,21 +213,36 @@ class ReactiveOverflowStrategy {
   }
   /**
    * Generate an LLM summary of the messages.
+   *
+   * @param messages Messages to summarize
+   * @param currentTask The most recent user message (current task context)
    */
-  async generateSummary(messages) {
+  async generateSummary(messages, currentTask) {
     const formattedConversation = this.formatMessagesForSummary(messages);
-    const prompt = this.options.summaryPrompt.replace("{conversation}", formattedConversation);
+    let conversationWithContext = formattedConversation;
+    if (currentTask) {
+      conversationWithContext += `
+
+--- CURRENT TASK (most recent user request) ---
+${currentTask}`;
+    }
+    const prompt = this.options.summaryPrompt.replace(
+      "{conversation}",
+      conversationWithContext
+    );
     try {
       const result = await generateText({
         model: this.model,
         prompt,
         maxOutputTokens: this.options.maxSummaryTokens
       });
-      return `[Previous conversation summary]
+      return `[Session Compaction Summary]
 ${result.text}`;
     } catch (error) {
-      this.logger.error("ReactiveOverflowStrategy: Failed to generate summary", { error });
-      return this.createFallbackSummary(messages);
+      this.logger.error(
+        `ReactiveOverflowStrategy: Failed to generate summary - ${error instanceof Error ? error.message : String(error)}`
+      );
+      return this.createFallbackSummary(messages, currentTask);
     }
   }
   /**
@@ -152,7 +278,7 @@ ${result.text}`;
   /**
    * Create a fallback summary if LLM call fails.
    */
-  createFallbackSummary(messages) {
+  createFallbackSummary(messages, currentTask) {
     const userMessages = messages.filter((m) => m.role === "user");
     const assistantWithTools = messages.filter(
       (m) => isAssistantMessage(m) && !!m.toolCalls && m.toolCalls.length > 0
@@ -168,9 +294,25 @@ ${result.text}`;
         assistantWithTools.flatMap((m) => m.toolCalls.map((tc) => tc.function.name))
       )
     ].join(", ");
-    return `[Previous conversation summary - fallback]
-User discussed: ${userTopics || "various topics"}
-Tools used: ${toolsUsed || "none"}`;
+    let fallback = `[Session Compaction Summary - Fallback]
+<session_compaction>
+  <conversation_history>
+    User discussed: ${userTopics || "various topics"}
+    Tools used: ${toolsUsed || "none"}
+    Messages summarized: ${messages.length}
+  </conversation_history>`;
+    if (currentTask) {
+      fallback += `
+  <current_task>
+    ${currentTask.slice(0, 500)}${currentTask.length > 500 ? "..." : ""}
+  </current_task>`;
+    }
+    fallback += `
+  <important_context>
+    Note: This is a fallback summary due to LLM error. Context may be incomplete.
+  </important_context>
+</session_compaction>`;
+    return fallback;
   }
 }
 export {

package/dist/context/compaction/types.d.ts

@@ -12,8 +12,20 @@ export interface ICompactionStrategy {
     /**
      * Compacts the provided message history.
      *
+     * The returned summary messages MUST include specific metadata fields for
+     * `filterCompacted()` to correctly exclude pre-summary messages at read-time:
+     *
+     * Required metadata:
+     * - `isSummary: true` - Marks the message as a compaction summary
+     * - `originalMessageCount: number` - Count of messages that were summarized
+     *   (used by filterCompacted to determine which messages to exclude)
+     *
+     * Optional metadata:
+     * - `isRecompaction: true` - Set when re-compacting after a previous summary
+     * - `isSessionSummary: true` - Alternative to isSummary for session-level summaries
+     *
      * @param history The current conversation history.
-     * @returns Summary messages to add to history (filterCompacted handles the rest).
+     * @returns Summary messages to add to history. Empty array if nothing to compact.
      */
     compact(history: readonly InternalMessage[]): Promise<InternalMessage[]> | InternalMessage[];
 }

package/dist/context/compaction/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/context/compaction/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C;;;;;;GAMG;AACH,MAAM,WAAW,mBAAmB;IAChC,yCAAyC;IACzC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB;;;;;OAKG;IACH,OAAO,CAAC,OAAO,EAAE,SAAS,eAAe,EAAE,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,GAAG,eAAe,EAAE,CAAC;CAChG"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/context/compaction/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C;;;;;;GAMG;AACH,MAAM,WAAW,mBAAmB;IAChC,yCAAyC;IACzC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CAAC,OAAO,EAAE,SAAS,eAAe,EAAE,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,GAAG,eAAe,EAAE,CAAC;CAChG"}