Cortex MCP Server by fazalur076

Cortex (cortex / ctx)

Fast, fully offline repository intelligence engine and MCP context server for AI coding agents and developers.

Cortex is a single-binary repository intelligence engine. It doesn't generate code, call cloud APIs, or require API keys. Instead, it reads your local source files, parses structural relationships (AST symbols, imports, API routes, UI components), and stores them in a local SQLite graph.

Whether you are using Cursor, Claude Code, Antigravity, VS Code, or working directly in the terminal, Cortex gives AI tools and human developers instant structural codebase context with zero API keys and zero cloud bills.

---

                       AI Coding Tools
          Claude Code  •  Cursor  •  Antigravity  •  VS Code
                             │
                      queries via MCP / CLI
                             ▼
                   ┌───────────────────┐
                   │   Cortex (`ctx`)  │
                   └─────────┬─────────┘
                             │
                 Local SQLite Knowledge Graph
                  (~/.cortex/repos/your-app)

---

Why Cortex?

Most AI context tools rely on fuzzy vector search (RAG) or force your AI agent to read thousands of lines of raw files over and over.

This causes two major issues:

1. High Token Bills & Sluggish Response: Reading whole repositories burns 100k+ tokens per prompt.
2. AI Guesses & Breaking Changes: Vector embeddings only find text that looks similar. They cannot reliably tell you if editing AuthService will affect React pages, API endpoints, permissions, or tests.

Cortex solves this deterministically:

• Zero Cloud Calls: 100% local compiled Go binary. Zero code leaves your computer.
• Evidence-backed Dependencies: Uses structural graph traversal with explicit evidence confidence. Go declarations use the native Go parser; other language extractors currently use heuristics.
• Whole-Changeset Git Diff Impact (ctx diff-impact / ctx impact --diff): Computes cumulative blast radius and reverse dependency paths across all staged, modified, and untracked files in the working tree in a single call.
• Database Schema Drift (ctx schema-drift / ctx sql-drift): Statically cross-references database migration columns against active code queries to catch phantom queries, column drift, and dropped columns before deploy.
• Token-Lean Mode (--lean / --llm): High-density single-line outputs saving up to 85% context tokens for agent prompts across symbol, impact, and schema drift checks.
• Feature Context (ctx explain): Gives structured feature overviews aggregating services, controllers, models, components, and routes without reading unrelated files.
• Cross-Repository Feature Extraction (ctx feat-extract): Slices AST symbol definitions, 2-hop import dependency graphs, and source code ranges into portable markdown reference artifacts for AI agents.
• Local & Global Scoping (--local / --global / --exclude-current): Query strictly within the active project or search across all indexed repos on your machine.
• Pre-Change Impact Analysis (ctx impact): Shows statically discovered dependents and routes before code is changed; compiler and tests remain the correctness checks.
• Real-Time Watcher (ctx watch): Listens to OS kernel file saves (fsnotify) and updates AST diffs in under 200ms with periodic hash verification (--verify).

The important split is simple:

• Cortex CLI commands produce deterministic repository facts.
• Cortex MCP tools expose those same facts, plus compact evidence packets for planning, explanation, review, and verification.
• The connected MCP host LLM performs reasoning and synthesis. Cortex itself does not run hosted inference.

---

Features

