@cuylabs/agent-core 4.10.0 → 5.0.1

package/dist/index.js

@@ -39,7 +39,7 @@ import {
   parseSubAgentRoleFrontmatter,
   parseSubAgentToolSpec,
   toSubAgentRole
-} from "./chunk-V4YQ6MBK.js";
+} from "./chunk-BKHWKKSG.js";
 import {
   InMemoryMailboxStore,
   InMemoryTaskBoardStore,
@@ -73,9 +73,9 @@ import {
   createMemoryMiddleware,
   formatMemoryContextFragment,
   normalizeMemoryRecords,
-  resolveAgentMemoryConfig,
-  resolveAgentMemoryTurnConfig
-} from "./chunk-EEAGM5MS.js";
+  resolveAgentMemoryCaptureConfig,
+  resolveAgentMemoryConfig
+} from "./chunk-DD7S7ZG4.js";
 import {
   MiddlewareRunner,
   approvalMiddleware,
@@ -83,7 +83,7 @@ import {
   isApprovalMiddleware,
   otelMiddleware,
   promptCacheMiddleware
-} from "./chunk-TU5KDFWI.js";
+} from "./chunk-GHVW7L4P.js";
 import {
   LayeredSettings,
   NullSettings,
@@ -157,7 +157,7 @@ import {
 import "./chunk-VOUEJSW6.js";
 import {
   assembleModelContext
-} from "./chunk-IQA64CAO.js";
+} from "./chunk-TYQWH6XH.js";
 import {
   createCompositeDispatchTaskExecutor,
   createDispatchExternalTaskControl,
@@ -179,12 +179,11 @@ import {
   ensureSessionLoaded,
   getVisibleSessionMessages,
   repairOrphanedToolCalls
-} from "./chunk-EBVSPHXA.js";
+} from "./chunk-556CPZ3J.js";
 import {
-  FileStorage,
+  InMemorySessionStore,
   LocalSessionTurnLock,
-  MemoryStorage,
-  STORAGE_VERSION,
+  SESSION_FORMAT_VERSION,
   SessionManager,
   buildEntryPath,
   buildMessagesFromEntries,
@@ -196,18 +195,13 @@ import {
   deserializeMessage,
   extractSessionInfo,
   generateEntryId,
-  getDataDir,
   getDefaultSessionManager,
-  getGitRootHash,
   getLeafId,
-  getProjectId,
-  getProjectSessionsDir,
-  getSessionsDir,
   parseJSONL,
   serializeMessage,
   toJSONL,
   toJSONLBatch
-} from "./chunk-VMGZKIFT.js";
+} from "./chunk-EDKZOPUV.js";
 import {
   sleep
 } from "./chunk-SZ2XBPTW.js";
@@ -241,7 +235,7 @@ import {
   processStepStream,
   runModelStep,
   runToolBatch
-} from "./chunk-LX4AHGI3.js";
+} from "./chunk-346FIYKT.js";
 import {
   applyAgentWorkflowCommitResult,
   applyAgentWorkflowContextCompactionResult,
@@ -277,6 +271,7 @@ import {
   DEFAULT_CONTEXT_LIMITS,
   DEFAULT_SUMMARY_MAX_INPUT_TOKENS,
   DEFAULT_SUMMARY_MAX_OUTPUT_TOKENS,
+  DEFAULT_TOOL_CONTEXT_PRUNE_POLICY,
   PRUNE_PROTECTED_TOOLS,
   canGenerateCompactionSummary,
   createCompactionEffectiveness,
@@ -285,6 +280,8 @@ import {
   extractCompactionSummaryText,
   generateSplitTurnSummary,
   generateSummary,
+  getAutoCompactTokenLimit,
+  getEffectiveContextWindow,
   getUsableTokenLimit,
   isContextOverflowing,
   planCompactionCut,
@@ -297,7 +294,7 @@ import {
   serializeMessagesForSummary,
   shouldFallbackOnSummaryFailure,
   shouldPruneContext
-} from "./chunk-NMJNN6LS.js";
+} from "./chunk-DYZGHHDB.js";
 import {
   AGENT_CONTEXT_FRAGMENT_CLOSE,
   AGENT_CONTEXT_FRAGMENT_OPEN,
@@ -314,7 +311,7 @@ import {
   normalizeAgentContextFragment,
   parseRenderedAgentContextFragment,
   renderAgentContextFragment
-} from "./chunk-AAGKWUXR.js";
+} from "./chunk-CGP6UNCQ.js";
 import {
   DEFAULT_MAX_OUTPUT_TOKENS,
   DEFAULT_MAX_STEPS,
@@ -1046,6 +1043,7 @@ function createEffectiveAgentConfig(config) {
   };
 }
 function resolveAgentContextLimits(contextWindow, compactionConfig = {}) {
+  const effectiveContextWindowPercent = compactionConfig.effectiveContextWindowPercent ?? DEFAULT_CONTEXT_LIMITS.effectiveContextWindowPercent;
   const proportionalReserve = Math.round(contextWindow * 0.12);
   const reserveTokens = contextWindow >= 64e3 ? Math.min(32e3, Math.max(8e3, proportionalReserve)) : Math.min(
     Math.max(1024, Math.round(contextWindow * 0.25)),
@@ -1053,11 +1051,17 @@ function resolveAgentContextLimits(contextWindow, compactionConfig = {}) {
   );
   const usableWindow = Math.max(
     512,
-    getUsableTokenLimit({ contextWindow, reserveTokens })
+    getUsableTokenLimit({
+      contextWindow,
+      reserveTokens,
+      effectiveContextWindowPercent
+    })
   );
   const requestedProtected = compactionConfig.protectedTokens ?? DEFAULT_CONTEXT_LIMITS.protectedTokens;
   const requestedPruneMinimum = compactionConfig.pruneMinimum ?? DEFAULT_CONTEXT_LIMITS.pruneMinimum;
   return {
+    ...effectiveContextWindowPercent !== void 0 ? { effectiveContextWindowPercent } : {},
+    ...compactionConfig.autoCompactTokenLimit !== void 0 ? { autoCompactTokenLimit: compactionConfig.autoCompactTokenLimit } : {},
     reserveTokens,
     protectedTokens: Math.min(
       requestedProtected,
@@ -1089,7 +1093,12 @@ function createAgentContextWindowManager(config) {
       maxInputTokens: compactionConfig.summaryMaxInputTokens,
       maxOutputTokens: compactionConfig.summaryMaxOutputTokens,
       targetRatio: compactionConfig.summaryTargetRatio
-    }
+    },
+    toolPruning: {
+      enabled: compactionConfig.prune ?? true,
+      policy: compactionConfig.toolPruning
+    },
+    tokenEstimator: config.context?.tokenEstimator
   });
 }
 
@@ -1491,7 +1500,7 @@ function createMiddlewareSetup(input, config) {
       createMemoryMiddleware({
         provider: memory.provider,
         recall: memory.recall,
-        turns: memory.turns,
+        capture: memory.capture,
         cwd: config.cwd
       })
     );
@@ -1569,7 +1578,7 @@ function createAgentSetup(input) {
   return {
     config,
     tools: toolSetup.tools,
-    sessions: input.sessionManager ?? getDefaultSessionManager(),
+    sessions: input.sessionManager ?? (input.sessionStore ? new SessionManager(input.sessionStore) : getDefaultSessionManager()),
     sessionTurnLock: input.sessionTurnLock ?? new LocalSessionTurnLock(),
     state: createAgentState(config),
     contextManager: createAgentContextWindowManager(config),
@@ -1589,27 +1598,27 @@ function createAgentSetup(input) {
 }
 
 // src/agent/turn-context/compaction/budget.ts
-function normalizeTransientContextTokens(value) {
+function normalizeContextFragmentTokens(value) {
   if (!Number.isFinite(value) || value === void 0 || value <= 0) return 0;
   return Math.floor(value);
 }
-function reserveTransientContextBudget(limits, transientContextTokens) {
-  if (transientContextTokens <= 0) return limits;
+function reserveContextFragmentBudget(limits, contextFragmentTokens) {
+  if (contextFragmentTokens <= 0) return limits;
   const usableLimit = getUsableTokenLimit(limits);
-  const transientUsableLimit = Math.max(
+  const fragmentAdjustedUsableLimit = Math.max(
     1,
-    usableLimit - transientContextTokens
+    usableLimit - contextFragmentTokens
   );
   return {
     ...limits,
-    contextWindow: transientUsableLimit + limits.reserveTokens,
+    contextWindow: fragmentAdjustedUsableLimit + limits.reserveTokens,
     protectedTokens: Math.min(
       limits.protectedTokens,
-      Math.max(1, Math.round(transientUsableLimit * 0.6))
+      Math.max(1, Math.round(fragmentAdjustedUsableLimit * 0.6))
     ),
     pruneMinimum: Math.min(
       limits.pruneMinimum,
-      Math.max(1, Math.round(transientUsableLimit * 0.5))
+      Math.max(1, Math.round(fragmentAdjustedUsableLimit * 0.5))
     )
   };
 }
@@ -1650,18 +1659,19 @@ function collectDurableContextFragments(removedMessages, keptMessages) {
 }
 
 // src/agent/turn-context/compaction/memory.ts
-async function prepareMemoryForCompaction(options) {
-  if (!options.provider?.prepareForCompaction) return;
+async function captureMemoryBeforeCompactionCommit(options) {
+  if (!options.provider?.captureBeforeCompactionCommit) return;
   if (options.removedMessages.length === 0) return;
   try {
-    await options.provider.prepareForCompaction({
+    await options.provider.captureBeforeCompactionCommit({
       sessionId: options.sessionId ?? "unknown",
       ...options.turnId ? { turnId: options.turnId } : {},
       cwd: options.cwd ?? process.cwd(),
       ...options.phase ? { phase: options.phase } : {},
       removedMessages: options.removedMessages,
-      keptMessages: options.keptMessages,
-      ...options.summary ? { summary: options.summary } : {},
+      recentKeptMessages: options.recentKeptMessages,
+      ...options.previousSummary !== void 0 ? { previousSummary: options.previousSummary } : {},
+      ...options.nextSummary !== void 0 ? { nextSummary: options.nextSummary } : {},
       ...options.abort ? { abort: options.abort } : {}
     });
   } catch (error) {
@@ -1679,6 +1689,8 @@ function createUnchangedCompactionResult(options) {
     messages: [...options.messages],
     persistedMessages: [...options.messages],
     decision: options.decision,
+    trigger: options.trigger,
+    reason: options.reason,
     effectiveness: createCompactionEffectiveness(
       options.tokensBefore,
       options.tokensBefore
@@ -1698,12 +1710,17 @@ function createUnchangedCompactionResult(options) {
 }
 function createToolContextCompactionResult(options) {
   const { messages, tokensBefore } = options;
-  const tokensAfter = estimateConversationTokens(messages);
+  const tokensAfter = estimateConversationTokens(
+    messages,
+    options.tokenEstimator
+  );
   return {
     compacted: true,
     messages,
     persistedMessages: messages,
     decision: options.decision,
+    trigger: options.trigger,
+    reason: options.reason,
     effectiveness: createCompactionEffectiveness(tokensBefore, tokensAfter),
     displaySummary: false,
     storageSummary: "Large historical tool context was compacted.",
@@ -1731,32 +1748,41 @@ function buildFallbackCompactionSummary(messages) {
 // src/agent/turn-context/compaction/agent-context.ts
 async function compactAgentMessages(options) {
   const { contextManager, messages, logger, force = false } = options;
+  const trigger = options.trigger ?? (options.phase === "manual" ? "manual" : force ? "recovery" : "auto");
+  const reason = options.reason ?? (trigger === "manual" ? "manual-request" : force ? "provider-overflow" : "context-limit");
   const log = logger ?? silentLogger;
   const visibleMessages = [...messages];
+  let previousSummary = findLatestCompactionSummary(visibleMessages);
   const baseLimits = contextManager.getLimits();
-  const transientContextTokens = normalizeTransientContextTokens(
-    options.transientContextTokens
+  const contextFragmentTokens = normalizeContextFragmentTokens(
+    options.contextFragmentTokens
   );
-  const compactionLimits = reserveTransientContextBudget(
+  const tokenEstimator = contextManager.getTokenEstimator();
+  const compactionLimits = reserveContextFragmentBudget(
     baseLimits,
-    transientContextTokens
+    contextFragmentTokens
   );
-  const limit = getUsableTokenLimit(compactionLimits);
-  const tokensBefore = estimateConversationTokens(visibleMessages);
+  const limit = getAutoCompactTokenLimit(compactionLimits);
+  const tokensBefore = contextManager.estimateTokens(visibleMessages);
   const summaryPolicy = contextManager.getSummaryPolicy();
   const canSummarize = canGenerateCompactionSummary(summaryPolicy);
   const initialDecision = decideContextCompaction(visibleMessages, {
     limits: baseLimits,
     force,
     canSummarize,
-    inputTokens: tokensBefore + transientContextTokens
+    inputTokens: tokensBefore + contextFragmentTokens,
+    trigger,
+    reason,
+    tokenEstimator
   });
   if (!force && !initialDecision.needed) {
     return createUnchangedCompactionResult({
       messages: visibleMessages,
       decision: initialDecision,
+      trigger,
+      reason,
       tokensBefore,
-      limit: getUsableTokenLimit(baseLimits)
+      limit: getAutoCompactTokenLimit(baseLimits)
     });
   }
   let removedCount = 0;
@@ -1771,25 +1797,30 @@ async function compactAgentMessages(options) {
   let fallbackRemovedMessages;
   let fallbackKeptMessages;
   try {
-    const result = await pruneContext(visibleMessages, {
+    const result2 = await pruneContext(visibleMessages, {
       limits: compactionLimits,
       summary: summaryPolicy,
-      force
+      force,
+      toolPruning: contextManager.getToolPruning(),
+      trigger,
+      reason,
+      tokenEstimator
     });
-    removedCount = result.removedCount;
-    pruneTokensRemoved = result.effectiveness.tokensRemoved;
-    summarized = result.summarized;
-    summary = result.summary;
-    cutIndex = result.cutIndex;
-    cutReason = result.cutReason;
-    prunedMessages = result.messages;
-    fallbackRemovedMessages = result.removedMessages;
+    removedCount = result2.removedCount;
+    pruneTokensRemoved = result2.effectiveness.tokensRemoved;
+    summarized = result2.summarized;
+    summary = result2.summary;
+    previousSummary ??= result2.previousSummary;
+    cutIndex = result2.cutIndex;
+    cutReason = result2.cutReason;
+    prunedMessages = result2.messages;
+    fallbackRemovedMessages = result2.removedMessages;
     if (removedCount > 0) {
       keptMessagesFromPrune = stripSummaryPreviewMessage(
-        result.messages,
+        result2.messages,
         summary
       );
-      fallbackKeptMessages = result.keptMessages;
+      fallbackKeptMessages = result2.keptMessages;
     }
   } catch (pruneError) {
     if (!shouldFallbackOnSummaryFailure({ policy: summaryPolicy, force })) {
@@ -1801,13 +1832,17 @@ async function compactAgentMessages(options) {
   }
   if (removedCount === 0 && prunedMessages && pruneTokensRemoved > 0 && !decideContextCompaction(prunedMessages, {
     limits: compactionLimits,
-    canSummarize
+    canSummarize,
+    tokenEstimator
   }).needed) {
     return createToolContextCompactionResult({
       messages: prunedMessages,
       decision,
+      trigger,
+      reason,
       tokensBefore,
-      limit
+      limit,
+      tokenEstimator
     });
   }
   if (removedCount === 0) {
@@ -1817,7 +1852,8 @@ async function compactAgentMessages(options) {
       compactionLimits.protectedTokens,
       {
         allowSplitTurn: summaryPolicy.mode !== "disabled",
-        maxKeptTokens: getUsableTokenLimit(compactionLimits)
+        maxKeptTokens: getUsableTokenLimit(compactionLimits),
+        tokenEstimator
       }
     );
     removedCount = fallbackPlan.cutIndex;
@@ -1831,13 +1867,18 @@ async function compactAgentMessages(options) {
       return createToolContextCompactionResult({
         messages: prunedMessages,
         decision,
+        trigger,
+        reason,
         tokensBefore,
-        limit
+        limit,
+        tokenEstimator
       });
     }
     return createUnchangedCompactionResult({
       messages: visibleMessages,
       decision,
+      trigger,
+      reason,
       tokensBefore,
       limit,
       cutIndex,
@@ -1852,22 +1893,15 @@ async function compactAgentMessages(options) {
   );
   if (summaryPolicy.mode === "disabled" && !summary) {
     const persistedMessages2 = [...preservedContextFragments, ...keptMessages];
-    const tokensAfter2 = estimateConversationTokens(persistedMessages2);
-    await prepareMemoryForCompaction({
-      provider: options.memoryProvider,
-      sessionId: options.sessionId,
-      turnId: options.turnId,
-      cwd: options.cwd,
-      abort: options.abort,
-      phase: options.phase,
-      removedMessages,
-      keptMessages,
-      logger: log
-    });
-    return {
+    const tokensAfter2 = contextManager.estimateTokens(persistedMessages2);
+    const result2 = {
       compacted: true,
+      trigger,
+      reason,
       messages: persistedMessages2,
       persistedMessages: persistedMessages2,
+      removedMessages,
+      keptMessages,
       decision,
       effectiveness: createCompactionEffectiveness(tokensBefore, tokensAfter2),
       displaySummary: false,
@@ -1876,12 +1910,22 @@ async function compactAgentMessages(options) {
       tokensRemoved: Math.max(0, tokensBefore - tokensAfter2),
       summarized: false,
       summary: void 0,
+      ...previousSummary !== void 0 ? { previousSummary } : {},
       cutIndex,
       cutReason,
       tokensBefore,
       tokensAfter: tokensAfter2,
       limit
     };
+    await runBeforeContextCompactionCommitHooks({
+      result: result2,
+      removedMessages,
+      keptMessages,
+      options,
+      inputTokens: tokensBefore + contextFragmentTokens,
+      log
+    });
+    return result2;
   }
   const summaryText = summary ?? buildFallbackCompactionSummary(removedMessages);
   const persistedMessages = [...preservedContextFragments, ...keptMessages];
@@ -1896,23 +1940,15 @@ async function compactAgentMessages(options) {
     ...preservedContextFragments,
     ...keptMessages
   ];
-  const tokensAfter = estimateConversationTokens(messagesWithSummary);
-  await prepareMemoryForCompaction({
-    provider: options.memoryProvider,
-    sessionId: options.sessionId,
-    turnId: options.turnId,
-    cwd: options.cwd,
-    abort: options.abort,
-    phase: options.phase,
-    removedMessages,
-    keptMessages,
-    summary: summaryText,
-    logger: log
-  });
-  return {
+  const tokensAfter = contextManager.estimateTokens(messagesWithSummary);
+  const result = {
     compacted: true,
+    trigger,
+    reason,
     messages: messagesWithSummary,
     persistedMessages,
+    removedMessages,
+    keptMessages,
     decision,
     effectiveness: createCompactionEffectiveness(tokensBefore, tokensAfter),
     displaySummary: true,
@@ -1921,12 +1957,23 @@ async function compactAgentMessages(options) {
     tokensRemoved: Math.max(0, tokensBefore - tokensAfter),
     summarized,
     summary: summaryText,
+    ...previousSummary !== void 0 ? { previousSummary } : {},
+    nextSummary: summaryText,
     cutIndex,
     cutReason,
     tokensBefore,
     tokensAfter,
     limit
   };
+  await runBeforeContextCompactionCommitHooks({
+    result,
+    removedMessages,
+    keptMessages,
+    options,
+    inputTokens: tokensBefore + contextFragmentTokens,
+    log
+  });
+  return result;
 }
 async function compactAgentContext(options) {
   const result = await compactAgentMessages({
@@ -1935,33 +1982,142 @@ async function compactAgentContext(options) {
     logger: options.logger,
     force: options.force,
     memoryProvider: options.memoryProvider,
+    middlewareRunner: options.middlewareRunner,
     sessionId: options.sessionId ?? options.sessions.getSessionId() ?? void 0,
     turnId: options.turnId,
     cwd: options.cwd ?? options.sessions.getHeader()?.cwd,
     abort: options.abort,
     phase: options.phase,
-    transientContextTokens: options.transientContextTokens
+    trigger: options.trigger,
+    reason: options.reason,
+    contextFragmentTokens: options.contextFragmentTokens
+  });
+  await commitAgentContextCompaction({
+    sessions: options.sessions,
+    result,
+    middlewareRunner: options.middlewareRunner,
+    sessionId: options.sessionId,
+    turnId: options.turnId,
+    cwd: options.cwd,
+    abort: options.abort,
+    phase: options.phase,
+    contextFragmentTokens: options.contextFragmentTokens
   });
-  if (result.compacted) {
-    await options.sessions.replaceWithCompaction({
-      summary: result.storageSummary,
-      displaySummary: result.displaySummary,
-      messages: result.persistedMessages,
-      tokensBefore: result.tokensBefore,
-      tokensAfter: result.tokensAfter
-    });
-  }
   return {
     removedCount: result.removedCount,
     decision: result.decision,
+    trigger: result.trigger,
+    reason: result.reason,
     effectiveness: result.effectiveness,
     tokensRemoved: result.tokensRemoved,
     summarized: result.summarized,
     summary: result.summary,
+    ...result.previousSummary !== void 0 ? { previousSummary: result.previousSummary } : {},
+    ...result.nextSummary !== void 0 ? { nextSummary: result.nextSummary } : {},
     cutIndex: result.cutIndex,
     cutReason: result.cutReason
   };
 }
+async function commitAgentContextCompaction(options) {
+  const { result } = options;
+  if (!result.compacted) {
+    return void 0;
+  }
+  const compactionId = await options.sessions.replaceWithCompaction({
+    summary: result.storageSummary,
+    displaySummary: result.displaySummary,
+    messages: result.persistedMessages,
+    tokensBefore: result.tokensBefore,
+    tokensAfter: result.tokensAfter,
+    ...options.phase ? { phase: options.phase } : {},
+    ...result.trigger ? { trigger: result.trigger } : {},
+    ...result.reason ? { reason: result.reason } : {},
+    ...result.cutReason ? { cutReason: result.cutReason } : {}
+  });
+  await options.middlewareRunner?.runAfterContextCompactionCommit(
+    buildContextCompactionHookContext({
+      result,
+      removedMessages: result.removedMessages ?? [],
+      keptMessages: result.keptMessages ?? result.persistedMessages,
+      sessionId: options.sessionId ?? options.sessions.getSessionId() ?? "unknown",
+      turnId: options.turnId,
+      cwd: options.cwd ?? options.sessions.getHeader()?.cwd ?? process.cwd(),
+      abort: options.abort,
+      phase: options.phase,
+      inputTokens: result.tokensBefore + normalizeContextFragmentTokens(options.contextFragmentTokens)
+    })
+  );
+  return compactionId;
+}
+async function runBeforeContextCompactionCommitHooks(options) {
+  const context = buildContextCompactionHookContext({
+    result: options.result,
+    removedMessages: options.removedMessages,
+    keptMessages: options.keptMessages,
+    sessionId: options.options.sessionId ?? "unknown",
+    turnId: options.options.turnId,
+    cwd: options.options.cwd ?? process.cwd(),
+    abort: options.options.abort,
+    phase: options.options.phase,
+    inputTokens: options.inputTokens
+  });
+  if (options.options.middlewareRunner) {
+    await options.options.middlewareRunner.runBeforeContextCompactionCommit(
+      context
+    );
+    return;
+  }
+  await captureMemoryBeforeCompactionCommit({
+    provider: options.options.memoryProvider,
+    sessionId: context.sessionId,
+    ...context.turnId ? { turnId: context.turnId } : {},
+    cwd: context.cwd,
+    ...context.abort ? { abort: context.abort } : {},
+    ...context.phase ? { phase: context.phase } : {},
+    removedMessages: context.removedMessages,
+    recentKeptMessages: context.keptMessages.slice(-20),
+    ...context.previousSummary !== void 0 ? { previousSummary: context.previousSummary } : {},
+    ...context.nextSummary !== void 0 ? { nextSummary: context.nextSummary } : {},
+    logger: options.log
+  });
+}
+function buildContextCompactionHookContext(options) {
+  return {
+    sessionId: options.sessionId,
+    ...options.turnId ? { turnId: options.turnId } : {},
+    cwd: options.cwd,
+    ...options.phase ? { phase: options.phase } : {},
+    ...options.result.trigger ? { trigger: options.result.trigger } : {},
+    ...options.result.reason ? { reason: options.result.reason } : {},
+    inputTokens: options.inputTokens,
+    limit: options.result.limit,
+    decision: options.result.decision,
+    effectiveness: options.result.effectiveness,
+    removedMessages: options.removedMessages,
+    keptMessages: options.keptMessages,
+    messagesAfter: options.result.messages,
+    persistedMessages: options.result.persistedMessages,
+    removedCount: options.result.removedCount,
+    tokensRemoved: options.result.tokensRemoved,
+    summarized: options.result.summarized,
+    ...options.result.previousSummary !== void 0 ? { previousSummary: options.result.previousSummary } : {},
+    ...options.result.nextSummary !== void 0 ? { nextSummary: options.result.nextSummary } : {},
+    ...options.result.cutIndex !== void 0 ? { cutIndex: options.result.cutIndex } : {},
+    ...options.result.cutReason ? { cutReason: options.result.cutReason } : {},
+    tokensBefore: options.result.tokensBefore,
+    tokensAfter: options.result.tokensAfter,
+    ...options.abort ? { abort: options.abort } : {}
+  };
+}
+function findLatestCompactionSummary(messages) {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const summary = extractCompactionSummaryText(messages[index]);
+    if (summary !== void 0) {
+      return summary;
+    }
+  }
+  return void 0;
+}
 
 // src/agent/turn-context/compaction/check.ts
 async function runCompactionCheck(params) {
@@ -1976,17 +2132,22 @@ async function runCompactionCheck(params) {
     cwd,
     abort,
     memoryProvider,
+    middlewareRunner,
     retryAttempt,
-    transientContextTokens
+    contextFragmentTokens,
+    trigger = phase === "manual" ? "manual" : phase === "recovery" ? "recovery" : "auto",
+    reason = phase === "manual" ? "manual-request" : force ? "provider-overflow" : "context-limit"
   } = params;
   const messages = sessions.getMessages();
   const limits = contextManager.getLimits();
-  const transientTokens = Number.isFinite(transientContextTokens) && transientContextTokens ? Math.max(0, Math.floor(transientContextTokens)) : 0;
-  const inputTokens = estimateConversationTokens(messages) + transientTokens;
-  const limit = getUsableTokenLimit(limits);
+  const fragmentTokens = Number.isFinite(contextFragmentTokens) && contextFragmentTokens ? Math.max(0, Math.floor(contextFragmentTokens)) : 0;
+  const inputTokens = contextManager.estimateTokens(messages) + fragmentTokens;
+  const limit = getAutoCompactTokenLimit(limits);
   const decision = contextManager.decide(messages, {
     force,
-    inputTokens
+    inputTokens,
+    trigger,
+    reason
   });
   if (!force && !decision.needed) {
     return {
@@ -1997,6 +2158,8 @@ async function runCompactionCheck(params) {
       report: {
         applied: false,
         phase,
+        trigger,
+        reason,
         inputTokens,
         limit,
         decision,
@@ -2019,13 +2182,18 @@ async function runCompactionCheck(params) {
       cwd,
       abort,
       memoryProvider,
+      middlewareRunner,
       phase,
-      transientContextTokens: transientTokens
+      trigger,
+      reason,
+      contextFragmentTokens: fragmentTokens
     });
     if (pruneResult.removedCount > 0 || pruneResult.summarized || pruneResult.tokensRemoved > 0) {
       events.push({
         type: "context-compaction",
         phase,
+        trigger,
+        reason,
         inputTokens,
         limit,
         decision: pruneResult.decision,
@@ -2049,6 +2217,8 @@ async function runCompactionCheck(params) {
         report: {
           applied: true,
           phase,
+          trigger,
+          reason,
           inputTokens,
           limit,
           decision: pruneResult.decision,
@@ -2075,6 +2245,8 @@ async function runCompactionCheck(params) {
     report: {
       applied: false,
       phase,
+      trigger,
+      reason,
       inputTokens,
       limit,
       decision,
@@ -2095,7 +2267,7 @@ async function runAutoCompaction(params) {
 
 // src/agent/turn-context/fit-model-context.ts
 function resolveConfiguredFragmentBudget(context) {
-  const maxEstimatedTokens = context?.maxEstimatedFragmentTokens;
+  const maxEstimatedTokens = context?.maxFragmentTokens;
   if (maxEstimatedTokens === void 0 || !Number.isFinite(maxEstimatedTokens)) {
     return void 0;
   }
@@ -2128,7 +2300,7 @@ async function assembleChatModelContextToFit(params) {
     if (!params.fitAssembledContext || attempt > 0 || !windowAfter?.shouldPrune) {
       break;
     }
-    const transientContextTokens = Math.max(
+    const contextFragmentTokens = Math.max(
       0,
       windowAfter.tokens - (windowBefore?.tokens ?? 0)
     );
@@ -2143,7 +2315,8 @@ async function assembleChatModelContextToFit(params) {
       cwd: params.cwd,
       ...params.abort ? { abort: params.abort } : {},
       memoryProvider: params.memoryProvider,
-      transientContextTokens
+      middlewareRunner: params.middlewareRunner,
+      contextFragmentTokens
     });
     events.push(...compaction.events);
     if (!compaction.compacted) {
@@ -2206,7 +2379,7 @@ function createAgentTurnRuntimeConfig(options) {
 
 // src/agent/instance/sessions.ts
 function createAgentSessionManager(sessions) {
-  return new SessionManager(sessions.getStorage());
+  return new SessionManager(sessions.getStore());
 }
 async function acquireAgentSessionLock(lock, sessionId, options) {
   return await lock.acquire(sessionId, options);
@@ -2421,7 +2594,7 @@ function createForkedAgentConfig(options) {
     topP: parentConfig.topP,
     reasoningLevel: forkOptions.reasoningLevel ?? reasoningLevel,
     ...childPrompt,
-    sessionManager: new SessionManager(sessions.getStorage()),
+    sessionManager: new SessionManager(sessions.getStore()),
     tools,
     onDoomLoop: parentConfig.onDoomLoop,
     enforceDoomLoop: parentConfig.enforceDoomLoop,
@@ -2772,6 +2945,7 @@ async function maybeRunRecoveryCompaction(options) {
     cwd: deps.config.cwd,
     abort: deps.abort,
     memoryProvider: deps.memoryProvider,
+    middlewareRunner: deps.middlewareRunner,
     retryAttempt: contextRecoveryAttempts + 1
   });
   for (const event of recoveryCompaction.events) {
@@ -2811,7 +2985,8 @@ async function* finalizeChatLoopTurn(options) {
       turnId,
       cwd: config.cwd,
       abort,
-      memoryProvider: deps.memoryProvider
+      memoryProvider: deps.memoryProvider,
+      middlewareRunner
     });
     for (const event of compactionEvents) {
       middlewareRunner.emitEvent(event);
@@ -2967,7 +3142,8 @@ async function* runChatLoop(deps) {
               turnId,
               cwd: config.cwd,
               abort,
-              memoryProvider: deps.memoryProvider
+              memoryProvider: deps.memoryProvider,
+              middlewareRunner
             });
             for (const event of preStepCompaction.events) {
               middlewareRunner.emitEvent(event);
@@ -3012,12 +3188,6 @@ async function* runChatLoop(deps) {
             return;
           }
           const planSnapshot = isPlanMode && stepResult.finishReason === "tool-calls" ? turnEngine.createStepCommitSnapshot() : void 0;
-          yield* commitStep({
-            step,
-            finishReason: stepResult.finishReason,
-            turnEngine,
-            applyCommitBatch
-          });
           if (stepResult.finishReason === "tool-calls") {
             if (step >= config.maxSteps) {
               const maxStepsError = new Error(
@@ -3062,6 +3232,13 @@ async function* runChatLoop(deps) {
                 turnEngine,
                 applyCommitBatch
               });
+            } else {
+              yield* commitStep({
+                step,
+                finishReason: stepResult.finishReason,
+                turnEngine,
+                applyCommitBatch
+              });
             }
             step += 1;
             continue;
@@ -3491,8 +3668,12 @@ var Agent = class _Agent {
       sessions: this.sessions,
       logger: this._logger,
       memoryProvider: this.memoryProvider,
+      middlewareRunner: this.middlewareRunner,
       sessionId: this.sessions.getSessionId() ?? void 0,
-      cwd: this.config.cwd
+      cwd: this.config.cwd,
+      phase: "manual",
+      trigger: "manual",
+      reason: "manual-request"
     });
   }
   async compactMessages(messages, options = {}) {
@@ -3501,9 +3682,15 @@ var Agent = class _Agent {
       messages,
       logger: this._logger,
       force: options.force,
+      trigger: options.trigger ?? (options.force ? "recovery" : "manual"),
+      reason: options.reason ?? (options.force ? "provider-overflow" : "manual-request"),
       memoryProvider: this.memoryProvider,
-      sessionId: this.sessions.getSessionId() ?? void 0,
-      cwd: this.config.cwd
+      middlewareRunner: this.middlewareRunner,
+      sessionId: options.sessionId ?? this.sessions.getSessionId() ?? void 0,
+      ...options.turnId ? { turnId: options.turnId } : {},
+      cwd: options.cwd ?? this.config.cwd,
+      ...options.phase ? { phase: options.phase } : {},
+      ...options.contextFragmentTokens !== void 0 ? { contextFragmentTokens: options.contextFragmentTokens } : {}
     });
   }
   clearRememberedDoomLoopTools() {
@@ -3707,14 +3894,32 @@ var Agent = class _Agent {
 
 // src/agent/event-printer.ts
 function formatContextCompactionEvent(event) {
+  const trigger = event.trigger ? `, trigger=${event.trigger}` : "";
+  const runReason = event.reason ? `, runReason=${event.reason}` : "";
   if (event.removedCount === 0 && event.tokensRemoved > 0 && !event.cutReason) {
-    return `\u{1F4E6} Context compaction (${event.phase}): compacted tool context, ${event.tokensRemoved} tokens
+    return `\u{1F4E6} Context compaction (${event.phase}): compacted tool context, ${event.tokensRemoved} tokens${trigger}${runReason}
 `;
   }
   const cutReason = event.cutReason ? `, reason=${event.cutReason}` : "";
-  return `\u{1F4E6} Context compaction (${event.phase}): removed ${event.removedCount} message(s), ${event.tokensRemoved} tokens${cutReason}
+  return `\u{1F4E6} Context compaction (${event.phase}): removed ${event.removedCount} message(s), ${event.tokensRemoved} tokens${cutReason}${trigger}${runReason}
 `;
 }
+function formatToolResult(result, maxChars) {
+  let text;
+  if (typeof result === "string") {
+    text = result;
+  } else {
+    try {
+      text = JSON.stringify(result);
+    } catch {
+      text = String(result);
+    }
+  }
+  if (text.length <= maxChars) {
+    return text;
+  }
+  return `${text.slice(0, Math.max(0, maxChars - 1))}\u2026`;
+}
 function createEventPrinter(options = {}) {
   const {
     tools = true,
@@ -3723,6 +3928,7 @@ function createEventPrinter(options = {}) {
     safety = true,
     completion = true,
     team = false,
+    toolResultMaxChars = 200,
     stdout = process.stdout,
     stderr = process.stderr
   } = options;
@@ -3777,8 +3983,11 @@ function createEventPrinter(options = {}) {
           );
         break;
       case "tool-result":
-        if (tools) stderr.write(`   \u2713 ${String(event.result).slice(0, 200)}
-`);
+        if (tools)
+          stderr.write(
+            `   \u2713 ${formatToolResult(event.result, toolResultMaxChars)}
+`
+          );
         break;
       case "tool-error":
         if (tools) stderr.write(`   \u2717 ${event.error}
@@ -3978,14 +4187,15 @@ export {
   DEFAULT_SUMMARY_MAX_INPUT_TOKENS,
   DEFAULT_SUMMARY_MAX_OUTPUT_TOKENS,
   DEFAULT_SYSTEM_PROMPT,
+  DEFAULT_TOOL_CONTEXT_PRUNE_POLICY,
   DISPATCH_STATES,
   DoomLoopError,
   EXTENDED_LEVELS,
   FIXED_LEVELS,
-  FileStorage,
   HumanInputTimeoutError,
   HumanInputUnavailableError,
   InMemoryMailboxStore,
+  InMemorySessionStore,
   InMemoryTaskBoardStore,
   Inference,
   InterventionController,
@@ -3997,7 +4207,6 @@ export {
   MAX_BYTES,
   MAX_LINES,
   Mailbox,
-  MemoryStorage,
   MiddlewareRunner,
   ModelCapabilityResolver,
   NullSettings,
@@ -4015,9 +4224,9 @@ export {
   PromptBuilder,
   RemoteCapabilityFetcher,
   RemoteCapabilitySource,
+  SESSION_FORMAT_VERSION,
   SKILL_FILENAME,
   STANDARD_LEVELS,
-  STORAGE_VERSION,
   SUBAGENT_TOOL_IDS,
   SessionManager,
   SkillRegistry,
@@ -4076,6 +4285,7 @@ export {
   clearInstalledSubAgents,
   cloneAgentWorkflowTurnState,
   code,
+  commitAgentContextCompaction,
   commitOutput,
   commitStep,
   compactAgentMessages,
@@ -4200,21 +4410,19 @@ export {
   generateSplitTurnSummary,
   generateSummary,
   getAgentContextFragmentMetadata,
+  getAutoCompactTokenLimit,
   getAvailableFamilies,
   getConfiguredSubAgents,
   getCurrentAgentTurnStepRecord,
-  getDataDir,
   getDefaultResolver,
   getDefaultSessionManager,
+  getEffectiveContextWindow,
   getErrorCategory,
-  getGitRootHash,
   getInstalledSubAgentBackend,
   getLeafId,
   getModelId,
   getNetworkStatus,
   getPluginLoader,
-  getProjectId,
-  getProjectSessionsDir,
   getProjectSubAgentRolesDir,
   getProviderCompatibility,
   getProviderId,
@@ -4223,7 +4431,6 @@ export {
   getReasoningConfigSync,
   getRequiredToolHost,
   getRetryDelay,
-  getSessionsDir,
   getTemplate,
   getToolRisk,
   getUsableTokenLimit,
@@ -4293,8 +4500,8 @@ export {
   resetFrameworkAliases,
   resetPluginLoader,
   resolveAgentDefaults,
+  resolveAgentMemoryCaptureConfig,
   resolveAgentMemoryConfig,
-  resolveAgentMemoryTurnConfig,
   resolveCapability,
   resolveContextSummaryPolicy,
   resolveFrameworkAliases,