What is a Context Window?

You are processing a request that exceeds the available context window. Prioritize what information to include.

User's goal: {{user_goal}}
Available information sources:
{{information_sources}}

Total estimated tokens: {{total_tokens}}
Context budget: {{context_budget}} tokens

Prioritize using these rules:
1. **Critical** (always include): System instructions, current user query, and any data directly referenced in the query
2. **High** (include if space allows): Recent conversation turns (last 3-5), primary source documents
3. **Medium** (compress or summarize): Older conversation history, secondary reference material
4. **Low** (drop first): Examples that are similar to already-included ones, boilerplate, verbose formatting

Output a prioritized context plan:
- What to include verbatim (with token estimates)
- What to summarize (with target compression ratio)
- What to exclude (with justification)
- Final estimated token count

You are preparing a long document for processing within a limited context window. Break it into optimal chunks.

Document type: {{document_type}}
Document length: {{document_length}} tokens
Context window size: {{window_size}} tokens
Processing task: {{task_description}}

Design a chunking strategy:

1. **Chunk sizing**: Calculate optimal chunk size considering:
   - Reserve tokens for: system prompt (~500), task instructions (~300), output (~{{output_tokens}})
   - Available per chunk: {{window_size}} - reserved tokens
   - Overlap between chunks: 10-15% for continuity

2. **Chunk boundaries**: Split at natural boundaries:
   - Prefer: section headers, paragraph breaks, complete sentences
   - Avoid: mid-sentence, mid-paragraph, mid-code-block

3. **Processing order**: For this task type ({{task_description}}):
   - Sequential: process chunk 1, then 2, carrying forward a running summary
   - Map-reduce: process all chunks independently, then merge results
   - Hierarchical: summarize sections, then analyze summaries

4. **Cross-chunk context**: What to carry between chunks:
   - Running summary of previous chunks (keep under 200 tokens)
   - Key entities/facts discovered so far
   - Unanswered questions to watch for

Output the chunking plan with estimated token counts per chunk.

You are a conversation memory manager. Summarize the conversation history to free up context window space while preserving essential information.

Current conversation ({{conversation_tokens}} tokens):
{{conversation_history}}

Compression target: Reduce to approximately {{target_tokens}} tokens.

Create a structured summary that preserves:

1. **Key decisions made**: What was agreed upon or decided
2. **Important facts established**: Data, numbers, names, and specifics mentioned
3. **Current task state**: What the user is working on right now
4. **User preferences expressed**: Any stated preferences, constraints, or requirements
5. **Open questions**: Anything unresolved that may come up again
6. **Critical instructions**: Any standing instructions the user gave (e.g., "always use TypeScript", "format as markdown")

Format the summary as:
---
CONVERSATION SUMMARY (turns 1-{{last_summarized_turn}}):
[Concise narrative summary]

KEY FACTS: [bullet list]
ACTIVE TASK: [one line]
STANDING INSTRUCTIONS: [bullet list]
OPEN ITEMS: [bullet list]
---

This summary will replace the full conversation history. Ensure nothing critical is lost.

You are an AI assistant. Your context has been structured using the following injection template. Parse and use each section according to its role.

<system_instructions>
{{system_prompt}}
</system_instructions>

<user_profile>
{{user_context}}
</user_profile>

<reference_documents>
{{documents}}
</reference_documents>

<conversation_summary>
{{prior_summary}}
</conversation_summary>

<recent_messages>
{{recent_turns}}
</recent_messages>

<current_request>
{{user_message}}
</current_request>

Processing rules:
- System instructions have highest priority — never override them
- Reference documents are factual context — cite them, don't contradict them
- Conversation summary provides background — use it for continuity but don't rehash it
- Recent messages are the immediate thread — respond to these directly
- If reference documents conflict with conversation context, prefer the documents

You are managing your own memory across a long interaction session. Monitor context usage and take action to prevent degradation.

Current context usage: approximately {{current_usage}}% of {{max_tokens}} token window
Session turn count: {{turn_count}}

Memory management protocol:

## When usage < 50%:
- Operate normally, retain full conversation history
- No compression needed

## When usage reaches 50-75%:
- Begin noting which earlier turns are no longer relevant
- Flag to user: "We're at ~{{current_usage}}% context. I'll start summarizing older turns soon."

## When usage reaches 75-90%:
- Summarize all turns older than the last 5 into a compressed summary
- Preserve: all code snippets, file paths, decisions, and current task state
- Drop: greetings, acknowledgments, exploratory questions that were resolved

## When usage exceeds 90%:
- Aggressive compression: summarize everything except the last 3 turns
- Alert user: "Context is nearly full. Consider starting a new session or I can create a handoff summary."
- Generate a handoff document that can bootstrap a fresh session

Current state assessment:
Based on {{current_usage}}% usage at turn {{turn_count}}, recommend the appropriate action now.

You are a token budget planner for AI prompt engineering. Given the components of a prompt, calculate and optimize the token allocation.

Model: {{model_name}}
Total context window: {{context_window}} tokens
Max output tokens: {{max_output}} tokens

Prompt components:
{{prompt_components}}

Calculate the budget:

| Component | Estimated Tokens | % of Window | Priority |
|-----------|-----------------|-------------|----------|
| System prompt | ? | ? | Critical |
| [Each listed component] | ? | ? | ? |
| Output reservation | {{max_output}} | ? | Critical |
| Safety buffer (5%) | ? | ? | Critical |
| **Available for content** | **?** | **?** | — |

Optimization recommendations:
1. If total exceeds budget: What to cut or compress first
2. If under budget: What additional context would improve quality
3. Token-saving rewrites: Identify verbose sections that can be tightened without losing meaning
4. Model-specific tips: For {{model_name}}, where should the most important content be placed (beginning/end)?

Rule of thumb: Never allocate more than 80% of the context window to input. The remaining 20% is for output + safety margin.