• Whole-Changeset Git Diff Impact (ctx diff-impact [ref] or ctx impact --diff): Analyzes the cumulative blast radius, changed files, and affected tests across working-tree modifications or git commits in one unified command.
• Database Schema Drift Detector (ctx schema-drift / ctx sql-drift): Detects column drift, queries targeting dropped columns, and phantom table columns by cross-referencing database migrations with codebase queries.
• Token-Lean Output Mode (--lean / --llm): Generates compact, single-line summaries tailored specifically for AI agent context windows, dramatically reducing token consumption across symbol, impact, and schema checks.
• Tiered Impact Summaries (--summary) & Path Scoping (--path): Quickly summarizes blast radius in structured tiers and allows monorepo engineers to scope impact analysis to specific sub-packages (e.g. --path apps/web).
• Code-Only & Noise Filtering: Automatically ignores .agents/, .cursor/, .claude/, .gemini/, and documentation markdown files (.md, .markdown, .mdx) during AST symbol lookups to prevent agent configuration and documentation from polluting code results.
• Cross-Stack Route Tracing: Deterministically bridges frontend TypeScript/JavaScript API client calls (apiClient.get(...), fetch(...), axios(...)) to backend route configurations (e.g. Django urls.py with path converters and include() mount prefixes) and backend view handlers (views.py).
• Feature Context (ctx explain <feature>): Aggregates services, controllers, models, components, hooks, and API routes associated with a feature module into a single structured summary.
• Cross-Repository Feature Extraction (ctx feat-extract): Slices AST symbol definitions, file dependencies, import DAG graphs, and exact line ranges from another local repository into a standalone workspace reference Markdown file (<feature>-ref.md). Supports auto-searching global or target project-ref with --max-files, --no-migrations, --no-tests.
• Local & Global Query Scoping (--local / --global / --exclude-current): Restrict searches to the active workspace (--local), query across all indexed repositories in ~/.cortex/repos/ (--global), or optionally exclude the current repository (--exclude-current).
• Blazing Fast: Built in Go with SQLite WAL mode. Scans and indexes 1,000+ files in under 1.5 seconds.
• 100% Offline & Private: Zero network calls, zero LLMs required for indexing, zero API keys.
• AST Symbol Lookup (ctx symbol <symbol>): Performs exact structural inspection of functions, classes, interfaces, and UI components with source locations, line numbers, and token-lean --lean output.
• Impact Analysis (ctx impact <symbol>): Calculates the statically discovered blast radius (affected files, routes, tests) before making code edits.
• API Contract Intelligence (ctx contracts, ctx api-diff): Compares frontend API calls, backend routes, request/response fields, duplicate route ambiguity, and supported SQL database constraints using deterministic evidence.
• Route Parameter Validator (ctx check-routes): Validates backend route/path-parameter contracts. For duplicate route ambiguity and frontend/backend API compatibility, use ctx contracts.
• Platform Scope Leak Auditor (ctx audit-target): Flags browser-only globals (window, document) leaking into shared server or mobile packages.
• Behavior Facts (ctx behavior-data <symbol>): Returns deterministic local behavior facts such as calls, reads, writes, conditions, returns, throws, permission checks, and persistence markers.
• Permission and Lineage Intelligence (ctx permissions, ctx lineage): Traces authorization evidence and supported static cross-layer field/data flow. SQL schema evidence is connected when detected; ORM-only database evidence is reported as unknown rather than inferred.
• Test Discovery (ctx tests <target>): Recommends likely focused tests based on imports, references, routes, and feature naming.
• Agent Hook Integrations (ctx integrations): Manages native context hooks across Claude Code, Cursor, Codex, Antigravity, and generic workflows.
• Health & Diagnostics (ctx doctor): Runs environment checks, verifies SQLite DB integrity, index health, file permissions, and MCP configuration.
• Native MCP Server (ctx serve): Plugs natively into Cursor, Claude Code, Antigravity, and other MCP-compatible tools via stdio with 13 built-in tools, full local/global scoping, and feature extraction.
• Strict MCP JSON-RPC Protocol Validation: Standardized parameter validation for native MCP tools, returning standard JSON-RPC error code -32602 Invalid params for missing or malformed fields.
• Auto AI Rules Generator (ctx init): On first run, automatically writes Cortex usage rules into .agents/AGENTS.md so coding agents understand when to use Cortex, when to inspect source directly, and when to avoid wasteful tool calls.
• Polyglot UI & Template Tree Indexing: Indexes UI renders and template inheritance across React/Next.js (<DataTable>), Vue (<script setup>), Svelte (<Header/>), Django/Flask (render(request, 'list.html'), {% include %}), Flutter (Widget(...)), Android Jetpack Compose (@Composable), and SwiftUI (VStack), enabling instant blast-radius impact analysis (ctx search <UIComponent>).
• Polyglot Framework Support: TypeScript/React, Next.js, Vue, Angular, Svelte, Go, Python/Django/FastAPI, Dart/Flutter, Rust, Java/Kotlin, Swift, PHP, C#/.NET, C/C++.

---

Installation

Download the pre-compiled binary package for your operating system from GitHub Releases.

macOS (Apple Silicon & Intel)

1. Download cortex-macos.zip from Releases
2. Extract and run the installer:

unzip cortex-macos.zip
cd release
bash install.sh

Linux (x86_64 & ARM64)

1. Download cortex-linux.zip from Releases
2. Extract and run the installer:

unzip cortex-linux.zip
cd release
bash install-linux.sh

Windows (PowerShell 5.1 & 7+)

