@dreb/coding-agent 2.64.2 → 2.64.4

package/README.md

@@ -253,7 +253,7 @@ Long sessions can exhaust context windows. Compaction summarizes older messages
 
 **Manual:** `/compact` or `/compact <custom instructions>`
 
-**Automatic:** Enabled by default. Triggers on context overflow (recovers and retries) or when approaching the limit (proactive). Configure via `/settings` or `settings.json`. For unattended long-running work, enable **Continue after auto-compaction** (persisted as `compaction.continueAfterAutoCompaction`) to start another model turn after every successful automatic compaction, even with no queued message. It is off by default and never makes manual `/compact` continue.
+**Automatic:** Enabled by default. Triggers on context overflow (recovers and retries) or proactively when approaching the limit, including between LLM requests in a long tool loop. Mid-turn checks wait until every tool call has a matching result, compact the settled context, and continue in the same loop before the next provider request. Configure via `/settings` or `settings.json`. For unattended long-running work, enable **Continue after auto-compaction** (persisted as `compaction.continueAfterAutoCompaction`) to keep pending or interrupted work moving after successful automatic compaction. It is off by default, does not start a fresh turn after a completed assistant answer, and never makes manual `/compact` continue.
 
 Compaction is lossy. The full history remains in the JSONL file; use `/tree` to revisit. Customize compaction behavior via [extensions](#extensions). See [docs/compaction.md](docs/compaction.md) for internals.
 

package/dist/core/agent-session.d.ts

@@ -202,6 +202,10 @@ export declare class AgentSession {
     private _pendingNextTurnMessages;
     private _compactionAbortController;
     private _autoCompactionAbortController;
+    /** The in-flight auto-compaction run (any start path), if any. */
+    private _autoCompactionInFlight;
+    /** Serializes auto-compaction checks so two never run concurrently. */
+    private _autoCompactionChain;
     private _overflowRecoveryAttempted;
     private _branchSummaryAbortController;
     private _retryAbortController;
@@ -289,6 +293,9 @@ export declare class AgentSession {
      * - Layer D: Turn limiter — restrict parent to N turns while bg agents are running
      */
     private _installBackgroundAgentGuardrails;
+    /** Install the settled pre-request hook used for mid-turn compaction. */
+    private _installMidTurnCompactionHook;
+    private _prepareForLlmCall;
     /**
      * Reset the background-agent guardrail counter and the pause-notified flag together.
      * These two fields are one logical unit — they must always reset in lockstep so a new
@@ -628,7 +635,27 @@ export declare class AgentSession {
      * Cancel in-progress branch summarization.
      */
     abortBranchSummary(): void;
+    /**
+     * Check if compaction is needed and run it.
+     * Called after agent_end and before prompt submission.
+     *
+     * Two cases:
+     * 1. Overflow: LLM returned context overflow error, remove error message from agent state, compact, auto-retry
+     * 2. Threshold: Context over threshold, compact, NO auto-retry (user continues manually)
+     *
+     * Checks run on a serialization chain: a check that arrives while another
+     * check's compaction is still in flight (e.g. a prompt submitted during an
+     * agent_end compaction) waits for it, then evaluates instead of starting a
+     * competing compaction. If an earlier queued check compacted or rebuilt
+     * context first, the captured message is pre-compaction and the
+     * pre-compaction staleness guard inside _doCheckCompaction skips it.
+     *
+     * @param assistantMessage The assistant message to check
+     * @param skipAbortedCheck If false, include aborted messages (for pre-prompt check). Default: true
+     * @param requestWillFollow Whether the caller will issue the next request without agent.continue().
+     */
     private _checkCompaction;
+    private _doCheckCompaction;
     /**
      * Apply the K3 auto context tier to a model being set on the agent. The
      * user-facing `k3` model runs on the cheaper `k3-256k` wire model ID until
@@ -644,6 +671,13 @@ export declare class AgentSession {
      * compacted. Returns true when the upgrade was applied.
      */
     private _tryUpgradeK3ContextTier;
+    /**
+     * Start an auto-compaction while tracking it, so a concurrent check that
+     * arrives during the run can await it instead of starting a competing one.
+     * The tracking flag clears when this specific run settles (even on error,
+     * since _runAutoCompaction swallows its own failures).
+     */
+    private _trackAutoCompaction;
     private _runAutoCompaction;
     /**
      * Toggle auto-compaction setting.