Every release, in one place

vexp SDK — code intelligence as infrastructure — The same engine, exposed for automation: a self-hosted, machine-to-machine gateway that serves type-accurate context and cross-repo blast-radius over a simple REST API, with Python and TypeScript clients. Built for coding agents, PR review, and incident triage at fleet scale, on your own infrastructure — your code never leaves your network. Details at vexp.dev/sdk.

Sharper retrieval for multi-word queries — Natural-language and multi-word searches now line up better with compound identifiers — PascalCase and snake_case names whose parts are spread across your query surface more reliably as the top pivots, so context capsules land on the right symbol more often. Existing indexes pick this up automatically on the first open after upgrading.

Fuller call graphs and blast-radius — The indexer reconciles more call edges when it builds the graph, so get_impact_graph and search_logic_flow return more complete callers and callees and a refactor blast-radius reflects more of the real connections — visible after the next reindex.

Impact and ranking refresh after every edit — Call edges and ranking signals are now recomputed after each batch of indexed changes, so impact analysis and search stay current as you work instead of lagging until a full reindex.

Activation clears a stale refresh token — Activating a license now clears any leftover short-lived refresh token first, so a re-activation or a plan change takes effect immediately instead of being shadowed by a cached token from the previous state.

Plan changes persist the new server token — When your plan changes, the server-issued long-lived token is now persisted on the spot, so the new node and repo caps apply across VS Code and the CLI without waiting for the next refresh cycle.

Per-session targeting wins over a stale global pin — A global VEXP_WORKSPACE environment variable used to override each session's own project, pinning every agent — Claude Code and Codex alike — to one repo's daemon. Agents working in other repos then queried the wrong index and got empty results from get_skeleton and run_pipeline (while the CLI, which resolves the index from the file's own folder, kept working — the tell-tale split). When VEXP_WORKSPACE disagrees with a session's actual project, the per-session signal now takes precedence, so parallel sessions across repos each target their own index. A deliberate single-project pin still behaves as before.

get_skeleton fails loud instead of returning nothing — Asking for a file in a repo the connected daemon does not serve used to silently fall back to the primary repo and return an empty list — indistinguishable from "file not found." It now returns a clear error naming the repos the daemon actually serves and pointing at the likely cause, so a misrouted request is obvious instead of masquerading as missing data.

vexp doctor catches the global-pin trap — vexp doctor now warns when a global VEXP_WORKSPACE is overriding per-session targeting, or when several daemons are registered behind a single pin — the exact misconfiguration behind empty cross-repo results — instead of reporting "no issues detected." A shell or OS-level environment variable is invisible to the config checks, so this surfaces it directly.

VS Code adopts a CLI-started daemon — When the CLI auto-start had already launched the engine, the extension could refuse to attach to that healthy daemon and sit on "starting" indefinitely — even though your agent was being served fine. It now recognizes and adopts a running daemon (including one started in a different context, where the liveness probe returns "permission denied" rather than "gone"), and a failed start resolves to a clear state instead of hanging on "starting."

Windows: the Claude guard hook works again — The PreToolUse hook that steers Claude toward vexp instead of Grep/Glob checked for a Unix socket file that never exists on Windows, so there it always failed open and Grep/Glob were never intercepted. The hook is now platform-aware — Windows keys off the named-pipe marker, Unix/macOS keep the socket-plus-live-PID check unchanged — so re-running agent setup restores the nudge.

Impact on a class now includes its methods' callers — Call edges target method nodes, not the class node — so an impact query on a class found zero incoming edges (querying an individual method worked; querying its class did not). Impact analysis is now container-aware: for a class/struct/interface it seeds the dependents search with the class and all its members, so everyone who calls any method of the class counts as its blast radius. A query like "NpcProfile blast radius" now enumerates the callers instead of returning nothing.

The impacted counter no longer zeroes itself out — The pipeline capped collected impact nodes at a value derived from the token budget (impact_budget / 50), which rounded to 0 for the refactor preset — silently discarding every dependent so the "impacted" count read 0 even when the analysis found real callers. That cap is now a sensible node-count limit, independent of the token budget, so the count reflects the actual blast radius.

Dotted Class.Method callees now resolve — VS Code's Call Hierarchy names a callee as file::Class.Method(params) (and file::Ns.Class.Method) — a dotted containing type — while the source side comes through as file::Method(params):ret. Our FQN parser stripped the parameter list but not the dotted class prefix, so the callee resolved to "BtDebugLogger.Header" — matching no node. On the reported index that meant 17,675 sources resolved but only 37 callees, so every call edge was dropped. The method is now taken as the final segment after the last "." or "::", so dotted callees resolve — 0 → 10,944 reconciled CALLS edges on the same index.

Call edges resolve at submit time — no reindex — The socket path that accepts LSP edges from the extension created graph edges only on an exact FQN match, so format-mismatched edges had to wait for a full reindex to be picked up. Both the submit path and the indexer reconcile pass now share one format-tolerant resolver (exact match, then an unambiguous (file, method) fallback that declines on overloads). Open VS Code, let the bridge submit edges, and get_impact_graph / search_logic_flow light up immediately.

Spec-Kit and feature directories no longer filtered out — The capsule's test/benchmark path filter matched the substring "/spec", so a codebase laid out under Spec-Kit directories (Claude/SPEC-08_CombatSystem/…) was classified as spec/test code and dropped from every result — only Markdown survived. Path classification now matches whole directory segments (tests/, spec/, __tests__/, benches/) and unambiguous filename patterns, never substrings, so SPEC-08_*/, specifications/, and latest.cs are treated as the production code they are. Query-side fix — no reindex required.

Cleaner embeddings, calibrated semantic scoring — TF-IDF tokenization now splits on every non-alphanumeric character and drops numeric and syntax artifacts (get;, key(5)], <summary>), and language keywords are filtered from the embedding vocabulary while the symbol name is kept verbatim. The query vector is computed against the index's global IDF statistics instead of a tiny per-query mini-corpus, so semantic similarity is meaningful — PascalCase queries that previously scored ~0 now score 70–90% on the right symbol.