1. Download cortex-windows.zip from Releases
2. Extract and run the installer in PowerShell:

Expand-Archive cortex-windows.zip -DestinationPath release
cd release
.\install.ps1

Note: The installer configures both cortex and ctx commands in your system PATH automatically.

---

Quickstart

Run inside any software repository:

# 1. Initialize project config and generated .agents/AGENTS.md policy
ctx init

# 2. Build full knowledge graph (< 2 seconds)
ctx build

# 3. View high-level tech stack & module summary
ctx summary

# 4. Inspect feature context and related modules
ctx explain authentication

# 5. Check what breaks before editing a symbol or class
ctx impact AuthMiddleware

# 6. Check cumulative blast radius of all working-tree changes / git diff
ctx impact --diff
# or: ctx diff-impact HEAD~1

# 7. Audit database migrations for column drift or phantom code queries
ctx schema-drift
# or: ctx sql-drift --lean

# 8. Direct AST symbol lookup (with token-lean 1-line output for LLM prompts)
ctx symbol AuthMiddleware --lean

# 9. Search locally inside current project only
ctx search "userRole" --local

# 10. Search globally across all indexed local repositories on your machine
ctx search "authentication" --global

# 11. Search globally while excluding the current repository
ctx search "login" --global --exclude-current

# 12. Cross-Repository Feature Extraction: extract AST symbols, import DAG, & code snippets for AI context
ctx feat-extract global authentication auth-ref.md --max-files 10 --no-migrations

# 13. Inspect deterministic behavior facts for a symbol
ctx behavior-data AuthMiddleware

# 14. Check agent hook integrations (Cursor, Claude, Codex, Antigravity)
ctx integrations status

# 15. Run system health & index diagnostics
ctx doctor

# 16. Start live background watcher with periodic hash verification for real-time AST updates (<200ms)
ctx watch --verify

Note on ctx init and generated agent policy: Running ctx init writes Cortex repository intelligence guidance into .agents/AGENTS.md. Existing Cortex policy sections are upgraded in place, so repeated ctx init runs do not duplicate the policy. AI tools such as Cursor, Claude Code, and Antigravity can use that policy to treat Cortex as the default structural navigation layer without blindly running every Cortex command for every task.

Flags & Options (Useful for Power Users & CI/CD)

• ctx build --full: Forces a full repository rebuild and SQLite database schema/format reconciliation.
• ctx watch --verify: Starts the file watcher and periodically reconciles file hashes against the SQLite index to handle branch swaps cleanly.
• ctx impact <symbol>:
  • -d, --diff: Computes whole-changeset blast radius across modified/untracked files.
  • --lean (or --llm): High-density 1-liner output saving up to 85% prompt tokens.
  • --summary: Tiered impact summary buckets.
  • --path <dir>: Scopes blast radius to a sub-directory (essential for monorepos).
• ctx diff-impact [ref]: Computes cumulative blast radius for working tree or specific git ref (--summary, --lean).
• ctx schema-drift (alias ctx sql-drift):
  • --lean (or --llm): Compact 1-line summary of database migration drift.
  • --json: Machine-readable JSON output of detected phantom/dropped columns.
• ctx symbol <name>:
  • --lean (or --llm): High-density 1-liner with signature, file:line, and caller count.
  • -l, --local: Restrict lookup strictly to current repository.
  • -g, --global: Search symbol across all indexed repositories in ~/.cortex/repos/.
• ctx search <query>:
  • -l, --local: Restrict search strictly to current repository.
  • -g, --global: Search across all indexed repositories in ~/.cortex/repos/.
  • --exclude-current: Exclude active workspace repository from global results.
• ctx feat-extract [project-ref|global] <feature> [output-path]:
  • --max-files <int>: Caps maximum number of files extracted (default: 15).
  • --no-migrations: Excludes database migration files (default: true).
  • --no-tests: Excludes test files from extraction.
• --json: Outputs command results in structured JSON format (great for CLI scripting, CI/CD workflows, or custom editor extensions).

---

CLI Command Surface

Cortex CLI commands are deterministic and local. They do not run an LLM, call cloud APIs, or require model/API-key configuration.

Deterministic CLI Commands

