# What Happens When the 2KB Snapshot Budget Is Exceeded During Compaction in context-mode?

> Learn what happens when the 2KB snapshot budget is exceeded during compaction in context-mode. Discover how XML resume snapshots are truncated and receive an ellipsis marker.

- Repository: [Mert Köseoğlu/context-mode](https://github.com/mksglu/context-mode)
- Tags: internals
- Published: 2026-04-24

---

**When the 2KB snapshot budget is exceeded during compaction, the XML resume snapshot is silently truncated at the byte boundary and appended with an ellipsis marker to enforce the hard limit.**

The `mksglu/context-mode` repository implements a strict memory management policy for LLM context windows. During session compaction, the engine serializes stored events into an XML resume snapshot, but the runtime enforces an unyielding 2048-byte cap to prevent context overflow. Understanding this truncation behavior is critical for debugging missing session history or optimizing event storage.

## The Compaction and Snapshot Building Process

When a compaction cycle triggers, the engine iterates through all stored `SessionEvent`s and constructs a comprehensive XML resume snapshot. This process occurs in [`src/session/snapshot.ts`](https://github.com/mksglu/context-mode/blob/main/src/session/snapshot.ts), where the `buildResumeSnapshot()` function generates a structured document containing grouped events, compact counts, and tool metadata.

The resulting XML string represents the complete session state that would normally resume the context. However, before this snapshot enters the LLM context window, it must pass through the hard-byte-cap validation.

## Hard Byte Cap Enforcement in truncate.ts

The enforcement logic resides in [`src/truncate.ts`](https://github.com/mksglu/context-mode/blob/main/src/truncate.ts), specifically within the `capBytes()` utility. This function implements a three-step truncation pipeline when the 2KB snapshot budget is exceeded:

### Byte Size Validation

The system calls `capBytes(str, maxBytes)` with `maxBytes` hardcoded to `2048` (2 × 1024). This function measures the byte length of the UTF-8 string rather than character count, ensuring accurate memory accounting for multi-byte characters.

### Marker Insertion at Boundary

When the snapshot exceeds 2048 bytes, the function calculates the longest prefix that fits within the budget and trims the remainder. It then appends the truncation marker (`…`) to indicate content omission. The final output strictly never exceeds the allocated 2048-byte budget.

### Priority Preservation Behavior

Unlike priority-based dropping mechanisms that remove low-importance sections first, this implementation performs a hard byte cut. The snapshot builder does not reorder or filter sections by priority; instead, it preserves the XML structure from the beginning up to the byte limit. Consequently, content appearing earlier in the serialized string has higher survival probability during truncation.

## Practical Implementation Example

The following pattern demonstrates how compaction applies the 2KB constraint in practice:

```typescript
import { buildResumeSnapshot } from "./session/snapshot.js";
import { capBytes } from "./truncate.js";

const events = await db.getAllEvents();          // Retrieved SessionEvents
const rawXml = buildResumeSnapshot(events, {
  compactCount: 1,
  searchTool: "ctx_search",
});

// Enforce the 2KB snapshot budget
const snapshotXml = capBytes(rawXml, 2 * 1024);   // 2048 bytes

console.log(snapshotXml);   // ≤ 2KB, ends with "…" if truncated

```

The `capBytes()` call acts as a failsafe, guaranteeing that regardless of how many events accumulated in the session, the final XML payload never breaches the runtime limit.

## Key Source Files and Validation

The truncation behavior is distributed across four critical files:

- **[`src/session/snapshot.ts`](https://github.com/mksglu/context-mode/blob/main/src/session/snapshot.ts)** – Constructs the full XML resume snapshot from `SessionEvent` groups and resume metadata.
- **[`src/truncate.ts`](https://github.com/mksglu/context-mode/blob/main/src/truncate.ts)** – Exports `capBytes()` and related utilities that enforce the hard byte limit and append the truncation marker.
- **[`tests/truncate.test.ts`](https://github.com/mksglu/context-mode/blob/main/tests/truncate.test.ts)** – Unit tests verifying that strings exceeding the byte budget are correctly truncated and that the ellipsis marker appears at the boundary.
- **[`tests/core/server.test.ts`](https://github.com/mksglu/context-mode/blob/main/tests/core/server.test.ts)** – Integration tests confirming that typical LLM responses, including snapshots, respect the `hardCapBytes: 2048` configuration.

## Summary

When the 2KB snapshot budget is exceeded during compaction in context-mode:

- The engine generates a complete XML resume snapshot in [`src/session/snapshot.ts`](https://github.com/mksglu/context-mode/blob/main/src/session/snapshot.ts) before applying size constraints.
- The `capBytes()` function in [`src/truncate.ts`](https://github.com/mksglu/context-mode/blob/main/src/truncate.ts) enforces a hard 2048-byte limit via byte-length calculation.
- Excess content is truncated with an ellipsis marker (`…`) appended to indicate omission.
- No priority-based filtering occurs; truncation cuts strictly at the byte boundary to preserve early content.

## Frequently Asked Questions

### Does context-mode throw an error when the snapshot exceeds 2KB?

No, the system silently truncates the snapshot. The `capBytes()` utility handles the overflow gracefully by trimming the string and appending a marker, allowing the session to continue without runtime exceptions.

### Why does the truncation use a byte limit instead of character count?

The 2KB budget refers to memory allocation in the context window, which is measured in bytes. Using `capBytes()` ensures that multi-byte UTF-8 characters do not inadvertently breach the hard limit, maintaining accurate memory accounting for international characters and symbols.

### Can I configure the snapshot budget to be larger than 2KB?

The analysis indicates the runtime enforces a hard cap of 2048 bytes (`hardCapBytes: 2048`). While `capBytes()` accepts any `maxBytes` parameter, the compaction logic in the source code specifically targets this 2KB limit for LLM context management.

### How can I detect if my snapshot was truncated?

Check for the presence of the ellipsis marker (`…`) at the end of the snapshot string. If the XML concludes with this character, the `capBytes()` function activated and removed trailing content to maintain the budget constraint.