@animalabs/context-manager 0.5.0 → 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)
@@ -1288,11 +1319,14 @@ export class AutobiographicalStrategy {
         const agentParticipant = this.config.summaryParticipant ?? 'Claude';
         // Build the KV-preserving prompt per hermes-autobio spec:
         //
-        //   1. Prior L1 summaries — narrativized as CM-asks / agent-recalls
-        //      pairs, in source order. ALL existing L1s at L1 fidelity
-        //      regardless of merge state ("fill lower orbitals first").
+        //   1. Prior summaries — narrativized as CM-asks / agent-recalls
+        //      pairs, in source order. The unmerged frontier of the
+        //      summary forest: any summary that has not yet been merged
+        //      into a higher level. After merges run, the L_{k+1} replaces
+        //      its L_k children — using the children plus their parent
+        //      doubles the prompt size unboundedly.
         //   2. Head — raw messages before the chunk that aren't already
-        //      represented by a prior L1.
+        //      represented by a prior summary.
         //   3. Marker — in-band signal that a memory is about to form.
         //   4. Chunk — raw messages being compressed, as the agent
         //      experienced them.
@@ -1302,13 +1336,35 @@ export class AutobiographicalStrategy {
         // future information into the model's KV state and corrupt the
         // as-of framing of memory formation.
         const llmMessages = [];
-        // ---- 1. Prior L1 recall pairs ----
-        // Sort by source position so the agent walks its prior memories
-        // chronologically, matching how it would have formed them.
-        const priorL1s = this.summaries
-            .filter((s) => s.level === 1)
+        // ---- 1. Prior recall pairs ----
+        // Filter to the unmerged frontier: any summary whose `mergedInto`
+        // is unset. After merge, the children's mergedInto points at the
+        // parent and the parent stands alone with that source range. The
+        // original "ALL L1s regardless of merge state" rule was a fidelity
+        // optimization that scales catastrophically: a 4000-message import
+        // converged to ~500 L1s that never aged out, blowing the 200k
+        // window around chunk 118.
+        const priorSummaries = this.summaries
+            .filter((s) => !s.mergedInto)
             .sort((a, b) => a.sourceRange.first.localeCompare(b.sourceRange.first));
-        for (const s of priorL1s) {
+        // 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: 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,
+                budgetTokens: recallBudget,
+            });
+        }
+        for (const s of keptSummaries) {
             llmMessages.push({
                 participant: 'Context Manager',
                 content: [{ type: 'text', text: `[CM] Recall memory ${s.id}.` }],
@@ -1345,20 +1401,24 @@ export class AutobiographicalStrategy {
             llmMessages.push({ participant: m.participant, content: m.content });
         }
         // Any raw messages between the head and the chunk that aren't yet
-        // represented by an L1 — usually empty in adaptive-resolution mode,
-        // since chunking proceeds contiguously and L1s exist for everything
-        // up to the chunk being processed.
+        // represented by any summary — usually empty in adaptive-resolution
+        // mode, since chunking proceeds contiguously and summaries cover
+        // everything up to the chunk being processed. Uses the full
+        // priorSummaries set (not the budget-capped keptSummaries) because
+        // the dedup question is "is this raw message covered by *any* live
+        // summary?" — a budget-dropped summary doesn't make the underlying
+        // raw messages reappear.
         const chunkFirstId = chunk.messages[0]?.id;
         if (chunkFirstId) {
-            const priorL1MessageIds = new Set();
-            for (const s of priorL1s) {
+            const priorSummaryMessageIds = new Set();
+            for (const s of priorSummaries) {
                 for (const id of s.sourceIds)
-                    priorL1MessageIds.add(id);
+                    priorSummaryMessageIds.add(id);
             }
             const chunkStartIdx = allMessages.findIndex((m) => m.id === chunkFirstId);
             for (let i = headEndIdx; i < chunkStartIdx && i < allMessages.length; i++) {
                 const m = allMessages[i];
-                if (priorL1MessageIds.has(m.id))
+                if (priorSummaryMessageIds.has(m.id))
                     continue;
                 llmMessages.push({ participant: m.participant, content: m.content });
             }
@@ -1389,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
@@ -1460,7 +1526,9 @@ export class AutobiographicalStrategy {
                 metadata: {
                     chunk_message_ids: chunk.messages.map((m) => m.id),
                     chunk_size: chunk.messages.length,
-                    prior_l1_count: priorL1s.length,
+                    prior_summary_count: priorSummaries.length,
+                    prior_summary_count_kept: keptSummaries.length,
+                    prior_summary_tokens: recallTokens,
                     has_doc_context: docContext !== null,
                     doc_context: docContext,
                     target_tokens: targetTokens,
@@ -1657,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);
         })
@@ -1676,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}.` }],
@@ -1692,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;
@@ -1777,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.