CLI Command	Purpose
ctx init	Initializes Cortex config and generated .agents/AGENTS.md policy
ctx build	Builds or refreshes the local SQLite knowledge graph (--full for clean rebuild)
ctx watch	Watches local files and incrementally refreshes the index (--verify for periodic hash checks)
ctx doctor	Checks index health, database integrity, freshness, and environment state
ctx summary	Shows repository architecture, language breakdown, modules, and stats
ctx search <query>	Searches symbols, files, routes, and indexed source text (--local, --global, --exclude-current)
ctx symbol <name>	Shows AST-backed symbol details and usages (--lean for 1-liner token-efficient output)
ctx impact <target>	Computes blast radius for a symbol, file, or working tree diff (--diff, --summary, --path, --lean)
ctx diff-impact [ref]	Analyzes cumulative blast radius and affected tests across working-tree diff or git ref
ctx schema-drift	Detects column drift, dropped column queries, and phantom columns against database migrations (alias: ctx sql-drift)
ctx routes	Lists backend API routes discovered from source
ctx check-routes	Validates backend route/path-parameter contracts and catches duplicate route strings
ctx contracts [route]	Audits frontend/backend/API/supported SQL DB contract evidence, including duplicate route ambiguity
ctx api-diff	Audits API contracts touched by the current working-tree diff
ctx lineage [target]	Traces matched static data and field flow evidence; unmatched targets return uncertainty
ctx permissions [target]	Traces frontend/backend/matrix permission evidence (--role to simulate role)
ctx tests [target]	Recommends likely focused tests based on imports, references, routes, and feature naming
ctx behavior-data <symbol>	Returns deterministic raw behavior facts for a symbol
ctx context [task]	Fast deterministic context packet retrieval for agent hooks
ctx integrations	Manages agent hook integrations (status, install, remove for claude/cursor/codex/antigravity)
ctx known-issues [target]	Shows current deterministic known issues
ctx workflows [target]	Shows evidence-backed local workflow recipes (ctx workflow <name> for specific recipe)
ctx gate	Runs Cortex's built-in deterministic regression/self-test precision gates
ctx audit-target	Audits shared packages for platform scope leaks (window, document)
ctx conventions	Shows detected architectural conventions
ctx patterns	Shows local cross-repository pattern memory
ctx explain <feature>	Shows deterministic feature context aggregating services, models, routes, and components
ctx feat-extract ...	Extracts focused local repository context into standalone Markdown
ctx serve	Starts the native MCP server over stdio

MCP-Only Reasoning Guidance Commands

When run from the CLI, these commands provide operational guidance for connecting and utilizing MCP tools:

CLI Command	Purpose
ctx plan	Guidance for task planning with ctx_plan
ctx behavior	Guidance for behavior explanation with ctx_explain_behavior and ctx_behavior_data
ctx verify-diff	Guidance for diff review with ctx_review_diff
ctx verify-task	Guidance for task verification with ctx_verify_task
ctx suggest	Guidance for architectural recommendations with ctx_suggest

CLI Commands Without Direct MCP Equivalents

These commands are intentionally CLI/local-runtime operations rather than MCP tools:

CLI Command	Why It Is CLI-Only
ctx init	Creates local project configuration and generated repository policy files
ctx build	Writes and refreshes the local SQLite index
ctx watch	Runs a long-lived local filesystem watcher
ctx serve	Starts the MCP server itself
ctx integrations	Installs/removes agent hook files in .cursor/, .claude/, etc.
ctx conventions	Local convention display command
ctx patterns	Local cross-repository pattern-memory display command
ctx gate	Precision regression gate execution

DB Evidence Boundary

Cortex currently treats detected SQL schema/constraint evidence as deterministic DB evidence. Unsupported ORM-only schema representations are reported as UNKNOWN/unsupported rather than inferred. ctx contracts and ctx lineage must not be read as confirmed DB lineage unless the output includes concrete DB evidence.

---

AI Editor Integration (Universal MCP Server)

To give your AI coding tools (Cursor, Claude Code, Antigravity, VS Code) instant access to Cortex, add this single global entry to your editor's MCP config file (e.g. ~/.cursor/mcp.json or claude_desktop_config.json):

{
  "mcpServers": {
    "cortex": {
      "command": "ctx",
      "args": [
        "serve"
      ]
    }
  }
}

Native MCP Tools (13 Built-in Tools)

Cortex provides 13 native MCP tools running over stdio for AI coding agents:

