@animalabs/context-manager 0.5.1 → 0.5.2

package/dist/src/strategies/autobiographical.js

@@ -1,6 +1,7 @@
 import { NativeFormatter } from '@animalabs/membrane';
 import { DEFAULT_AUTOBIOGRAPHICAL_CONFIG } from '../types/index.js';
 import { getSummaryParentId } from '../types/strategy.js';
+import { splitMixedToolMessages } from '../normalize-tool-messages.js';
 import { appendFileSync, mkdirSync } from 'node:fs';
 import { dirname } from 'node:path';
 import { Picker, OverBudgetError } from '../adaptive/picker.js';
@@ -622,6 +623,36 @@ export class AutobiographicalStrategy {
      * Mark a summary as merged into a higher-level summary, updating the
      * chronicle copy at the same index. Index is the position in `this.summaries`.
      */
+    /**
+     * Token-budget cap for recall-pair summary sets. Walks newest→oldest
+     * keeping each summary that still fits; skips (rather than breaks at)
+     * a summary that would put us over budget, so a heterogeneous set
+     * fills the remaining slots with smaller siblings instead of stopping
+     * at the first oversized one. The kept set is re-sorted chronologically.
+     *
+     * Used by both `compressChunkHierarchical` (the L1 compression prompt
+     * recall pairs) and `executeMerge` (the merge prompt recall pairs).
+     * Without the cap, both sites grow their recall set linearly with
+     * conversation length and overflow the 200k window around the same
+     * point — observed empirically at ~chunk 118 in a 4000-message import.
+     *
+     * Per-summary +50 token overhead accounts for the "[CM] Recall memory
+     * <id>." question turn that wraps each recall body. Rough but defensive.
+     */
+    capRecallPairs(summariesChronological, maxTokens) {
+        const kept = [];
+        let total = 0;
+        for (let i = summariesChronological.length - 1; i >= 0; i--) {
+            const s = summariesChronological[i];
+            const est = (s.tokens ?? Math.ceil(s.content.length / 4)) + 50;
+            if (total + est > maxTokens)
+                continue;
+            kept.push(s);
+            total += est;
+        }
+        kept.reverse();
+        return { kept, keptTokens: total };
+    }
     setMergedInto(entry, mergedIntoId) {
         entry.mergedInto = mergedIntoId;
         if (!this.store)
@@ -1316,32 +1347,17 @@ export class AutobiographicalStrategy {
         const priorSummaries = this.summaries
             .filter((s) => !s.mergedInto)
             .sort((a, b) => a.sourceRange.first.localeCompare(b.sourceRange.first));
-        // Token-budget cap on recall pairs as defense-in-depth. With merged
-        // exclusion the set is bounded by `mergeThreshold^depth`, but a
-        // conversation with thousands of unmerged top-level summaries can
-        // still overflow. Newest-first selection so proximate context is
-        // preferred; the kept set is re-sorted chronologically below. We
-        // always keep at least one summary even if it's larger than the
-        // budget — otherwise a single oversized summary would leave the
-        // model with no compressed context at all.
-        const recallBudget = this.config.compressionRecallBudgetTokens ?? 150_000;
-        const keptSummaries = [];
-        let recallTokens = 0;
-        for (let i = priorSummaries.length - 1; i >= 0; i--) {
-            const s = priorSummaries[i];
-            const approxTokens = Math.ceil(s.content.length / 4);
-            if (recallTokens + approxTokens > recallBudget && keptSummaries.length > 0)
-                break;
-            keptSummaries.push(s);
-            recallTokens += approxTokens;
-        }
-        keptSummaries.reverse();
+        // Token-budget cap (see capRecallPairs). Defense-in-depth: even with
+        // merged exclusion the unmerged frontier can be large at extreme scale.
+        const recallBudget = this.config.compressionRecallBudgetTokens ?? 100_000;
+        const { kept: keptSummaries, keptTokens: recallTokens } = this.capRecallPairs(priorSummaries, recallBudget);
         if (keptSummaries.length < priorSummaries.length) {
             const dropped = priorSummaries.length - keptSummaries.length;
-            console.warn(`autobio: recall-pair budget capped (${keptSummaries.length}/${priorSummaries.length} summaries kept, ` +
+            console.warn(`autobio: compression recall-pair budget capped (${keptSummaries.length}/${priorSummaries.length} summaries kept, ` +
                 `~${recallTokens} tokens, budget ${recallBudget}; ${dropped} oldest dropped this compression).`);
             logCompressionCall({
                 event: 'recall-budget-capped',
+                site: 'compression',
                 kept: keptSummaries.length,
                 total: priorSummaries.length,
                 tokens: recallTokens,
@@ -1433,8 +1449,14 @@ export class AutobiographicalStrategy {
             participant: 'Context Manager',
             content: [{ type: 'text', text: instructionText }],
         });
+        // Split any bundled tool_use+tool_result cycles in non-user turns into
+        // separate API-shape messages. claude.ai-imported sessions carry these
+        // bundles (a tool_result in an assistant message rejects the request);
+        // for fresh imports the conhost importer splits at ingest time, but
+        // already-warmed sessions hit this path. See `normalize-tool-messages.ts`.
+        const split = splitMixedToolMessages(llmMessages);
         // Collapse consecutive same-participant messages for API compliance
-        const collapsed = this.collapseConsecutiveMessages(llmMessages);
+        const collapsed = this.collapseConsecutiveMessages(split);
         // NO system prompt. The agent's identity is established by the head
         // (the actual conversation opening — user message + agent reply that
         // grounded the original instance). A system prompt would (a) add a
@@ -1703,17 +1725,21 @@ export class AutobiographicalStrategy {
             const m = allMessages[i];
             llmMessages.push({ participant: m.participant, content: m.content });
         }
-        // ---- 1b. PRIOR L1 RECALL PAIRS (chronologically before merge range) ----
-        // L1s whose entire source range is before the merge range and that
-        // aren't part of the merge tree. Sort by source position.
-        const priorL1s = this.summaries
-            .filter((s) => s.level === 1)
+        // ---- 1b. PRIOR RECALL PAIRS (chronologically before merge range) ----
+        // The unmerged frontier of summaries whose source range is before the
+        // merge range and which aren't part of the merge tree. Originally this
+        // was filtered to `level === 1` (the "L1 fidelity for prior content"
+        // intent) but at 4000+ messages that produces hundreds of L1s and
+        // overflows the model window. Switching to the unmerged frontier
+        // (`!mergedInto`) lets a merged L1 drop out in favour of its L2/L3
+        // parent — the same rule used everywhere else and now in
+        // `compressChunkHierarchical`. The cap below is the defense-in-depth.
+        const priorSummariesAll = this.summaries
+            .filter((s) => !s.mergedInto)
             .filter((s) => {
-            // Exclude any L1 that's an ancestor of our merge target
             for (const lid of s.sourceIds)
                 if (sourceLeafIds.has(lid))
                     return false;
-            // Include only if it starts strictly before the merge range
             const firstIdx = allMessages.findIndex((m) => m.id === s.sourceRange.first);
             return firstIdx >= 0 && (mergeStartIdx < 0 || firstIdx < mergeStartIdx);
         })
@@ -1722,12 +1748,31 @@ export class AutobiographicalStrategy {
             const bi = allMessages.findIndex((m) => m.id === b.sourceRange.first);
             return ai - bi;
         });
-        const priorL1MessageIds = new Set();
-        for (const s of priorL1s) {
+        const mergeRecallBudget = this.config.compressionRecallBudgetTokens ?? 100_000;
+        const { kept: keptPriorSummaries, keptTokens: mergeRecallTokens } = this.capRecallPairs(priorSummariesAll, mergeRecallBudget);
+        if (keptPriorSummaries.length < priorSummariesAll.length) {
+            const dropped = priorSummariesAll.length - keptPriorSummaries.length;
+            console.warn(`autobio: merge recall-pair budget capped (${keptPriorSummaries.length}/${priorSummariesAll.length} summaries kept, ` +
+                `~${mergeRecallTokens} tokens, budget ${mergeRecallBudget}; ${dropped} oldest dropped this merge).`);
+            logCompressionCall({
+                event: 'recall-budget-capped',
+                site: 'merge',
+                targetLevel,
+                kept: keptPriorSummaries.length,
+                total: priorSummariesAll.length,
+                tokens: mergeRecallTokens,
+                budgetTokens: mergeRecallBudget,
+            });
+        }
+        // The full unmerged-frontier set covers what's "compressed somewhere"
+        // for the raw-middle dedup below — a budget-dropped recall pair
+        // doesn't make its underlying raw messages reappear.
+        const priorSummaryMessageIds = new Set();
+        for (const s of priorSummariesAll) {
             for (const id of s.sourceIds)
-                priorL1MessageIds.add(id);
+                priorSummaryMessageIds.add(id);
         }
-        for (const s of priorL1s) {
+        for (const s of keptPriorSummaries) {
             llmMessages.push({
                 participant: 'Context Manager',
                 content: [{ type: 'text', text: `[CM] Recall memory ${s.id}.` }],
@@ -1738,12 +1783,12 @@ export class AutobiographicalStrategy {
             });
         }
         // Raw middle: any messages between the head window and the merge
-        // range that aren't covered by a prior L1 or the merge tree.
+        // range that aren't covered by a prior summary or the merge tree.
         // Usually empty (chunking is contiguous).
         if (mergeStartIdx >= 0) {
             for (let i = headEndIdx; i < mergeStartIdx; i++) {
                 const m = allMessages[i];
-                if (priorL1MessageIds.has(m.id))
+                if (priorSummaryMessageIds.has(m.id))
                     continue;
                 if (sourceLeafIds.has(m.id))
                     continue;
@@ -1823,7 +1868,9 @@ export class AutobiographicalStrategy {
                     text: mergeInstructionText,
                 }],
         });
-        const collapsed = this.collapseConsecutiveMessages(llmMessages);
+        // Same bundled-tool-cycle defense as compressChunkHierarchical.
+        const split = splitMixedToolMessages(llmMessages);
+        const collapsed = this.collapseConsecutiveMessages(split);
         // NO system prompt — identity is established by the head window
         // (present at the start of llmMessages above) and by the prior
         // recall pairs. Same rationale as compressChunkHierarchical.