Large classes are never dropped from a capsule — The pivot loop used to break on the first candidate whose body exceeded the budget, so an exactly-named 750-line C# class returned an empty capsule while a 350-line one worked. The top-ranked pivot is now always included — capped to the total budget and truncated if enormous — and oversized lower-ranked pivots are skipped instead of ending the loop.

LSP call edges resolve across FQN formats — VS Code emitted call edges as file::Method(params):ret while the indexer stored file::Class::Method, so the two never joined and get_impact_graph / search_logic_flow only ever returned class-membership edges. Reconciliation now resolves on (file, method) when an exact FQN match fails — declining on ambiguity — and the extension emits a file::Class::Method form. Call graphs light up for C#.

Zero-config GPU acceleration — NVIDIA acceleration with no manual setup: the CUDA runtime is fetched on demand from the public PyPI redistributable the first time a GPU is detected, including CUDA 12.8 / Blackwell SASS support. There is no separate GPU build to install.

Codex & MCP transport hardening — Codex now uses a direct MCP transport with stdout kept strictly JSON — no reindex or abort chatter under it, which previously surfaced as "Transport closed". Agent and MCP config files are merged rather than overwritten on a parse failure, and written ASCII-clean.

Per-session, multi-workspace targeting — Each session resolves to the correct workspace daemon, so several projects open at once no longer cross their indexes. Plus license diagnostics, a force-reindex restart path, and Windows single-instance daemon handling to stop duplicate vexp-core processes from leaking handles.

AppSumo lifetime tiers — Lifetime-deal plans (tier1–tier4) are recognized across the license issuer and consumer, mapping to the right node and repo caps.

Daemon no longer crashes on non-ASCII markdown — truncate_markdown_body sliced markdown content at a fixed 8000-byte offset that could land mid-codepoint, killing the daemon before it bound its socket. Every downstream call (vexp mcp --proxy, the VS Code sidebar, MCP requests) then failed silently with no diagnostic. The slice now snaps to the nearest UTF-8 char boundary via str::floor_char_boundary, so multi-byte characters at any offset are handled correctly.

Audit-wide fix, not a one-spot patch — A sweep of the Rust codebase surfaced five total sites with the same raw-byte-slice pattern (markdown indexing, JSON value summarization, tool-result logging, JSON-shape sniffing, impact-graph truncation). All five now use the stable str::floor_char_boundary stdlib method. The obsolete in-crate floor_char_boundary_safe helper was removed so contributors stop reaching for the wrong idiom.

Regression tests for the exact reproducer — Four new tests cover the reported em-dash-at-byte-8000 case plus the pathological all-em-dashes input and the 2-byte (accented letter) and 4-byte (emoji) UTF-8 boundary cases. 375/375 cargo tests green; end-to-end validated by rebuilding 2.0.17 with the local LLM feature and indexing the trigger files plus the full vexp repo.