MCP Tool	Description	Inputs / Options
ctx_project_summary	Returns high-level architecture, language breakdown, modules, stats, and conventions across workspace repositories	none
ctx_feature	Resolves feature context: services, controllers, models, components, hooks, routes, files, and tests	name (required)
ctx_symbol	Inspects symbol AST definition, file location, signature, and usages	name (or symbol/target/file), scope (local/global), global (bool), lean (bool)
ctx_impact	Computes blast radius for a symbol, file, or whole working tree diff	target (or symbol/file), scope, global, diff (bool), ref (string), lean (bool), summary (bool), path_scope (string)
ctx_plan	Returns a compact deterministic evidence packet for MCP-host task planning	task (required), max_files (int, default 8)
ctx_search	Searches indexed symbols, files, routes, and source snippets across local workspace or all repos	query (required), scope (local/global), global (bool), exclude_current (bool)
ctx_schema_drift	Detects column drift, dropped column queries, and phantom columns against database migrations	lean (bool)
ctx_sql_drift	Alias for ctx_schema_drift; audits SQL query/schema drift against migrations	lean (bool)
ctx_doctor	Returns runtime health status and diagnostic checks	none
ctx_check_routes	Validates route parameter contracts and catches hardcoded duplicate route strings	none
ctx_audit_target	Flags platform scope leaks (window, document, process.env) in shared packages	none
ctx_suggest	Returns architectural refactoring recommendations (file length, route conflicts, scope leaks)	none
ctx_feat_extract	Slices feature AST symbols, file dependencies, and line snippets into a workspace Markdown reference	project_ref (string), feature (required), output_path, no_migrations, no_tests, max_files

CLI and MCP Parity

Deterministic CLI commands and their MCP equivalents are semantically aligned for the same repository state. For example:

ctx impact AuthMiddleware --lean

produces the exact same token-lean blast radius string as calling the MCP tool:

{
  "name": "ctx_impact",
  "arguments": {
    "target": "AuthMiddleware",
    "lean": true
  }
}

Use MCP when your coding agent can consume structured tool results directly. Use CLI when working manually in the terminal, scripting, or running CI checks.

---

How It Works (Under the Hood)

1. AST & Route Scanner: Reads source files and extracts symbols (functions, classes, interfaces, React components, API routes, route handlers) with exact line numbers.
2. Directed Import Graph (DAG): Connects relative and aliased imports (./auth, @/components) into a directional node graph with 2-hop dependency resolution.
3. SQLite FTS5 Search Engine: Stores symbols, file entries, and routes in a local SQLite database (~/.cortex/repos/<project>/context.db) with an inverted search index for sub-5ms lookups.
4. Kernel Event Watcher & Verifier: Listens for OS fsnotify file saves and computes incremental AST diffs to update modified files, route tables, and search indexes in under 200ms.

---

Read the Cortex Launch Article:
Why I Built Cortex: A 100% Offline, Sub-15ms Repository Intelligence Engine for AI Coding Agents

Documentation & Releases:

• Release Notes
• Changelog

Released under the MIT License. Copyright (c) 2026 Fazalur-Rahman.

Search performance and evidence guarantees

Search uses indexed case-insensitive exact and prefix lookups, followed by ranked FTS5 text retrieval and a substring fallback when indexed strategies do not match. Exact identifier searches return matching definitions, including ambiguous names. Queries are treated as text, not FTS expressions or SQL wildcard patterns. Local search does not enumerate repository files or run Git/framework discovery. MCP global search reuses read-only database connections and bounds concurrent searches. Results retain separate repository identities and deterministic ranking.

ctx context shares a 200 ms default deadline across retrieval and subprocesses, verifies the source hashes of selected evidence, and caps compact JSON output at 3,500 bytes by default. index_status: indexed means a published snapshot exists; it does not certify the entire working tree as current. Returned source evidence is checked individually. Timeouts, unverified evidence, and generation changes are reported explicitly. Literal search uses fixed strings and structured ripgrep output.

Index updates publish atomically in SQLite transactions, including a generation ID. An unsuccessful write rolls back the update. Go syntax evidence is labeled syntax_verified; regex-derived symbols are heuristic, and source-text hits are text_match. Syntax recognition does not imply compiler-resolved calls or types.

Repeatable search benchmarks (fixture setup excluded):

go test ./internal/engine -run '^$' -bench '^BenchmarkSearch$' -benchmem

The initial 10,000-file exact-identifier benchmark on an Apple M2 measured 26.56 ms and 9.44 MB allocated per query. The indexed implementation measured roughly 0.076 ms and 3.3 KB including snapshot isolation. A separate 30-query warm MCP comparison on this Cortex checkout measured median latency of 10.39 ms before and 0.14 ms after (p95: 42.69 ms before, 0.25 ms after). These are local query measurements, not end-to-end MCP or arbitrary full-text search guarantees.

