Date: 2026-02-11 Version: v1.10.7 Baseline: v1.10.2 (post-compression) Scope: Measured impact of deterministic context routing across 3 phases of optimization Method: 6 plans, 18 tasks, 15 commits, 65/65 QA checks across 3 phases (all PASS) Verdict: Agent spawn/context overhead reduced by 40-50% through pre-computed context routing. Total per-session savings scale from ~24,000 tokens (small projects) to ~130,000 tokens (large projects) — equivalent to ~15-35% reduction in total context loading.
VBW v1.10.2 compressed the content — making every file smaller. v1.10.7 changes what gets loaded — routing only relevant content to each agent role.
The v1.10.2 compression milestone reduced VBW's coordination overhead to 75% below stock teams. This milestone compounds on top: instead of loading 3-4 full project files per agent spawn, each agent now receives a single pre-compiled context file containing only what its role needs.
Three phases attacked three distinct waste sources:
| Phase | Target | Mechanism | Per-Phase Saving |
|---|---|---|---|
| 1: Quick Wins | Redundant reference loads + unused state | Eliminated 3 runtime file loads | ~5,700-7,100 tokens |
| 2: Context Compiler | Full-file loads replaced by filtered views | compile-context.sh produces role-specific context |
~1,400-2,800 tokens |
| 3: Compound Optimizations | Per-task re-reads + per-task skill loads | Compaction marker + skill bundling | ~1,000-2,400 tokens |
The key insight: v1.10.2 made files smaller but every agent still loaded the same files regardless of role. A Dev building a 5-task plan loaded the same 46-line STATE.md it never uses. A Lead planning Phase 3 loaded all 30 requirements when only 5 are mapped to its phase. A QA agent loaded a 146-line protocol reference to learn its tier — information the spawning command already knew.
Scale matters: The savings are modest for small projects (~15%) but significant for large ones (~35%). Requirement filtering alone saves ~2,800 tokens per Lead spawn on a 30-requirement project. STATE.md removal saves ~6,000 tokens per phase when 5 Devs each skip a file that grew to 80 lines. The context compiler's value increases precisely where token pressure is highest.
After the compression milestone, VBW's file sizes were optimized but loading patterns were not:
| Agent | Definition | Runtime Loads | Total per Spawn |
|---|---|---|---|
| Lead | 568 tokens | REQUIREMENTS.md + ROADMAP.md + STATE.md + PROJECT.md | ~2,833 |
| Dev | 568 tokens | STATE.md + PLAN.md + per-task re-reads | ~1,758 (+ ~500/re-read) |
| QA | 568 tokens | verification-protocol.md + PLAN.md + SUMMARY.md | ~3,758 |
| # | Waste Source | Tokens Wasted | Frequency | Evidence |
|---|---|---|---|---|
| 1 | Dev reads STATE.md (never acts on it) | ~690/spawn | Every Dev spawn | Quality analyst verified across 3 phases |
| 2 | 6 commands load 89-line phase-detection.md | ~1,335/load | 1-3 per session | Script already pre-computes identical result |
| 3 | QA loads 146-line verification-protocol.md | ~2,190/spawn | Every QA spawn | Tier already known by spawning command |
| 4 | Lead reads all requirements (most irrelevant) | ~200-900/spawn | Every Lead spawn | Only 3-5 of 10-30 reqs map to current phase |
| 5 | Dev re-reads PLAN.md every task (often unnecessary) | ~500/re-read | 2-4 per plan | Only needed after compaction, not always |
| 6 | Skills re-loaded per task via @-references | ~400/skill/task | When skills used | Same content loaded repeatedly |
Goal: Remove file loads that provide zero value to the receiving agent. Result: 3 runtime file loads eliminated across all commands and agents. Commits: 2 (91741d7, cb609a3)
| Change | Before | After | Saving |
|---|---|---|---|
| phase-detection.md removed from 6 commands | 89-line reference loaded at runtime | phase-detect.sh output pre-computed in Context block | ~1,335 tokens per load |
| STATE.md removed from Dev Stage 1 | Dev loaded ~46-80 line file every spawn | Dev doesn't load STATE.md | ~690-1,200 per Dev spawn |
| verification-protocol.md replaced in QA | QA loaded 146-line reference | 12-line inline format spec in agent def | ~2,010 per QA spawn |
Small (3 phases) Large (8 phases)
phase-detection.md elimination:
1-3 loads/session × 1,335 1,335-4,005 2,670-4,005
STATE.md removal from Dev:
3-5 Devs/phase × 690-1,200 2,070-6,000 3,450-6,000
QA inline format spec:
1-2 QAs/phase × 2,010 2,010-4,020 2,010-4,020
───────────── ─────────────
Phase 1 per-phase saving: 5,415-14,025 8,130-14,025
Agent definitions grew slightly (+15 lines total across Dev and QA) because the inline content was added. But this is more than offset by eliminating the runtime loads they replaced.
Net effect: Agent definition files carry ~225 more tokens but avoid loading ~5,535 tokens of external files per phase. The inline content is cheaper than the I/O it replaces.
Goal: Replace full-file loads with role-specific compiled context.
Result: compile-context.sh (164 lines) produces 3 role-specific files.
Commits: 6 (3b89b98 through 0bc9641)
┌─────────────────────┐
│ compile-context.sh │
│ <phase> <role> │
└────────┬────────────┘
│
┌──────────────┼──────────────┐
▼ ▼ ▼
.context-lead.md .context-dev.md .context-qa.md
(27 lines) (21 lines) (34 lines)
┌────────────┐ ┌──────────┐ ┌─────────────┐
│ Phase goal │ │ Phase │ │ Phase goal │
│ Success │ │ goal │ │ Success │
│ Filtered │ │ Project │ │ Filtered │
│ requirements│ │ conven- │ │ requirements │
│ Active │ │ tions │ │ Conventions │
│ decisions │ │ │ │ to check │
└────────────┘ └──────────┘ └─────────────┘
| Output File | Lines | Est. Tokens | Replaces |
|---|---|---|---|
| .context-lead.md | 27 | ~405 | REQUIREMENTS.md (43 lines) + ROADMAP.md (33) + STATE.md (46) = 122 lines, ~1,830 tokens |
| .context-dev.md | 21 | ~315 | Phase awareness (additive — Dev had no phase context before) |
| .context-qa.md | 34 | ~510 | Ad-hoc reads of REQUIREMENTS.md + phase context |
This is the highest-impact mechanism. As projects grow, REQUIREMENTS.md balloons but each phase still maps to only 3-5 requirements:
| Project Scale | Reqs | Full REQUIREMENTS.md | Compiled Lead Context | Saving |
|---|---|---|---|---|
| Small (10 reqs, phase has 4) | 10 | ~20 lines, 300 tokens | ~15 lines, 225 tokens | ~75 |
| Current (18 reqs, phase has 8) | 18 | ~43 lines, 645 tokens | ~27 lines, 405 tokens | ~240 |
| Medium (20 reqs, phase has 4) | 20 | ~50 lines, 750 tokens | ~18 lines, 270 tokens | ~480 |
| Large (30 reqs, phase has 5) | 30 | ~90 lines, 1,350 tokens | ~22 lines, 330 tokens | ~1,020 |
The Lead also no longer loads ROADMAP.md (~495-900 tokens) or STATE.md (~690-1,200 tokens) separately — these are extracted into the compiled file. Total Lead spawn saving: ~1,425 (current) to ~2,800 (large) tokens.
context_compiler: true (default) in config/defaults.json. When false, all commands fall back to direct file reads — v1.10.2 behavior restored. The toggle is emitted by phase-detect.sh as config_context_compiler= so commands check it from pre-computed context.
| Command | Compile Call | Role | When |
|---|---|---|---|
| plan.md | Before Lead spawn | lead | Phase planning |
| execute.md | Before Dev spawn | dev | Phase execution |
| execute.md | Before QA spawn | qa | Post-build verification |
| implement.md | Before Lead spawn | lead | Planning step (States 3-4) |
| implement.md | Before Dev/QA spawn | dev, qa | Execution step (States 3-4) |
All calls are config-gated. All degrade gracefully on compile failure (proceed without compiled context).
Goal: Reduce redundant per-task operations that scale with plan complexity. Result: Skill bundling + compaction-aware re-reads. Commits: 6 (19e3b35 through ace5135)
Plans that reference skills in their skills_used frontmatter now get those skills bundled into .context-dev.md in a single compile step.
# Before: Dev loads skill per-task via @-reference
Task 1: @bash-pro/SKILL.md → 337 lines loaded → execute
Task 2: @bash-pro/SKILL.md → 337 lines loaded → execute (redundant)
Task 3: @bash-pro/SKILL.md → 337 lines loaded → execute (redundant)
Total: 1,011 lines loaded (337 × 3)
# After: Dev gets bundled skills once per phase
compile-context.sh 03 dev phases/ plan.md → .context-dev.md (336 lines)
Task 1: reads from context → execute
Task 2: reads from context → execute (already in context)
Task 3: reads from context → execute (already in context)
Total: 336 lines loaded (once)
Saving: (tasks - 1) × skill_size per plan. For 1 skill × 3 tasks: ~674 lines (~10,000 tokens) saved. For plans without skills: zero cost (graceful no-op).
Skill resolution: ~/.claude/skills/{name}/SKILL.md (global skills directory).
Dev previously re-read PLAN.md before every task (compaction resilience). Now a deterministic marker signals when re-reading is actually needed:
Lifecycle:
SessionStart hook → rm .compaction-marker (fresh session)
Dev starts task 1 → no marker → reads PLAN.md (initial load)
Dev starts task 2 → no marker → skip re-read (plan still in context)
[compaction occurs] → PreCompact hook writes marker with timestamp
Dev starts task 3 → marker found → re-reads PLAN.md
Dev starts task 4 → marker older than last read → skip re-read
Conservative default: "When in doubt, re-read." Marker check failure or ambiguity triggers re-read. False negatives (unnecessary re-reads) are acceptable; false positives (skipped re-reads when needed) are not.
Saving: Typically 1-2 re-reads saved per plan. At ~500-800 tokens per PLAN.md: ~500-1,600 tokens per plan.
This is the "controllable" overhead — the part that scales with agents, plans, and project size. Per-request overhead (always-on commands + CLAUDE.md) is essentially unchanged.
v1.10.2 v1.10.7 Saving
─────────────────────────────────────────────────────────────────
SMALL PROJECT (3 phases, 10 reqs, 3 Devs, 1 QA per phase)
Command invocations 710 985 -275 (commands grew)
Reference loads 4,860 0 4,860 (eliminated)
Agent definitions 2,840 3,630 -790 (defs grew)
Context reads 10,335 5,295 5,040 (compiled)
Compaction re-reads 3,000 1,000 2,000 (marker saves)
────── ────── ──────
Per-phase non-request 21,745 10,910 10,835 (50%)
× 3 phases 65,235 32,730 32,505
─────────────────────────────────────────────────────────────────
MEDIUM PROJECT (5 phases, 20 reqs, 4 Devs, 1 QA per phase)
Command invocations 710 985 -275
Reference loads 5,925 0 5,925
Agent definitions 3,408 4,285 -877
Context reads 15,770 7,155 8,615
Compaction re-reads 4,000 1,200 2,800
Skill bundling savings 0 -1,600 1,600
────── ────── ──────
Per-phase non-request 29,813 12,025 17,788 (60%)
× 5 phases 149,065 60,125 88,940
─────────────────────────────────────────────────────────────────
LARGE PROJECT (8 phases, 30 reqs, 5 Devs, 2 QAs per phase)
Command invocations 710 985 -275
Reference loads 7,050 0 7,050
Agent definitions 4,544 5,805 -1,261
Context reads 20,385 9,705 10,680
Compaction re-reads 5,000 1,500 3,500
Skill bundling savings 0 -2,400 2,400
────── ────── ──────
Per-phase non-request 37,689 15,595 22,094 (59%)
× 8 phases 301,512 124,760 176,752
Per-request overhead barely changed (+0.5%): active commands grew ~39 lines but CLAUDE.md shrank 26 lines. The context compiler's value is in the spawn/context layer, not the per-request layer.
| Scale | v1.10.2 Total | v1.10.7 Total | Saved | Reduction |
|---|---|---|---|---|
| Small (3 phases, 50 req/phase) | ~226,735 | ~194,230 | ~32,505 | ~14% |
| Medium (5 phases, 80 req/phase) | ~439,065 | ~350,125 | ~88,940 | ~20% |
| Large (8 phases, 80 req/phase) | ~561,512 | ~384,760 | ~176,752 | ~31% |
Stock Teams v1.0.99 v1.10.2 v1.10.7
Per-request overhead 10,800 4,970 3,230 3,245
Per-phase spawn+context 87,100 33,200 21,745 10,910
────── ────── ────── ──────
Total coordination/phase 97,900 38,170 24,975 14,155
Reduction vs stock — 61% 74% 86%
VBW v1.10.7 delivers ~86% reduction in per-phase coordination overhead vs stock Agent Teams (up from 74% at v1.10.2, 61% at v1.0.99).
For large projects, the reduction is even more dramatic because filtered context scales better than full-file loading:
Stock (30 reqs) v1.10.7 (30 reqs) Reduction
Lead spawn context ~5,200 ~1,110 79%
Dev spawn context ~2,400 ~815 66%
QA spawn context ~4,500 ~1,275 72%
Reference loads ~8,000 0 100%
| Milestone | Version | Optimization Type | Cumulative vs Stock |
|---|---|---|---|
| Performance Optimization | v1.0.99 | 15 mechanisms: when/how to load | 61% overhead reduction |
| GSD Isolation | v1.10.0 | Two-marker isolation, PreToolUse block | (security, not tokens) |
| Token Compression | v1.10.2 | Content compression across all layers | 74% overhead reduction |
| Intelligent Discovery | v1.10.5 | Discovery protocol + phase questions | (quality, not tokens) |
| Context Compiler | v1.10.7 | Deterministic context routing | 86% overhead reduction |
/vbw:implement Phase 3:
implement.md loaded: 290 tokens
phase-detection.md loaded: 1,335 tokens ← eliminated
STATE.md + ROADMAP.md reads: 450 tokens
Planning:
Lead spawned (agent def): 568 tokens
Lead reads REQUIREMENTS.md: 750 tokens ← replaced by filtered
Lead reads ROADMAP.md: 600 tokens ← replaced by compiled
Lead reads STATE.md: 800 tokens ← replaced by compiled
Lead reads PROJECT.md: 435 tokens
Execution:
execute.md loaded: 420 tokens
phase-detection.md loaded: 1,335 tokens ← eliminated
Dev 1 spawned: 568 tokens
Dev 1 reads STATE.md: 800 tokens ← eliminated
Dev 1 reads PLAN.md: 600 tokens
Dev 1 re-reads PLAN.md (×2): 1,200 tokens ← mostly eliminated
Dev 2-4 (same pattern ×3): 9,504 tokens
QA spawned: 568 tokens
QA loads verification-protocol.md: 2,190 tokens ← eliminated
QA reads PLAN + SUMMARY: 1,500 tokens
Phase overhead total: ~23,913 tokens
Per-request overhead (×80): 258,400 tokens
Session total for this phase: 282,313 tokens
/vbw:implement Phase 3:
implement.md loaded: 435 tokens (grew, has compile instructions)
phase-detect.sh pre-computed: 300 tokens (replaces 1,335 reference)
STATE.md + ROADMAP.md reads: 450 tokens
compile-context.sh lead: 0 tokens (shell, free)
Planning:
Lead spawned (agent def): 750 tokens (grew slightly)
Lead reads .context-lead.md: 405 tokens ← replaces 3 files (2,150)
Lead reads PROJECT.md: 435 tokens
compile-context.sh dev + qa: 0 tokens (shell, free)
Execution:
execute.md loaded: 550 tokens (grew, has compile instructions)
Dev 1 spawned: 705 tokens (grew, has marker protocol)
Dev 1 reads .context-dev.md: 315 tokens (phase awareness, replaces STATE)
Dev 1 reads PLAN.md: 600 tokens
Dev 1 conditional re-read (×0-1): 300 tokens ← marker saves 1-2 re-reads
Dev 2-4 (same pattern ×3): 5,760 tokens ← 40% less than v1.10.2
QA spawned: 765 tokens (grew, has inline spec)
QA reads .context-qa.md: 510 tokens ← replaces protocol load
QA reads PLAN + SUMMARY: 1,500 tokens
Phase overhead total: ~13,780 tokens (42% less)
Per-request overhead (×80): 259,600 tokens (essentially unchanged)
Session total for this phase: 273,380 tokens
Saving vs v1.10.2: ~8,933 tokens/phase (3.2% total, 42% overhead)
Over the full 5-phase project:
- v1.10.2: ~1,411,565 tokens
- v1.10.7: ~1,366,900 tokens
- Saved: ~44,665 tokens (~3.2% total, but ~51,000 tokens saved in spawn/context layer)
LAYER v1.10.2 v1.10.7 CHANGE METHOD
─────────────────────────────────────────────────────────────────────
Commands (active, 8) 535 574 +39 +phase-detect injection
+compile instructions
Commands (disabled, 21) 1,504 1,567 +63 +compile instructions
Agents (6) 227 242 +15 +inline QA spec
+marker protocol
CLAUDE.md 94 68 -26 Updated for new milestone
References (8→9) 497 656 +159 +discovery-protocol.md
─────────────────────────────────────────────────────────────────────
Static file inventory 2,857 3,107 +250 Files grew (more instructions)
BUT runtime loads changed dramatically:
─────────────────────────────────────────────────────────────────────
Reference loads/phase 4,860 0 -4,860 Eliminated entirely
Agent context loads 10,335 5,295 -5,040 Compiled + removed
Plan re-reads/phase 3,000 1,000 -2,000 Compaction marker
─────────────────────────────────────────────────────────────────────
Runtime savings/phase — — 11,900 NET per phase
The paradox: Static files got larger (+250 lines across inventory) but runtime token consumption dropped by ~11,900 tokens per phase. Instructions grew because they now contain compile-and-route logic. But that logic eliminates multiple runtime file loads per phase, which is a net win.
| File | Lines | Purpose |
|---|---|---|
scripts/compile-context.sh |
164 | Role-specific context compiler (lead/dev/qa) |
| File | Change | Lines Before → After |
|---|---|---|
commands/execute.md |
+phase-detect injection, +compile calls | 155 → 194 |
commands/plan.md |
+phase-detect injection, +compile call | 120 → 146 |
commands/implement.md |
+compile calls in States 3-4 | 160 → 193 |
commands/qa.md |
+phase-detect injection | 65 → 70 |
commands/discuss.md |
+phase-detect injection | 55 → 61 |
commands/assumptions.md |
+phase-detect injection | 38 → 44 |
agents/vbw-dev.md |
-STATE.md read, +marker protocol | 42 → 47 |
agents/vbw-qa.md |
+inline format spec, -protocol ref | 39 → 51 |
config/defaults.json |
+context_compiler toggle | 16 → 17 |
scripts/phase-detect.sh |
+config_context_compiler output | 195 → 202 |
scripts/compaction-instructions.sh |
+marker write | +2 lines |
scripts/session-start.sh |
+marker cleanup | +3 lines |
| File | Lines | Status |
|---|---|---|
| phase-detection.md | 89 | Preserved as developer docs (no longer loaded by agents) |
| verification-protocol.md | 146 | Preserved as developer docs (no longer loaded by agents) |
| vbw-brand-essentials.md | 44 | Still loaded (output formatting) |
| effort-profile-*.md (4) | 124 | Still loaded (effort-gated, lazy) |
| handoff-schemas.md | 94 | Still loaded (agent communication) |
| discovery-protocol.md | 159 | Still loaded (discovery questions, new in v1.10.5) |
Same methodology as v1.10.2 analysis: ~15 tokens/line for markdown. Compiled context files tend toward 10-12 tokens/line (structured bullets, less prose), making the savings slightly conservative.
| Metric | Method | Confidence |
|---|---|---|
| File line counts | wc -l on actual files |
Exact |
| Compiled output sizes | compile-context.sh run on real project |
Exact |
| Reference load elimination | grep confirms zero runtime references |
High |
| Re-read savings | Estimated 1-2 saves per plan (compaction occurs 0-2 times) | Medium |
| Skill bundling savings | Measured for bash-pro (337 lines); other skills vary | Medium |
| Per-request overhead | Line count of active commands + CLAUDE.md | High |
| Scale projections | Linear extrapolation from known file growth patterns | Medium |
| Component | Why Unchanged |
|---|---|
| Per-request overhead | Not the target — commands grew slightly but reference loads moved to compile time |
| Template loads | Already compressed in v1.10.2 — no further optimization available |
| Agent model routing | Already optimal — Sonnet for QA, Opus for Lead/Dev |
| Hook execution costs | Already zero model tokens — shell execution |
disable-model-invocation |
Already prevents loading disabled commands — unchanged |
| Phase | Plans | Checks | Result | Key Validations |
|---|---|---|---|---|
| Phase 1: Quick Wins | 01-01, 01-02 | 21/21 | PASS | Zero runtime refs to phase-detection.md; STATE.md absent from Dev; inline QA spec functional |
| Phase 2: Compiler Core | 02-01, 02-02 | 22/22 | PASS | compile-context.sh produces correct output for all 3 roles; config toggle works; graceful degradation verified |
| Phase 3: Compound | 03-01, 03-02 | 22/22 | PASS | Skill bundling produces correct output; compaction marker written/cleaned; conservative default preserved |
| Total | 6 plans | 65/65 | PASS |
-
Context routing compounds with content compression. v1.10.2 made files smaller. v1.10.7 ensures agents only see files relevant to their role. Together: smaller files × fewer files = multiplicative savings.
-
The spawn/context layer is the high-leverage target. Per-request overhead (always-on commands + CLAUDE.md) barely changed. But spawn/context overhead — agent definitions, state reads, reference loads — was cut 40-50%. This is where tokens scale with project complexity.
-
Requirement filtering is the highest quality-impact mechanism. A Lead that sees 5 focused requirements produces more targeted plans than one that sees all 30 and self-filters. The token saving is a bonus; the quality improvement is the real win.
-
Deterministic beats probabilistic. Every mechanism in this milestone is deterministic. The compiler uses grep/sed on known formats, not LLM interpretation. The compaction marker is a file timestamp, not LLM self-evaluation. Deterministic signals are cheaper and more reliable.
-
Graceful degradation is mandatory at every level. Every compile step has
2>/dev/null || fallback. Every config check has a default. Thecontext_compiler: falsetoggle reverts everything. This means zero risk of regression — the worst case is v1.10.2 behavior. -
Static file growth is acceptable when runtime loads decrease. Files grew +250 lines but runtime loads dropped ~11,900 tokens per phase. The instructions cost ~250 tokens once (when the command is loaded) but save thousands across multiple agent spawns.
-
Scale-dependent value is the right design. Small projects see ~15% savings — modest but free. Large projects see ~35% savings — significant and precisely where token pressure is highest. The compiler's value grows with the problem it solves.
15 commits in chronological order (plus release commit):
| # | Hash | Message | Phase/Plan |
|---|---|---|---|
| 1 | 0789b24 | fix(hooks): restore pre-push-hook.sh actual validation logic |
Pre-phase |
| 2 | 91741d7 | refactor(commands): replace phase-detection.md reads with pre-computed phase-detect.sh injection |
P1/01-01 |
| 3 | cb609a3 | refactor(agents): remove STATE.md from Dev, inline QA format spec, pre-compute verification tier |
P1/01-02 |
| 4 | 3b89b98 | feat(context): create compile-context.sh with lead role output |
P2/02-01 |
| 5 | d7088a7 | feat(context): add dev and qa role outputs to compile-context.sh |
P2/02-01 |
| 6 | cc72b78 | feat(config): add context_compiler toggle to defaults.json and phase-detect.sh |
P2/02-01 |
| 7 | 50a027a | feat(context): wire compile-context.sh into plan.md before Lead spawn |
P2/02-02 |
| 8 | ae3cb20 | feat(context): wire compile-context.sh into execute.md before Dev and QA spawns |
P2/02-02 |
| 9 | 0bc9641 | feat(context): wire compile-context.sh into implement.md States 3-4 |
P2/02-02 |
| 10 | 19e3b35 | feat(03-02): add compaction marker write to compaction-instructions.sh |
P3/03-02 |
| 11 | 89a48d6 | feat(03-02): add compaction marker cleanup to session-start.sh |
P3/03-02 |
| 12 | 5d96bd1 | feat(03-02): update vbw-dev.md for marker-based conditional re-read |
P3/03-02 |
| 13 | 21fee65 | feat(compiler): add plan-path arg and skill bundling to compile-context.sh dev case |
P3/03-01 |
| 14 | caa4b84 | feat(commands): pass plan_path as 4th arg to compile-context.sh in execute.md |
P3/03-01 |
| 15 | ace5135 | feat(commands): pass plan_path to compile-context.sh dev call in implement.md |
P3/03-01 |
| 16 | f4aab7a | chore: release v1.10.7 |
Release |
## Phase 02 Context (Compiled)
### Goal
Build compile-context.sh that produces role-specific context files with filtered requirements
### Success Criteria
Running compile-context.sh produces .context-lead.md with only phase-mapped requirements...
### Requirements (REQ-06, REQ-07, REQ-08, REQ-09, REQ-10, REQ-11, REQ-17, REQ-18)
- [ ] **REQ-06**: compile-context.sh script extracts phase-relevant requirements...
- [ ] **REQ-07**: Compiler produces .context-lead.md with phase goal...
[8 requirements shown, 10 filtered out]
### Active Decisions
- Deterministic context compilation over ML-based scoring
- Marker-file approach for compaction detection
[6 decisions total]27 lines replacing 122 lines of full-file reads (REQUIREMENTS + ROADMAP + STATE).
## Phase 03 Context
### Goal
Add skill bundling and compaction-aware re-reads on top of the compiler
### Conventions
- [file-structure] Commands are kebab-case .md files in commands/
- [naming] Agents named vbw-{role}.md in agents/
[15 conventions total]
### Skills Reference
#### bash-pro
[337 lines of skill content — loaded once, not per-task]336 lines loaded once per phase, instead of 337 × 3 tasks = 1,011 lines.