Windows login launcher — fixed — vexp 2.0.12 shipped an invalid VBScript template for the Startup-folder launcher, causing a Type mismatch error at login and silently preventing vexp serve from starting. The generator now emits valid VBScript (proper quote doubling) and routes through %ComSpec% /d /s /c so cmd.exe applies legacy single-strip quote semantics. Verified end-to-end: the MCP HTTP server starts on 127.0.0.1:7821 at login and writes to ~/.vexp/autostart.log.

Automatic migration from 2.0.12 — On Windows, the next vexp invocation after upgrading detects any existing broken vexp-serve.vbs by signature and rewrites it with the fixed template — before the autostart marker short-circuit kicks in. No manual vexp autostart uninstall/install required. VEXP_NO_AUTOSTART_INSTALL=1 still opts out cleanly: the migration runs after the env-var check, so opted-out users are never touched.

Markdown indexing (first-class) — .md and .mdx files are now indexed at section granularity. Each heading becomes a retrievable node; URLs inside sections become markdown_link nodes. Spec-Kit and planning artifacts (spec.md, plan.md, tasks.md, README.md, docs/adr/*) get a small ranking boost so agents surface them when relevant.

Secret filtering (default on) — Files matching .env, .env.production, id_rsa, *.pem, *.key, secrets.yaml, secret.md, password.json, credentials.toml — and similar filename-boundary matches — are skipped at index time. Legitimate code like src/secret-manager.ts is unaffected. Public templates (.env.example, .env.sample, .env.template) are allowlisted. Opt out with filter_secrets = false in .vexp/vexp.toml.

.vexpignore filename alias — .vexpignore (no underscore — matching the .gitignore / .dockerignore convention) now works alongside the historical .vexp_ignore. If both files exist, their patterns are concatenated.

.ignore (ripgrep) support documented — vexp also honors .ignore files (the ripgrep / fd / Sublime Text convention) via its underlying walker. If your project already has one for ripgrep, vexp picks it up automatically.

Starter: 20 pipeline calls per day — Daily call quota raised from 8 to 20 on the Starter plan. Enough to explore vexp on real projects across a full work day. Quota still resets at midnight UTC.

Cross-repo collection respects ignore rules — The multi-repo cross-link detector now routes file collection through the same walker as the primary indexer: .gitignore, .vexp_ignore, and .vexpignore patterns are honored consistently everywhere vexp reads source files.

Runs on every Linux distro — Ubuntu 20.04+, Debian 11+, RHEL 8+, Fedora, WSL2, Amazon Linux — all supported out of the box. No extra libraries to install.

Daemon auto-start — After first setup, the background engine starts automatically whenever you or your AI agent needs it. Nothing to manage.

Interactive CLI — Type `vexp` for a guided menu with live status of the daemon and local LLM. Setup, explore, and configure agents without memorizing commands.

Reliable agent connections — AI agents (Claude Code, Codex, Cursor, …) now find the daemon automatically, even when launched from different directories. Connection errors eliminated.

vexp-devmind local LLM — A compact, code-specialised model that runs entirely on your machine for an extra +30% token savings. Zero cloud, zero account, zero code leaving your laptop. ~3.5 GB download.

GPU acceleration — Metal on Apple Silicon + Intel Macs, CUDA on NVIDIA (Linux & Windows). Auto-detected at runtime. CUDA plugin downloaded on-demand when an NVIDIA driver is detected.

Smart prompt preprocessor — Your question is analysed locally and pre-enriched with the right files, symbols, and call chains before reaching your AI agent. Fewer tool calls, sharper answers.

run_pipeline single-call — One MCP call replaces capsule + impact + memory + observation. Auto-detects intent (debug/modify/refactor/explore) from your task description.

30 language support — From 12 to 30 languages in a single release. Kotlin, Scala, Swift, Dart, PHP, Elixir, Haskell, OCaml, Lua, R, Zig, HCL/Terraform, Objective-C, Dockerfile, Clojure, and F# join the existing lineup with full AST parsing and dependency graph support.

Daily free tier quota — Starter plan users now get 20 pipeline calls per day — enough to explore vexp on real projects. The quota resets daily at midnight UTC.

Pipeline streaming — run_pipeline now streams results as they arrive: pivots first, then impact analysis, then memories. Agents see initial context faster on large codebases.

LSP Bridge v2 — The VS Code language server integration now captures richer type information with better performance. More accurate call graphs, especially for TypeScript generics and Go interfaces.

189 automated tests — Test suite expanded from 133 to 189 tests covering all 30 languages, pipeline streaming, and the new quota system.

Smoother installs — Fixed edge cases in the npm publish pipeline and aligned package versions across the VS Code extension and standalone CLI.

Resilient license verification — License checks now handle edge cases and malformed responses gracefully. Your workflow is never interrupted by a transient verification issue.

Smarter parameter handling — MCP tool parameters are now automatically coerced to the correct types. Agents that send numbers as strings or booleans as "true" no longer cause errors.

Improved hook guard — The Claude Code hook guard now uses process-level detection to avoid conflicts with other tools. More reliable interception on busy systems.

Automatic database recovery — If the index database is corrupted (e.g. after a system crash), vexp detects it and rebuilds automatically from the manifest. Zero data loss, zero manual intervention.

Health monitoring — The daemon now monitors its own health continuously: database integrity and indexing throughput. Issues are surfaced in the status bar and index_status output.

133 automated tests — Comprehensive test suite covering database recovery, health checks, and all supported languages.

Faster, more reliable updates — We overhauled our release pipeline so new versions reach you quicker and more reliably across all platforms — Linux, macOS, and Windows.

Automatic cleanup on shutdown — vexp now cleans up all connection files when the daemon stops, preventing stale sockets even after unexpected crashes.

Smarter hook guard — The Claude Code integration now detects stale connections and gracefully falls back, so your agent always has access to code search tools.

Regex support in hooks — The hook guard now intercepts Regex tool calls in addition to Grep and Glob, ensuring your agent always uses vexp's smarter search.

Shared daemon across windows — Multiple VS Code windows now share a single vexp daemon. Only the original window manages its lifecycle — other windows connect automatically.

Automatic port recovery — If the MCP port is busy, vexp finds an available one automatically. No more restart loops or manual port changes.

Smart reconnection — If the daemon restarts, non-owner windows detect it and reconnect with exponential backoff. If the daemon is gone, a new window takes over automatically.

Resilient daemon connection — The MCP client now retries transient connection errors automatically, keeping your agent on vexp's smarter search even during brief daemon restarts.

run_pipeline MCP tool — Single-call pipeline that auto-detects intent (debug/modify/refactor/explore), combines capsule + impact + memory, and includes full file content for pivots. ~60% fewer context tokens. Available on all plans (basic on Starter, full on Pro+).

CLI license enforcement — vexp activate, vexp deactivate, and vexp license commands. Shared license file at ~/.vexp/license.jwt — activate once, both VS Code and CLI use the same plan.

Marker-delimited git hooks — Git hooks now use # --- vexp start/end --- markers. Safely coexists with existing hooks (husky, lint-staged) without overwriting them.

Mobile & React Native defaults — Pods/, DerivedData/, and .expo/ are now excluded from indexing by default for faster mobile project setup.

Intent detection fix — Fixed false positives in intent detection caused by substring matching on non-English words. Now uses exact word boundary matching.

FTS5 query fix — Fixed crashes when search queries contained special characters like parentheses, asterisks, or quotes.

Standalone CLI — npm install -g vexp-cli and start using vexp with Claude Code, Codex, Opencode, or any terminal agent. Zero dependencies, instant setup.

Direct binary mode — Run vexp-core mcp --workspace . for maximum performance. One native binary, no Node.js required.

Smarter file watcher — vexp now reads your .gitignore and skips ignored files entirely. Faster indexing, fewer false positives.

Cleaner multi-repo sidebar — Empty repositories are hidden by default. One toggle to show them when you need to.

5 platform packages — Native binaries for Linux (x64, arm64), macOS (Intel, Apple Silicon), and Windows. Downloaded automatically on first install.

Windows named pipes fixed — Each workspace now gets a unique pipe name. No more connection failures when running multiple projects.

Smaller Windows extension — The VS Code package no longer bundles binaries for other platforms. 5 MB instead of 45 MB.

Passive Observation — vexp watches every file change and correlates it with your agent's tool calls. It understands not just what changed, but why — without any setup.

Project Rules — Recurring patterns in your workflow are auto-promoted into rules. They persist across sessions and are injected into context capsules — your agent learns your project's conventions.

Memory Consolidation — Repetitive observations are automatically merged, keeping memory clean and relevant without losing information.

Standalone MCP server — Run vexp as a native Rust daemon with MCP over stdin/stdout. Works with Claude Code, Codex, and any MCP-compatible agent — no VS Code needed.

Manifest-only git — Only a lightweight manifest.json is committed to git. No binary blobs, no merge conflicts. Teammates rebuild the full index in seconds.

Session Memory system — Full session memory: auto-capture, cross-session search, manual observations, and staleness detection — all linked to the code dependency graph. Works identically across all 12+ supported agents.

3 new MCP tools (Free Tier) — get_session_context, search_memory, and save_observation. All 3 are available on the free Starter plan — memory is the product showcase.

Auto-capture every tool call — Every MCP tool call is automatically recorded as a compact observation (~100-200 bytes) with per-tool extraction: intent + pivots, symbol FQNs, start→end flows, file lists.

Capsule memory auto-surfacing — get_context_capsule automatically includes relevant memories from previous sessions — no extra tool calls needed. Budget: 10% of token budget, ranked by query + pivot proximity.

Code-graph linked staleness — Observations linked to code symbols are auto-flagged stale when the code changes. Stale memories are penalized in search ranking (-0.30) but never deleted.

Hybrid memory search — FTS5 BM25 (0.35) + TF-IDF cosine (0.25) + recency decay with 7-day half-life (0.20) + code-graph proximity (0.15) − staleness penalty. Every result includes a "why" field.

Session compression — Background task compresses inactive sessions (>2h): extracts key terms, file paths, node IDs into a structural summary. Ephemeral observations deleted; insights preserved permanently.

Progressive disclosure — 3 detail levels: L1 Headline (~20 tokens, capsule inject), L2 Standard (~50 tokens, default search), L3 Full (~100 tokens, deep queries).

Database schema v2 — New tables: sessions, observations, observations_fts (FTS5 with porter stemmer), observation_node_links. Incremental migration — no existing data touched.

UTF-8 multi-byte fix — Prevent panics on multi-byte UTF-8 string slicing in skeleton generation and TF-IDF tokenization.

Cross-repo queries are live — Context capsules, impact graphs, and logic flow searches now resolve symbols across repository boundaries. One query spans your entire stack — frontend, backend, and infra.

VS Code sidebar panel — Real-time daemon status, index statistics, per-repo cards, and quick actions — Force Re-index, Generate Capsule, Add Repository, View Logs — all without leaving the editor.

CodeLens on exports — Every exported symbol shows its dependent count inline: "12 dependents across 4 files". Know the blast radius before you refactor.

Hover impact data — Hover over any exported declaration to see dependents, cross-repo references, and top callers — without running a single command.

All 12 agent configs updated — Multi-repo documentation added to every agent template, from Claude Code's full CLAUDE.md to Cursor's compact rules file.

Smarter capsule ranking — File-path detection, churn-based scoring, and path priority boosting deliver more relevant results with fewer tokens.

6 new languages — Java, C#, C, C++, Ruby, and Bash join TypeScript, JavaScript, Python, Go, and Rust. Full class, method, and interface extraction for each.

Intent detection — vexp reads your prompt and adapts. "fix bug" activates debug mode and follows error paths. "refactor" shows blast radius. "add feature" prioritizes modification targets.

Hybrid search — Combines full-text search, TF-IDF semantic similarity, and graph centrality scoring. Finds validateCredentials when you search "authentication".

LSP Bridge — VS Code captures type-resolved call edges from the Language Server and feeds them into the dependency graph. Higher confidence, zero configuration.

New MCP tool: submit_lsp_edges — Dedicated tool for IDE-level call edge submission. 7 MCP tools total.

Claude Code stdio transport — Switched from HTTP to stdio transport, eliminating "Session not found" errors. Rock-solid, zero-config connection.

Context feedback loop — Repeated queries with similar terms automatically expand the result budget, giving you deeper context on the second pass.

Core context engine — tree-sitter parsing, AST dependency graph, SQLite index, and token-efficient context capsules with 65-70% token reduction.

5 languages at launch — TypeScript, JavaScript, Python, Go, and Rust with full function, class, and type extraction.

6 MCP tools — get_context_capsule, get_impact_graph, search_logic_flow, get_skeleton, index_status, and workspace_setup.

Auto-configuration for 12 agents — One command detects your AI agent and writes the config file. Claude Code, Cursor, Windsurf, Copilot, and 8 more.

Git-native manifest — Only manifest.json (blake3 hashes) is committed to git. Clone a repo and the index rebuilds incrementally from the manifest in seconds.