Validation includes literal punctuation, cancellation, output budgets, stale source exclusion, duplicate filenames, Go package imports, full/incremental graph equivalence, transaction rollback, and live global connections observing new index generations.

Offline retrieval quality

The core stays local: no API keys, embedding models, vector services, or LLM calls for indexing, search, or dependency analysis. The connected agent handles planning and reasoning over Cortex's evidence. Lexical search splits identifier spelling (RefreshAccessToken → refresh access token, HTTPHeader → http header); it does not infer semantic similarity. Exact identifier lookup retains its indexed fast path. Lexical symbol results include the definition's line and confidence.

Static JavaScript/TypeScript import extraction handles multiline declarations, named aliases, namespaces, re-exports, and side-effect imports while excluding comments and quoted examples. Relative .js imports can resolve to indexed .ts or .tsx source. File impact follows reverse imports through symbol-free barrels and cycles, returning dependency_paths that explain why each file is included. These are module dependencies, not compiler-verified function calls. Ambiguous filenames require a repository-relative path; unresolved external namesakes are reported as uncertainty instead of being counted as local symbol dependents.

Run the labeled regression evaluation without network access:

go test ./internal/engine -run '^TestOfflineQuality$' -v

The hand-written fixture contains Go, Python, and TypeScript source, 12 query/file labels, four import-edge labels, four transitive file-impact labels, and unrelated or commented-out imports as negative examples. On this fixture:

Measure	Before this quality update	After
Expected file found in top 3 unique files	6/12	12/12
Mean reciprocal rank, top 3	0.500	1.000
Expected dependency edges found	1/4	4/4
Correct dependency edges / returned edges	1/2	4/4
Expected affected files found	0/4	4/4
Correct affected files / returned files	0/1	4/4

These are small, targeted regression results, not an independent benchmark or a measurement of agent task success. They do not establish superiority over code-review-graph or Sourcegraph. Additional regressions cover a 13-hop dependency cycle, incremental/full rebuild equivalence, ambiguous filenames, and actual task context returning a verified definition location. Wider evaluations should use held-out repositories and identical agent tasks, measuring missed dependencies, irrelevant context, task correctness, and latency together.

Known boundaries: TS/JS scanning remains heuristic. Dynamic loading, compiler overload/type resolution, and implicit same-package references are not fully modeled. File impact exposes that limitation explicitly.

Index format 4: offline retrieval and local modules

• Git repositories respect Git's ignore rules, including tracked-file exceptions. Generated Graphify output, frontend bundles under frontend-build, and common build caches are excluded by default. Custom .context/config.yaml ignore entries extend the defaults; a final !relative/path entry explicitly includes a file or directory. Re-run ctx build after changing configuration.
• FTS ranking no longer generates snippets for every candidate. Selected document previews read at most 8,192 characters and return roughly 320 characters. A preview is not an exact-line citation and may omit a match later in a document. Literal lookup still uses ripgrep; symbol results retain definition locations.
• Symbol search includes signatures and adjacent comments. If all-term retrieval misses, a bounded lexical fallback requires at least two distinct matching terms and labels its results partial_text. Simple plural/-ing normalization is spelling normalization, not semantic search. No model is loaded or called.
• Implementations rank above same-name synthetic re-exports.
• Local module resolution reads the nearest tsconfig.json, JSONC, relative extends, baseUrl, and paths, plus declared npm/pnpm workspace packages and their exports. Duplicate package names and conflicting conditional exports stay unresolved. Package-based config inheritance, project-reference config selection, arbitrary workspace glob syntax, and runtime platform inference are not supported.
• Changes to standard resolution/ignore metadata trigger graph rebuilding. Changes to effective Cortex ignore settings also force a full build. Changes to an arbitrarily named extended config require an explicit full rebuild.

Run ctx build --full after upgrading; index format changes also trigger a full rebuild on the next ctx build. Restart existing MCP servers to load the new binary.

make release requires the full test suite and portable accuracy regressions. Local quality checks additionally enforce the real-repository gate: at least 5/6 query hits, all labeled edges and consumers, no false negative-control edges, and warm in-process p95 below 50 ms per codebase. These are source-labeled retrieval tests, not proof of agent task success or superiority over another tool.