context-horizon
Supports Google Antigravity and Gemini CLI as target hosts, providing hook installation, a telemetry sidepane with context health and cache TTL views, automated context compression, and session auditing for token waste and cold-cache spikes.
Supports OpenAI Codex CLI as a target host, enabling installation of context-management hooks, token-usage auditing, output compression, and cache-aware session optimization.
This server does not currently have a deployable release on Glama. Follow the repository's setup instructions to install and configure it for your MCP client, including any required credentials and local dependencies.
Highbeam (ctxtop v4.1) — Active Context Surgeon, KV-Cache Shield & Token FinOps for Claude Code, Google Antigravity & MCP Hosts
Local Context Window Profiler, KV-Cache TTL Monitor, Multi-Family FTS5 Output Compressor & Deterministic PreInvocation / PreToolUse Surgeon (~0.1–2.9ms avg Tier-1 In-Process · ~58ms Warm IPC / ~105ms Cold Windows Tier-2 Hook) across Google Antigravity, Claude Code, Codex CLI, Gemini CLI & Cursor
Live Interactive Demo • 10-Second 5-Host Audit • Quick Start • Cookbook • Benchmarks • Enterprise MDM
⚡ Try in 10 Seconds (Zero Hooks / Zero Writes)
Before installing any hooks or modifying config files, scan your last 7 days of local Google Antigravity, Claude Code, OpenAI Codex CLI, Gemini CLI, and Cursor sessions strictly read-only to measure preventable token waste, cold-cache spikes, and oversized tool dumps:
npx ctxtop audit --days 7[Highbeam Session ROI Audit] Window: 7d | Platform: all | Sessions: 12
Sludge Tax Preventable : 1,420,850 tok ($2.84 USD)
Cold-Cache Spikes (>5m): 14 | 3x Thrash Loops: 4
Un-Sliced Large Reads : 11 | Oversized Tool Dumps: 38Related MCP server: ctx-memory
🚀 Installation & Quick Start
Google Antigravity (1-Line Install) | Claude Code (1-Line Install) | Cursor / Windsurf / Codex / Gemini CLI |
```bash | ||
npx ctxtop init | ||
``` | ```bash | |
npx ctxtop install --global | ||
``` | ```bash | |
npx ctxtop init --cursor --windsurf --codex --gemini-cli |
| *Workspace-only*: `npx ctxtop init --workspace`<br/>*Health check*: `npx ctxtop doctor` | *StatusLine HUD*: `npx ctxtop statusline --demo`<br/>*In-chat pane*: `/horizon` · `/cost-radar` · `/handoff` | *Universal `.mcp.json`*: `npx ctxtop init --all-hosts`<br/>*FTS5 search*: `npx ctxtop search "<keyword>"` |
### Your First 5 Minutes After Installing
#### 1. Google Antigravity Workflow
1. **Install hooks & sidecar**: Run `npx ctxtop init` in your project root (or globally).
2. **Open the Highbeam Sidepane**: Launch the local telemetry WebView (`npx ctxtop ui` or via the Antigravity sidepane) to view real-time context health:
- **Simple View (Default)**: 4 glanceable zones—**Zone A** (Safe Headroom & Warm KV Cache TTL), **Zone B** (`DO / AVOID / HOLD` Model & Effort switch guidance), **Zone C** (Live automated interventions), and **Zone D** (Verified tokens/USD saved + 1-click `/compact`).
- **Advanced View (1-Click Toggle)**: Expands the **40-Cell Chrono-Positional Recall Grid** (`Primacy 0–30%`, `Mid-Trough 30–70%`, `Recency 70–100%`), top token consumer file table, `Off / Coach / Auto` mode switcher, and the full `DET-01..32` guard log.
3. **Code normally**: Highbeam runs in **`COACH` mode** by default—automatically compressing verbose CLI test dumps via SQLite FTS5 and folding repeat file reads without interrupting your prompts.
#### 2. Claude Code Workflow
1. **Install plugin & hooks**: Run `npx ctxtop install --global` (or `npx ctxtop init --claude`) to wire `.claude-plugin/plugin.json`, `hooks/hooks.json`, and the live terminal `statusLine`.
2. **Watch the Live Terminal `statusLine`**: At the bottom of your terminal, Highbeam renders an auto-adapting (`80 / 110 / 144` col) telemetry bar:
```text
AH [SCCCCCCC................] sonnet-5-5 64k/200k (32%) · Cache 88% (4m12s) · COACH · Saved $1.84Open the In-Chat Docked HUD: Type
/horizonin chat (or runnpx ctxtop panelfor the standalone HTML workbench) to inspect cache gravity, active guards, and reclaimable tokens.
🧭 Built-In Slash Skills & In-Chat Commands (Both Hosts)
All 6 slash skills are registered identically in both Google Antigravity (plugin.json) and Claude Code (.claude-plugin/plugin.json):
Slash Command / Skill | When to Use It | What It Outputs |
| Anytime during a coding session | Renders the live 40-cell Context Health HUD, KV-Cache TTL countdown, active |
| Before sending a complex refactor prompt or switching models | Audits prompt specificity (6-dimension rubric), checks horizon-aware KV-cache break-even ( |
| Before running | Distills active plan checkboxes, modified files, and unresolved |
| When reviewing session token burn or cache busts | Generates an interactive HTML/SVG timeline of prefix-cache retention, |
| When diagnosing slow tools or subagent fan-out | Visualizes session trajectory call-tree spans, per-tool latencies, and token attribution as a standalone artifact. |
| After correcting agent mistakes across a session | Audits |
Quick In-Chat Prompt Prefixes:
! <prompt>— BypassPreInvocationchecks for a single turn.!lock <prompt>— Freeze current reasoning effort tier and prefix state for the remainder of the session.#check <prompt>— Force an explicit pre-flight scorecard and concrete prompt rewrite suggestion.
🛡️ Example Session Receipt: +164.0k Tokens Saved in One 4-Step Loop
Most CLI trackers passively count tokens after your quota is already burned. Highbeam intercepts redundant reads, compresses noisy test dumps via local SQLite FTS5, and shields warm KV prefixes before they hit your billing meter:
Step in Coding Loop | Developer / Agent Action | Highbeam Active Intervention (Zone C) | Verified Incident Savings |
1. Warm KV Cache + Repeat Read | Agent re-reads an unmodified 800-line source file on a | GUARD-4 intercepts the duplicate read ( |
|
2. Failing Test Suite Dump |
| SQLite FTS5 BM25 Compressor indexes raw stdout locally and injects only the 160-token failing assertion digest |
|
3. Mid-Session Rule Edit | Agent updates | PrefixCacheShield queues the rule delta until TTL expiry or |
|
Example Incident Receipt | 4-Step Feature / Bugfix Loop | Zero context dilution · 100% critical error retention |
|
Reconciled Monthly Expectation: Across normal coding weeks without deliberate cache-busting, our bottom-up benchmark model estimates
~$9.42/wk(~$40.79/mo,~6%–11%of raw API spend) saved for a full-time agentic developer, alongside30%–50%longer 5-hour subscription sprints by cuttingO(N²)tool-log compounding.
💡 Why Saved Tokens Multiply (O(N²) Turn Compounding, Quota Life & Model IQ)
In agentic coding, every turn re-sends the entire prior conversation history. A single 15,000-token raw test dump on Turn 5 is not billed once—it is re-sent on Turns 6 through 25, burning 300,000 cumulative tokens (15,000 × 20).
For Fixed-Subscription Users (
Claude Pro / Max,Antigravity OAuth Seats) — Stop 2:00 PM Quota Lockouts & Context Rot:Compressing noisy tool outputs and duplicate file reads on early turns prevents
O(N²)history compounding, stretching 5-hour sprint quotas by30%–50%.Staying below the 70% Safe Horizon prevents Context Rot (middle-window attention decay where the model starts overlooking
AGENTS.md/CLAUDE.mdrules or hallucinating imports).
For Metered API & Enterprise Teams — Self-Expensing FinOps ROI:
Preventing accidental warm-cache busts plus automatic FTS5 log compression saves
~$40.79/mo($9.42/wk) for average full-time API devs (~$149/mofor heavy 100k–200k Opus swarm users).
Daily Cockpit Decisions No Human Can Calculate in Their Head (Zone B):
"If I downshift from Opus to Sonnet right now, will I save quota or pay a 10x cold-prefill penalty?" — Highbeam computes the horizon-aware KV-cache break-even limit (
C_max) and post-switch warm-request payback in real time and displays a 1-line verdict:Model: Hold (03:34) — switching busts warm cache.
⚙️ What Runs Automatically (100% Free COACH Default)
Highbeam defaults to COACH mode—performing lossless token surgery silently in the background while never blocking your chat prompt unless a 3-strike identical failure loop or destructive git command occurs:
Automated Feature | How It Works Under the Hood | Developer Experience |
1. SQLite FTS5 CLI & Test Output Compression ( | Strips ANSI/progress noise, indexes full stdout in local SQLite FTS5 ( | 100% automatic — saves |
2. Post-Edit Delta Diffs & 3rd-Read AST Stubs ( | When the agent re-reads a file after editing 5 lines (or reads the same unclipped file | 100% automatic — cuts repeat-read token burn by |
3. | Intercepts mid-session edits to | Model-aware cache protection — prevents silent cold prefix rebuilds without false-positiving on |
4. Live Model & Effort Switch Verdict ( | Evaluates remaining KV cache TTL ( | Instant visual guidance — tells you when to hold vs. switch models or lower thinking effort |
5. Held Downshift & Boundary Lifecycle ( | Surfaces held | Post-compact downshift handoff — reminds |
6. Git Hook-Bypass & Destructive Shell Guard ( | Blocks | Zero-config repo safety — keeps frustrated agents from bypassing your pre-commit linters |
7. | Computes break-even ( | Protects mid-session switches — prevents losing money on short-horizon downgrades while allowing profitable early switches |
📊 Empirical Wire Highlights (Claude Code 2.1.325)
Highbeam's cache-economics engine is backed by 45 pre-registered randomized runs (540 live wire-reconciled turns) and 6 live 30-turn compaction studies against first-party Anthropic via OpenRouter:
Downgrading Mid-Chat Can Cost More Than Staying on Opus: At
~58kcontext, switchingOpus 4.6 -> Sonnet 4.6at Turn 6 produced a0.0%cache hit (+$0.1783spike) and increased 12-turn session cost ($0.8611vs$0.7789Opus control).Changing
--effortBusted4.6Caches (+$0.0853), Fixed in5.5: Wire diffs caughtoutput_config.effortinvalidating4.6prompt caches whileclaude-sonnet-5-5preserved warm cache hits (n = 3).Stock
/compactScored0/6Violations Up to28.10xCompression: Because default compaction preserved constraints cleanly without custom templates, Highbeam emits zeroPreCompactbloat.MCP / Tool-List Swaps on
--resumeWipe Cache;CLAUDE.mdEdits Do Not: Highbeam hashes.mcp.json/.claude/settings*.jsonacross resumes and warns before uncached rebuilds.
👉 See full methodology, per-arm datasets, SDK stream-json set_model patterns, and explicit unverified boundaries in docs/EMPIRICAL_BENCHMARKS.md.
🌱 Zero-Waste AI Engineering: FinOps + GreenOps (Scope 3 Compute Efficiency)
For systems engineers, re-sending a 40,000-token test log 15 times is the AI equivalent of a memory leak—it wastes datacenter GPU prefill cycles, increases time-to-first-token (TTFT) latency, and degrades reasoning quality.
For Engineering Managers and Enterprise FinOps / Sustainability teams, every 1,000,000 redundant frontier LLM tokens prevented avoids approximately ~0.65 kWh (650 Wh) of datacenter GPU prefill energy (~247g CO₂e and associated cooling water). Highbeam's local Corporate PDF 1.4 Expense Receipt (npx ctxtop receipt --pdf) automatically reports both Verified USD Saved (FinOps) and Estimated GPU Compute Energy Avoided (GreenOps / Scope 3) with a cryptographic SHA-256 audit digest—giving teams a dual cost-and-sustainability justification with zero cloud telemetry.
Why Highbeam (ctxtop) Exists (vs. Cloud LLM Observability)
Cloud trace platforms (Langfuse, Helicone, Arize) require proxying API keys over the network and only observe HTTP request/response payloads. They have zero visibility into the local filesystem, git working tree, IDE process table, or local SQLite/JSONL session stores.
ctxtop is a zero-dependency local systems profiler built on Node.js built-ins (node:sqlite, node:fs, node:http). It correlates local session transcripts and SQLite databases with live disk state to catch concrete failure modes that cloud proxies cannot see:
Failure Mode | Root Cause in Agentic Sessions | How |
12.5x–80x Prompt Cache Tax & Overage TTL Cliffs | Falling from a 1-hour prompt cache tier to a 5-minute overage/fallback tier, or mutating system/MCP blocks mid-session while holding | Tracks Dual-TTL windows ( |
Compaction Lobotomy & Post-Compact Re-Read Tax | Autocompact at 80%–95% context wipes file line numbers, active | Deterministically distills |
30GB–100GB Local IDE Storage Bloat ( | Orphaned Cursor | Audits and reclaims orphaned rows via streaming read-only SQLite export ( |
Stale File Overwrites ( | Developer edits or runs | Compares |
Unseen Call-Site Breakage ( | Agent modifies an exported function signature without reading downstream callers in the repo. | Runs a bounded |
Superseded Full-File Reads & Tool Sludge ( | Agent reads the same 800-line file 6 times, runs unreferenced exploratory | Pairs |
Turn-0 MCP Schema Bloat ( | Eagerly loaded MCP servers inject 15k–40k tokens of JSON tool schemas on Turn 0 even when never invoked. | Computes per-server Token ROI ( |
Multi-Harness v4.0 Wedge Capabilities
Cross-Harness SQLite & Protobuf Trajectory Stitcher (
src/core/trajectory_stitcher.mjs):Google Antigravity (
[App],[IDE],[CLI]): Zero-dependency protobuf wire-walker (decodeProtobufWire) inspectsconversations/<uuid>.db(stepstable binarystep_payloadandmetadatablobs) in strict read-only mode to extractfile:///workspace URIs and stitch withtranscript_full.jsonlandannotations/<uuid>.pbtxt.Claude Code: Reconstructs the
uuid -> parentUuidDAG up to the activeleafUuid, isolating/rewindbranches,file-history-snapshotrestore points, and Turn-1cache_creation_input_tokens.Cursor: Correlates
composerData:<id>,bubbleId:<id>:<bubble>,messageRequestContext, andagentKv:blob:*(requestId) withstore.dband timestamp-lessagent-transcripts/*.jsonl.
Subagent Worktree & File Collision Detector (
src/core/subagents.mjs):Builds a parent-to-child subagent DAG, tracks independent 5-minute child cache TTLs, and flags
SUBAGENT_FILE_COLLISIONwhen>= 2concurrent subagent branches edit the same canonical file path.
SQLite FTS5 Episodic Memory & Git Commit Token Ledger (
src/core/episodic_memory.mjs,src/core/git_ledger.mjs):Indexes historical session decisions, modified files, and resolved bug signatures into a local SQLite FTS5 (
porter unicode61) store (~/.ctxtop/episodic_memory.sqlite) for<1,000-token BM25 retrieval.Correlates
.git/logs/HEADcommit timestamps against session windows to attribute input/output tokens, cache hit %, and USD cost per git commit.
Zero-PII Sanitizer & Forensic Snapshot Exporter (
src/core/sanitizer.mjs):Scrubs API keys (
sk-ant-*,sk-proj-*,AIza*), GitHub PATs (ghp_*,github_pat_*), AWS keys, Bearer tokens,.envvalues, and OS home paths (<USER_HOME>) before exporting shareable forensic JSON snapshots.
Quick Start
1. Inspect Live Sessions, Prune Tool Sludge, or Run Storage GC
# Audit the last 5 local sessions for duplicate file reads, dead errors & MCP schema tax
node src/cli/postmortem.mjs --last 5
# Run environment & transcript health diagnostics (hooks, SQLite/JSONL confidence, 3-way mirror SHA-256)
node src/cli/doctor.mjs
# Run offline Prefix-Safe Tool-Output Surgeon on the active session transcript (with atomic backup)
node src/cli/doctor.mjs --prune-tools --dry-run
# Recover orphaned Antigravity brain/ directories or compact Cursor state.vscdb without VACUUM locks
node src/cli/doctor.mjs --recover-brain --gc-cursor --vscdb path/to/state.vscdb --dry-run
# Print the 40-cell ANSI status bar for the active session
node src/cli/horizon_hud.mjs --live2. Launch the Local Telemetry WebView (127.0.0.1)
# Start the loopback sidecar daemon and open the Tufte WebView
node sidecars/horizon-daemon/server.mjs3. Install Lifecycle Hooks & CLI statusLine
# Global install (~/.gemini/config/plugins/agy-horizon-flightcheck)
node src/cli/init.mjs init
# Workspace-local install (.agents/plugins/agy-horizon-flightcheck)
node src/cli/init.mjs init --workspaceLooking for copy-paste recipes for Cursor 50GB storage reclamation, offline tool pruning, Antigravity brain recovery, or programmatic Node.js API snippets? See thectxtop Cookbook & Recipes.
Systems Architecture & Zero-Trust Security
ctxtop is engineered for strict operational safety alongside live IDE/CLI database writers:
Zero Outbound Network Connections:
0 runtime
npmdependencies (package.jsonhas nodependenciesblock).0 external HTTP/HTTPS requests, telemetry beacons, or remote API calls. All parsing, classification, and routing run 100% in-memory on the local machine.
The local WebView daemon (
sidecars/horizon-daemon/server.mjs) binds strictly to127.0.0.1(loopback only) and rejects cross-originOriginor non-localHostheaders (HTTP 403) to prevent DNS rebinding and drive-by localhost CSRF.
Read-Only Database & Transcript Introspection (
SQLITE_OPEN_READONLY):Every connection to Antigravity or Cursor SQLite databases (
conversations/<uuid>.db,conversation_summaries.db,state.vscdb,store.db) is opened via Node's nativenode:sqliteDatabaseSyncwithObject.freeze({ readOnly: true })(SQLITE_OPEN_READONLY).ctxtopcan never contend for write locks with an active IDE or CLI.Live JSONL transcripts (
transcript_full.jsonl/transcript.jsonl) are read viafs.openSync(filePath, 'r')using byte-offset slicing (O(Δbytes)per turn), falling back to full re-parse only when a step-index regression (Undo/Rewind) is detected.
Ring 1 Security, Concurrency & Context Hygiene Boundaries:
DET-19Git Hook-Bypass Guard: Interceptsgitexecution via.agents/shims/wrappers, strips.agents/shimsfromPATHto eliminate recursion, blocks verification evasion (--no-verify, standalone-n,-amn,--no-gpg-sign,core.hooksPath), and allows bypass strictly via a 60-second single-use cryptographic human nonce.Zero-Token Subagent IPI Sanitizer: Deterministically strips Unicode Tag characters, zero-width spaces, bidi overrides, HTML comments, and delimiter breakouts in
<1ms, framing external research digests safely at prompt tails under<untrusted_subagent_data>.Pre-Threshold ANSI Normalization (
DET-14b): Strips ANSI escape sequences and collapses carriage returns (\r) before the 4,096-char threshold and SQLite FTS5 archival, featuring specialized noise profiles forcargo testandnpm installwith Critical Error-Line Recovery.Concurrent Scope Lockfile (
DET-20): Manages.agents/locks/active_scopes.jsonwith atomic writes, auto-evicting dead PIDs and expired leases (>300s), while alerting on multi-agent file collisions with 1-clickgit worktree addcommands.
Locked v4.0 Edward Tufte UI Laws:
Law 1 (Raw Physical Units Only): Displays
Tokens + %,Cache Hit %,Waste Tokens, and1h/5m TTL Countdownside-by-side—never arbitrary0–100gamified scores.Law 2 (40-Cell Hero + Top 3–5 Riskiest Cells): Surfaces the top 3–5 highest-risk context cells directly below the 40-cell flamegraph with exact file paths, attention recall %, and 1-click
[Re-Anchor / Prune]actions.Law 3 (Zero-Click Passive Workload Tag): Passively classifies sessions into
[Mode: Read-Heavy Audit],[Mode: Multi-File Refactor], or[Mode: Subagent Swarm]from tool-call ratios.Law 4 (Silent-When-Nominal Watchdog): Host RAM and orphan process counters remain completely hidden unless an anomaly (
orphanCount > 0orZOMBIE_LEAK) occurs.
🔧 Configuration, Flight Modes & MCP Server (@ctxtop/mcp)
1. Customizing .attention-horizon.json (Flight Modes & Detector Overrides)
Highbeam works with zero configuration out of the box (COACH mode). To customize behavior per-repository or globally (~/.attention-horizon.json), use the CLI or create .attention-horizon.json in your workspace root:
# Set a detector to warn-only, block, or off via CLI
npx ctxtop config DET-08 warn
npx ctxtop config DET-19 block{
"flightMode": "COACH",
"turnZeroTokenBudget": 20000,
"detectors": {
"DET-06": "block",
"DET-07": "block",
"DET-08": "warn",
"DET-09": "block",
"DET-19": "block",
"DET-20": "warn"
}
}"COACH"(Default): Compresses CLI output (DET-07), folds repeat file reads (GUARD-4), and stages warm rule edits (DET-09) automatically while advising on model/cache switches without blocking normal flow."AUTO_PILOT": Enforces strict pre-turn & stop-gate verification locks (e.g., requiring tests to run after source edits before session completion)."SILENT"/"OFF": Passive telemetry collection only.
2. Using Highbeam as an MCP Server (npx ctxtop mcp)
Any MCP-compatible client (Google Antigravity, Claude Code, OpenAI Codex CLI, Gemini CLI, Cursor, Windsurf, or Claude Desktop) can auto-configure Highbeam via npx ctxtop init --cursor --windsurf --codex --gemini-cli or run standard JSON-RPC stdio directly:
{
"mcpServers": {
"highbeam": {
"command": "npx",
"args": ["-y", "ctxtop", "mcp"]
}
}
}Exposes 7 standalone zero-network MCP tools (<5ms response): horizon_status, cache_gravity_check, scope_lock_claim, export_receipt_pdf, horizon_compress_cli, horizon_search_logs, and horizon_audit_sessions.
For centralized organization deployment (Jamf / Intune / GPO), CHECKSUMS.sha256 verification, and BYO-Grafana OpenTelemetry telemetry, see Enterprise & MDM Deployment Guide.
📦 Editions: Free (MIT Core + COACH) vs. Pro & Team
Feature / Capability | Free Core ( | Highbeam Pro ( | Team / FinOps ( |
Simple & Advanced 40-Cell HUD + | ✅ | ✅ | ✅ |
Multi-Family FTS5 Compression ( | ✅ | ✅ | ✅ |
Automated Repeat-Read Delta Diffs & AST Stubs ( | ✅ | ✅ | ✅ |
| ✅ | ✅ | ✅ |
| Preview | ✅ | ✅ |
30-Day Chronic Offender Memory & Workspace Savings Ledger | — | ✅ | ✅ |
Signed Corporate PDF 1.4 FinOps + GreenOps Receipt ( | — | ✅ | ✅ |
Shared | — | — | ✅ |
Commercial SKU Summary (Offline Ed25519 CTXP1 Activation via npx ctxtop license activate <key>):
Pro Monthly (
$15/mo) & Pro Annual ($149/yr,~$12.42/mo): 1 developer seat, 14-day zero-network local trial (npx ctxtop trial), expensable vianpx ctxtop receipt --pdf.Pro Founder Lifetime (
$199one-time, capped at200seats): Lifetime solo Pro entitlement (expiresAt: null).Team Starter (
$299/yrfor 5 seats) & Team FinOps ($39/seat/mo): Multi-seat MDM rollout, shared.agents/rules/primacy governance, and BYO-Grafana OpenTelemetry pack (npx ctxtop team-pack).
Deterministic PreInvocation Router & 6 Local Sensors
When registered in hooks.json, src/hooks/pre_invocation.mjs evaluates incoming prompts across 8 deterministic router states (Tier-1 In-Process PreInvocation: ~0.1–2.9ms avg / ~3.4ms p95 inside a warm V8 isolate; Tier-2 CLI Hook End-to-End Wall Time on Windows: ~58ms p50 warm daemon IPC / ~105ms avg cold fallback (~25–60ms POSIX) including Node process startup):
ALLOW_SILENT: Immediate pass-through ({}) on!bypass prefix or healthy turns.ALLOW_ACTIVE_SET: Silent pass-through when referenced files are already warm in the last 5 turns.ALLOW_PLAN_OR_SUBAGENT: Silent pass-through during/planmode or subagent delegation.INJECT_CONTEXT_GUARD: Appends asystemMessagewarning when target files were modified externally on disk (DIRTY_SNAP), have unseen callers (UNSEEN_CALLERS), or touch deprecated paths (LEGACY_POISON).STEER_SUBAGENT: Advisesinvoke_subagentwhen a broad exploratory prompt would pollute a warm>30k-token parent context window.HALT_HYGIENE_OR_SAFETY: Halts execution (or warns inadvisorymode) on context ceiling breach, 3-strike identical command error loops, or severe duplicate-read dilution.HALT_EFFORT_OR_QUOTA: Warns when 5-hour/7-day quota falls below the configured floor (10%) or when>600-line single-shot file rewrites risk output stream truncation.HALT_REWRITE_SCORECARD: Triggered via#checkor vague cold-start prompts (Turn <= 2), outputting a 4-line prompt rewrite scorecard.
CLI Commands & Forensic Postmortem
Command | Description |
| Zero-write, hookless 5-host audit of Sludge Tax, cold-cache spikes, and oversized tool dumps. |
| Installs Google Antigravity, Claude Code, and 1-command MCP configurations across editors & CLIs. |
| Searches local SQLite FTS5 offloaded CLI dumps and artifacts via BM25 matching. |
| Installs Claude Code |
| Launches the local HTTP/SSE telemetry daemon ( |
| Starts the standalone zero-network 7-tool JSON-RPC stdio MCP server ( |
| Validates hook registration, FTS5 offload readiness, warm-IPC path, model ceilings, 3-way SHA-256 parity, and SQLite health. |
| Scans the last |
| Exports a SHA-256 verified FinOps + GreenOps token/USD savings receipt for the active workspace. |
| Verifies cryptographic SHA-256 integrity of all tracked release files against |
| Prints a terminal forensic summary of recent sessions with top duplicate-read file offenders and copy-pasteable remediations. |
| Plays the 5-stage terminal crisis simulation across synthetic fixtures. |
Verification & Benchmarks
Run the full zero-dependency test and verification suites (1,060+ tests across 215+ suites — see Empirical Benchmarks & Compression & Antigravity Parity Report):
# Full Coach, UI, & 360° Capability-Proof suite
npm run test:coach
# Claude Code dual-tier Mod, CLI hooks, statusLine, and 5-category ledger suite (195 tests)
npm run test:claude
# Unit & Multi-Harness Wedge suite (89 tests across 31 suites)
npm run test:unit
# Architectural verification suite (Gates 0-6 & Phases 1-7: SQLite read-only locks, JSDOM UI, MCP audit)
npm run test:gates && npm run test:phases
# Reproducible 10-family CLI compression + 12-session Antigravity & 5-host parity benchmark
npm run bench:parity
# Latency benchmark (200 iterations/path: Tier-1 ~2.9ms avg, Tier-2 ~58ms warm IPC / ~105ms cold Windows, ~5.4ms HUD)
npm run benchLicense
MIT © Gizzant
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
This server cannot be deployed
Maintenance
Related MCP Connectors
Cryptographic 563-leaf LLM rate oracle, context-cliff auditor, and prompt cache optimizer.
Research-backed lint + generation for agent context files (CLAUDE.md, AGENTS.md) + prompt enhancer.
Compress coding-agent context ~64%. Hosted Neural Keep MCP for Cursor/Claude/Codex.
Exact Claude API cost calc with real cache economics, plus a tiktoken-misuse scanner.
Related MCP Servers
- AlicenseNot gradedqualityAmaintenanceZero-tool-call codebase intelligence for Claude Code and MCP clients. Automatically injects the right code context, functions, callers, and call chains, before the LLM starts thinking. Replaces 4-6 grep/read round-trips with a single 5ms hook injection, cutting token usage by 3-8x.88 npm37MIT
- AlicenseBqualityDmaintenanceA fully local persistent memory layer for LLM coding agents (Claude Code, Codex, Gemini CLI, OpenCode). A shell wrapper intercepts tool invocations, fires hooks on every tool call, then runs a 3-layer pipeline (extract → compress to ≤500-token digest → merge into project memory doc) at session end. The next session gets prior context injected automatically.61MIT
- AlicenseCqualityCmaintenanceProfessional local context management and system diagnostic tools for AI IDEs (Cursor, Trae, Antigravity, Windsurf).3684 npm1MIT
- AlicenseNot gradedqualityAmaintenanceReduces context window usage by 60-90% through intelligent caching, compression, and smart tool replacements for Claude Code and Claude Desktop.4,264 npm587MIT