LoopGuard
DocsInstall
LoopGuard

Roadmap

Three versions. What shipped, what is live now, and what is coming — with the full feature list for every IDE and CLI tool.

Feature request? Open an issue on GitHub

v1

Extension Core

Shipped

The VS Code extension that started it all. Loop detection, status bar metrics, and focused context snapshots — all running locally in the editor, no account required.

Loop detection — VS Code, Cursor, Windsurf
  • Diagnostic loop detection via vscode.languages.onDidChangeDiagnostics — fires when the same error hash reappears 2–5× per session
  • Edit-pattern detection via onDidChangeTextDocument — catches repeated edits in the same region even when error text shifts
  • Configurable sensitivity: low (5×), medium (3×), high (2×)
  • Status bar: time wasted in loop + repeat count, always visible
  • Alert actions: Try New Approach, View Details, Ignore
Focused context engine
  • Copy Optimized Context — built-in mode lifts the failing window, imports, and nearby definitions
  • Native helper path (loopguard-ctx) for deeper focused reads on larger files
  • Before/after token estimate shown with every copy
  • Automatic fallback to built-in mode when helper is unavailable
IDE + platform support
  • VS Code — full support, published to VS Code Marketplace
  • Cursor — same extension, cursor:// URI auth auto-detected
  • Windsurf — same extension, windsurf:// URI auto-detected
  • Multi-IDE auth via vscode.env.uriScheme detection
  • Windows · macOS · Linux — x64 and ARM64, binary inside platform VSIX
Dashboard & sync
  • In-editor dashboard: session time, time lost, tokens saved, cost avoided
  • Optional web dashboard sync — anonymized metrics only, source code never leaves device
  • Sync every 5 minutes and on session end
  • Core protection works fully offline — sign-in never required
v2

CLI + Sync Pipeline

Current

The loopguard-ctx binary brings the context engine to every terminal-based AI workflow. MCP tools, Homebrew, anonymous device sync, and a shareable Wrapped stats card.

loopguard-ctx binary — all platforms
  • 20+ MCP tools: ctx_read, ctx_shell, ctx_search, ctx_tree, ctx_session, ctx_wrapped, ctx_compress, ctx_metrics and more
  • Homebrew tap: brew tap rodthenewcomer/loopguard && brew install loopguard-ctx
  • curl installer for environments without Homebrew
  • GitHub release binaries: macOS (x64/ARM64), Linux (x64/ARM64 gnu), Windows (x64)
  • Rust-built single binary, no runtime dependencies
All IDEs + CLI tools wired
  • Claude Code — PreToolUse rewrite, PostToolUse periodic, Stop sync, UserPromptSubmit session protocol
  • Cursor — terminal_command rewrite hook + postToolUse periodic notify+sync every 15 min
  • Windsurf — MCP config + .windsurfrules project file; loopguard-ctx setup --agent=windsurf
  • Codex CLI — MCP config + ~/.codex/ instruction file; loopguard-ctx setup --agent=codex
  • GitHub Copilot (VS Code MCP) — via VS Code MCP server config
  • Shell hooks (bash, zsh, fish) — compressed CLI output before it reaches any agent
Anonymous sync & Wrapped
  • Device UUID at ~/.loopguard-ctx/device.json — no account needed
  • Stop hook syncs stats in background at session end
  • Cursor periodic hook syncs every 15 min (no session-end event in Cursor)
  • /wrapped shareable stats card with dynamic OG meta — tokens saved, $ avoided, 14-day spark chart
  • Session task surfacing — last task description shown at every session start
Session continuity protocol
  • ctx_session load/save/status — restore previous task context across chat sessions
  • ctx_session finding / decision — record key findings and architectural decisions inline
  • ctx_overview(task) — task-relevant project map before reading any file
  • ctx_wrapped("session") — savings report card at session end
  • UserPromptSubmit hook injects mandatory session protocol on first prompt of every session
v3

Intelligence Layer

Live

The intelligence layer — shipped. v3 brings root cause hints, predictive context pre-selection, local fix memory, and cost forecasting to every IDE and CLI tool LoopGuard supports.

Loop root cause hints
  • When a loop fires, analyze diagnostic text + edit history to surface a specific diagnosis — not just "you're looping"
  • Lightweight local inference — no mandatory cloud round-trip
  • Works in VS Code/Cursor/Windsurf (extension alerts) and Claude Code/Codex/Cursor terminal (CLI hooks)
  • Example output: "This matches a type narrowing issue — try narrowing at the call site instead of the definition"
  • Grounded in the actual error pattern of the current session, not generic advice
Predictive context pre-selection
  • Ranks every file in the workspace by keyword overlap, path relevance, and session history — before any read
  • VS Code/Cursor/Windsurf: Copy Optimized Context appends predicted related files to clipboard output
  • CLI: loopguard-ctx predict "<task>" --path=<dir> or ctx_predict via MCP
  • Runs locally, zero network calls — pure keyword and path scoring
  • Session history boost: files you touched this session rank higher automatically
Session pattern memory
  • Locally stored index of what fixed similar bugs in past sessions
  • "Last 3 times this error appeared, the fix was in auth/middleware.ts:42" — surfaced automatically
  • Never synced to the server, never leaves the device
  • Queryable via ctx_memory MCP tool and visible in the extension dashboard
  • Compounds value the longer you work in the same codebase
Pre-send cost forecast
  • Before a session starts, estimate token cost based on task description + workspace size
  • "This refactor looks like 40k tokens at ~$0.12 — here's the focused slice that gets it to 8k"
  • Shown in extension status bar and as ctx_forecast MCP tool for CLI workflows
  • Supports Sonnet, Haiku, GPT-4o, and Gemini pricing models
  • Injected into Claude Code UserPromptSubmit hook so the estimate appears before work begins
Install now

v1 and v2 are live. Start with the extension or the CLI helper — both take under 60 seconds.

Setup guideDocumentation