Finish What You Start

Context engineering for Claude Code. Load what you need, when you need it — 150k tokens down to 12k. Sessions that last 20+ exchanges instead of crashing at 7.

$ /plugin marketplace add qf-studio/navigator
$ /plugin install navigator
> "Start my Navigator session"
✓ 12k loaded · run /nav:stats for your efficiency report

Install plugin → · Read the docs →

The loop you’re stuck in

AI coding sessions crash at exchange 5–7. The context window fills with documentation you never use.

exchange 5  →  Claude forgets your recent changes
exchange 7  →  hallucinations start ("that function doesn't exist")
exchange 8  →  context limit reached
            →  restart · reload · re-explain · repeat

Why: you loaded 150,000 tokens of documentation “just in case.” You used 8,000. The rest is noise drowning out signal — and it’s what ends your session early.

Load what you need, when you need it

Strategic loading beats bulk loading. Three steps, no command memorization.

1. Start your session — say “Start my Navigator session.” Navigator loads a ~2k index of what exists, not 150k.
2. Work the feature — it lazy-loads relevant docs on demand: the task doc when you open a task, a system doc only if the work touches it.
3. Finish it — sessions run 20+ exchanges and ship. When done, Navigator commits, archives the task doc, and closes the ticket on its own.

index 2k + task doc 3k + system doc 5k (only if needed)  =  ~12k loaded
                                          vs  150k loaded upfront

Enforced by a runtime, not by prose

Instructions in CLAUDE.md are suggestions — the model can ignore them, and under context pressure it does. As of v7.0.0, Navigator’s behaviors are enforced by a hook runtime instead: one dispatcher (hooks/nav_dispatch.py) routes op modules through a pipeline (gates → responders → injectors → recorders) across 13 Claude Code events. Fail-open by design — a dispatcher crash never blocks your session.

• Behaviors are config, not mandates. The v6 prose mandates (WORKFLOW CHECK blocks, the session-start ritual, the forbidden-actions list) are retired. Each behavior is now an op with an off-switch in .agent/.nav-config.json — the root CLAUDE.md shrank from 988 to 331 lines.
• New in v7 (blocking features ship disabled): zero-token instant answers for five exact commands (nav stats, graph health, …), a completion gate that derives six indicators from observable turn evidence (git tree, test runs, docs) before accepting “done”, knowledge-graph injection for subagents and failure diagnosis, and task-lifecycle graph sync.
• Validated before shipped. All nine v6 behaviors byte-matched a recorded corpus before any new behavior landed; the conformance suite re-runs per Claude Code version (results checked in), after ~7 weeks of dogfooding on two real workloads.

How the runtime works → · Configuration → · Workflows →

See where you are

Since v8 Navigator runs inside Claude Code and draws. Type /nav and a pane opens next to the chat; one line above the prompt says where you are.

• Next — the step you’re on, as a button. Press it and it becomes your next prompt, with an ETA from your pace so far.
• Off route — two prompts in a row that have nothing to do with the task, and the card turns orange: park the detour as a task, go back, or switch.
• Judge — what the typed judge made of your last prompt and what Navigator did about it.
• Context — how full the window is, and whether it’s time to compact.

How the pane works →

Same workflows. More capabilities.

Navigator is a superset, not an alternative. Everything you’d expect from a workflow plugin, plus context engineering and autonomy.

See it on your own sessions

NAVIGATOR EFFICIENCY REPORT  (example)
Project documentation: 150,000 tokens
Loaded this session:    12,000 tokens
Tokens saved:          138,000 tokens (92% ↓)
Context usage:             35%
Efficiency score:       94/100

• 92% fewer tokens loaded
• 20+ exchanges per session (vs 5–7 without)
• ~97.7% marker compression (a ~130k conversation → a 2–5k marker)
• Run /nav:stats for yours

Built for the way you actually ship

When Navigator earns its keep

• Long feature work that used to die mid-session — lazy loading + context markers mean the feature ships in one sitting, and a compact never loses your place.
• Unattended runs you can trust — “Run until done” iterates with stagnation detection; the completion gate checks evidence (tree clean? tests ran?) before accepting “done.”
• Team memory that survives people — decisions, pitfalls, and SOPs are queryable and git-tracked; new developers ask “What do we know about payments?” instead of reading 150k of docs.
• Zero-token answers — nav stats, show features, graph health are answered deterministically by the runtime. Instant, and they can’t hallucinate.

All seven use cases →

Up and running in 30 seconds

# 1. Install
/plugin marketplace add qf-studio/navigator
/plugin install navigator
# (then restart Claude Code)
 
# 2. Initialize (once per project)
"Initialize Navigator in this project"
 
# 3. Start every session
"Start my Navigator session"

That’s it. Navigator handles the rest — lazy loading, commits, docs, and tickets.

Open source. Verified. A superset of what you already use.

MIT License · open source on GitHub  · OpenTelemetry-instrumented

Stop restarting. Start shipping.

92% fewer tokens loaded. 20+ exchange sessions. Measured on your own work.

Install plugin → · Read the docs →

Finish what you start.