Context Loading

Priority Allocation

Workflow

Step 1: Identify the Task Target

Determine the primary files for the task:

• Bug fix: the file with the bug + its direct imports
• New feature: the module where the feature will live + related interfaces
• Refactor: the files being refactored + their dependents (from symbol map)
• Code review: the changed files in the PR/diff

Step 2: Load P0 - Task-Direct Files (40% budget)

1. Read the target file(s).
2. Use the symbol map to find direct dependencies.
3. Load those dependency files.
4. Track tokens used so far.

Step 3: Load P1 - Architecture Files (20% budget)

Load governance files that provide project context:

• AGENTS.md or CLAUDE.md (project instructions)
• RULES.md (coding standards)
• Entry point files (from repo map: files with isEntry: true)
• Only load sections relevant to the task, not entire files

Step 4: Load P2 - Related Test Files (15% budget)

1. Find test files for the target.
2. Load test files to understand expected behavior and test patterns.
3. If budget is tight, load only test names (describe/it blocks), not full test bodies.

Step 5: Load P3 - Recently Modified Related Files (15% budget)

Use the repo map to find high-importance files in the same module.

Step 6: Load P4 - Repo Map Summary (10% budget)

Load a condensed view of the project structure:

• Top 20 files by importance score
• Directory tree with file counts

Step 7: Track What Was Loaded

If the SQLite database exists, record the context load in context_loads.

Budget Overflow Strategy

When P0 alone exceeds 40% of budget:

1. Load only the target file and type signatures for dependencies.
2. Use symbol map signatures instead of full dependency files.
3. Reduce P1 to only project instruction summary sections.
4. Skip P3 entirely.
5. Keep P2 because tests are critical for behavior understanding.

Rules

• Always load P0 first - the task target is non-negotiable
• Never load files blindly - use repo map and symbol map to select
• Track tokens consumed at each priority tier
• If symbol map is outdated (>24h), suggest running /context-refresh first
• Prefer loading type signatures over full file contents when budget is tight
• Never load generated files, lock files, or vendored dependencies

Anti-patterns

• Loading every file in a directory without checking relevance
• Reading full file contents when only interfaces/types are needed
• Ignoring repo map and loading files alphabetically
• Spending >50% of budget on architecture files instead of task-direct code
• Not tracking loaded context, making optimization impossible later

Checklist

• Repo map exists and is recent (<24 hours old)
• Task target files identified
• P0 files loaded within 40% budget
• P1 architecture context loaded
• P2 test files loaded
• P3 related recent files loaded (if budget allows)
• P4 repo map summary loaded
• Context load recorded to telemetry database

Related

• Commands: /context-refresh, /context-budget
• Skills: session-memory, strategic-compact, search-first