wicked-estate

         _      _            _                 _        _       
         (_)    | |          | |               | |      | |      
__      ___  ___| | _____  __| |______ ___  ___| |_ __ _| |_ ___ 
\ \ /\ / / |/ __| |/ / _ \/ _` |______/ _ \/ __| __/ _` | __/ _ \
 \ V  V /| | (__|   <  __/ (_| |     |  __/\__ \ || (_| | ||  __/
  \_/\_/ |_|\___|_|\_\___|\__,_|      \___||___/\__\__,_|\__\___|

What your agents know about your system. wicked-estate turns a repo, and the infrastructure, policy, and mainframe estate around it, into a code graph, memory and knowledge an LLM agent can actually use: blast-radius of change, requirements↔implementation, infra + policy relationships, and operational history, across 114 languages. Memory is what happened and what you told it; knowledge is what it learned from your code and docs; the two stay separate and cited. Every edge carries {confidence, provenance, resolved_by}; a heuristic is never handed to an agent as a fact. Portable by design — one static binary, local-first on SQLite, or a shared concurrent team backend on Postgres.

wicked-brain (retired 2026-08) migrated its memory + knowledge here zero-loss; the agent surface is wicked-garden's mem/search skill domains.

Status: see the crates.io page for the current release. 0 build warnings and clippy -D warnings clean, both CI-enforced on every push. Greenfield, pre-1.0. See FEATURES.md for the exhaustive, honestly-tagged capability inventory (✅ built / 🟡 partial / 🟦 designed-not-built).

---

Where it sits in the platform

Your coding agents do the work. A different agent checks it against your rules. You get the evidence. The wicked platform is four layers — one surface, one control plane, one catalog, one record — and estate is the record the others read before they act and write after. SQLite by default; no servers, no accounts, nothing leaves your machine.

Layer	Product	What it does	Stack
Surface	wicked-studio	Where you direct your coding agents: start a job with a chat, watch sandboxed agents work, approve what matters with the evidence.	TS
Control plane	wicked-crew (engine: wicked-core)	Runs the jobs: agents in sandboxes, a different agent reviews the work, app changes pass acceptance testing before delivery.	npm · Rust
Catalog	wicked-garden	The skills your coding agent can't build alone — evidence-gated "done", graph-aware refactor, 40 QE specialists, review panels from other models.	JS/TS
Record	wicked-estate (this repo)	What your agents know about your system — code graph, memory and knowledge with provenance.	Rust · crates.io
Record	wicked-interactive	The document engine behind studio's docs, decks and captioned demo recordings.	TS
Infra	wicked-bus	The durable local event bus beneath it all — at-least-once, replayable.	JS/ESM · npm

Absorbed into this repo as internal crates (not separate products): wicked-memory → wicked-estate-memory, wicked-knowledge → wicked-estate-knowledge, wicked-overlay → wicked-estate-overlay.

Why

LLM coding agents waste turns grepping and re-reading files. wicked-estate gives them a precise, ranked, bounded answer instead — "who calls this?", "what breaks if I change it?", "give me just the context for this symbol" — across 114 languages (103 wired tree-sitter grammars + 6 grammar-less mainframe extractors; including legacy enterprise stacks: VB6/VBA/VBScript/VB.NET, RPG, Delphi, ColdFusion, Progress ABL, PowerBuilder, Visual FoxPro, LotusScript, Informix 4GL, Crystal Reports) and a mainframe/IaC estate layer (COBOL, JCL, RACF, IMS, MQ, Terraform, CloudFormation, …) that almost nothing else unifies into one graph. Every edge carries {confidence, provenance, resolved_by}; heuristics are never presented as facts.

Install

Two binaries: the wicked-estate CLI (index / query / blast-radius / rank / drift / plugins / …) and the wicked-estate-mcp server your agent connects to.

Prebuilt binaries (no Rust toolchain)

Every release tagged after wicked-estate#360 attaches one archive per platform to its GitHub Release, with both binaries plus LICENSE, NOTICE and this README, and a SHA256SUMS file:

Platform	Archive
macOS, Apple silicon	wicked-estate-<version>-aarch64-apple-darwin.tar.gz
macOS, Intel	wicked-estate-<version>-x86_64-apple-darwin.tar.gz
Linux x86_64 (glibc ≥ 2.28)	wicked-estate-<version>-x86_64-unknown-linux-gnu.tar.gz
Linux arm64 (glibc ≥ 2.28)	wicked-estate-<version>-aarch64-unknown-linux-gnu.tar.gz
Windows x64	wicked-estate-<version>-x86_64-pc-windows-msvc.zip

V=<version> T=x86_64-unknown-linux-gnu   # e.g. V=0.31.0; T from the table above
curl -LO https://github.com/mikeparcewski/wicked-estate/releases/download/v$V/wicked-estate-$V-$T.tar.gz
curl -LO https://github.com/mikeparcewski/wicked-estate/releases/download/v$V/SHA256SUMS
sha256sum -c SHA256SUMS --ignore-missing      # macOS: shasum -a 256 -c SHA256SUMS --ignore-missing
tar -xzf wicked-estate-$V-$T.tar.gz && cp wicked-estate-$V-$T/wicked-estate* ~/.local/bin/
gh attestation verify wicked-estate-$V-$T.tar.gz --repo mikeparcewski/wicked-estate   # optional

• Linux binaries are built against glibc 2.28, so they start on RHEL/Alma/Rocky 8+, Debian 10+ and Ubuntu 20.04+. They are glibc builds and not static musl ones, because a musl binary cannot dlopen the runtime grammar plugins (PLUGIN.md).
• macOS binaries are not notarized yet. After downloading, clear the quarantine flag once: xattr -d com.apple.quarantine wicked-estate wicked-estate-mcp.
• Windows binaries link the C runtime statically, so no VC++ redistributable is needed.
• The prebuilt binaries are the default feature set: offline, no ONNX. For semantic embedders, use cargo install … --features model2vec|fastembed (below).

From crates.io or source

# from crates.io:
cargo install wicked-estate       # the CLI — index / query / blast-radius locally
cargo install wicked-estate-mcp   # the MCP server the agent connects to

# Or straight from this repo (install both from git):
cargo install --git https://github.com/mikeparcewski/wicked-estate wicked-estate
cargo install --git https://github.com/mikeparcewski/wicked-estate wicked-estate-mcp

# Or build from source (gives you both the wicked-estate CLI and the MCP server):
git clone https://github.com/mikeparcewski/wicked-estate
cd wicked-estate && cargo build --release   # binaries in target/release/

Real semantic search is opt-in (keeps the default build dependency-free + offline):

cargo install wicked-estate-mcp --features model2vec   # static embeddings, light, no ONNX
cargo install wicked-estate-mcp --features fastembed   # contextual ONNX/BGE, highest quality

Quickstart

# Index a repo into a local graph
wicked-estate index ./my-project --db graph.db

# Several repos in ONE graph — label each one (co-location, not cross-repo linking)
wicked-estate index ../wicked-ledger --db graph.db --repo ledger
wicked-estate index ../wicked-vault  --db graph.db --repo vault

# Who/what depends on a symbol (blast radius = transitive dependents)
wicked-estate blast-radius MyClass --db graph.db

# How does A reach B? The ordered hops, each with its edge confidence
wicked-estate path http_handler db_write --db graph.db

# Find a symbol + print its source
wicked-estate query handleRequest --db graph.db
wicked-estate source handleRequest --db graph.db

# Most important symbols (PageRank)
wicked-estate rank --db graph.db

# Semantic search (after: wicked-estate index … --embeddings, built with a semantic feature)
wicked-estate semantic "login security check" --db graph.db

# Stats (incl. git provenance), keep it watching, or stream changes
wicked-estate stats --db graph.db
wicked-estate watch ./my-project --db graph.db

What it does (highlights — full list in FEATURES.md)

• Live technical environment, queryable — the lead: requirements↔implementation, blast-radius of change, infra + policy relationships, and operational history, all keyed to one stable symbol identity with {confidence, provenance, resolved_by} on every edge. This is what estate is — the environment around your code and the memory + knowledge layer (absorbed 2026-08; agent surface: wicked-garden's mem/search domains); estate maps what a change touches, what protects it, and what it was.
• Extraction engine — 114 languages (tree-sitter + grammar-less) — symbols, calls, imports, heritage feed the environment above. Languages are data (a manifest row + a .scm query) — adding one is zero core change; 103 of the 114 manifest rows have wired tree-sitter grammars (see the generated coverage matrix).
• Runtime language plugins — drop a compiled tree-sitter grammar + .scm query + manifest into the plugins dir and it loads at startup, no recompile. The grammar is a separate artifact, never linked into the (MIT) core — so a grammar under a license incompatible with MIT (GPL, etc.) stays isolated. A plugin can also override a built-in language — patch a query gap locally (override_query) or swap the whole grammar under an explicit double opt-in (override = true
  • WICKED_ESTATE_PLUGIN_OVERRIDE), loudly announced and audit-tracked (ADR-010). wicked-estate plugins list shows what's loaded; see PLUGIN.md and the nginx example.
• Precise blast-radius — bounded reverse-reachability over all dependency edge kinds (not just calls), so it never silently under-reports.
• Layered resolution — name / scoped / import-map / relative-import → SCIP (precise). Two-phase EXTRACT → RESOLVE; resolution is swappable without re-parsing. The on-demand LSP client is built as a library; its intent-routed edit-plane consumer is designed, not yet wired (ADR-009).

Architecture

The whole engine programs against five traits (wicked-estate-core); everything else is a swappable impl behind a seam:

Crate	Role
wicked-estate-core	types + the five traits (Extractor/Resolver/GraphStore/Ranker/RetrievalTool) + GraphStore conformance kit
wicked-estate-extract	tree-sitter + grammar-less extractors + W15 rules engine extractors
wicked-estate-resolve	reference resolvers (name/scoped/import-map/relative-import/SCIP/estate) + the LSP client library (ADR-009)
wicked-estate-store	storage (SQLite default + in-memory reference)
wicked-estate-rank	PageRank importance
wicked-estate-retrieve	agent-facing retrieval tools + hybrid/semantic search
wicked-estate-mcp	MCP server (wicked-estate-mcp binary)
wicked-estate	the wicked-estate CLI binary
wicked-estate-bench	agent-eval benchmark harness
wicked-estate-observe	OTLP HTTP/JSON exporter (OtlpSink) + wired emission sites
wicked-estate-overlay	internal — absorbed from wicked-overlay (XedgeStore cross-engine search layer)
wicked-estate-memory-core	internal — absorbed from wicked-memory (MemoryApi trait, CaptureRequest, RecallQuery types)
wicked-estate-memory	internal — absorbed from wicked-memory (memory engine impl)
wicked-estate-knowledge	internal — absorbed from wicked-knowledge (knowledge engine impl)
wicked-estate-memory-api	internal — absorbed from wicked-memory (shim crate for clean re-exports)

MCP

wicked-estate-mcp is a stdio MCP server (JSON-RPC 2.0) exposing 30 tools across 3 domains:

• Estate (12 tools): SearchEntity, RetrieveEntity, TraverseGraph, Path, BlastRadius, FetchContent, ContextBundle, RulesInventory, rules.recall, RankHotspots, Communities, Lineage
• Memory (7 tools): memory.capture, memory.recall, memory.reflect, memory.erase, memory.learn, memory.coverage, memory.list
• Knowledge (7 tools): knowledge.ingest, knowledge.write, knowledge.relate, knowledge.recall, knowledge.coverage, knowledge.relate_code, knowledge.recall_about_code
• Proposal queue (4 tools, memory-domain): proposal.submit, proposal.list, proposal.approve, proposal.reject

Register it in Claude Code, Cursor, Antigravity, or Codex. Per-client config: docs/mcp-integration.md.

The architecture wiki

Estate is also the serving layer of the wicked ecosystem's graph-backed architecture wiki (ADR-011): doctrine authored as frontmattered markdown docs, projected into the graph as conformance rules and knowledge chunks, and recalled with citations —

• rules.recall — which rules apply to what you're doing (faceted by language/layer/framework, severity-ordered, every hit citing <doc>@<blob sha>#<RULE-ID>). Pass projects to get the rules scoped to the projects you're working in; without it you get global rules only;
• knowledge.recall with {"scope_prefix": "wiki:"} — the rationale and ADR text behind them.

Authoring, seeding, retiring, and monitoring live in wicked-core's operator guide: wicked-core/crates/wicked-governance/WIKI.md.

wicked-estate index ./my-project --db .wicked-estate/graph.db
# Claude Code (or install the plugin: /plugin marketplace add mikeparcewski/wicked-estate):
claude mcp add wicked-estate -s project -- wicked-estate-mcp --db "$PWD/.wicked-estate/graph.db"
# Cursor / Antigravity: mcpServers in ~/.cursor/mcp.json or ~/.gemini/config/mcp_config.json
# Codex: a [mcp_servers.wicked-estate] table in ~/.codex/config.toml

Adding a language

Languages are data, not code. Add a row to crates/wicked-estate-extract/languages.toml, drop a crates/wicked-estate-extract/src/queries/<lang>.scm query (conventions: @code_<kind>.def + @code_<kind>.name, @call.function, @import), and wire one LangEntry. The every_wired_query_compiles test guards it. See docs/add-lang.md.

To add a language without recompiling the core — or to use a grammar under a license incompatible with MIT — ship it as a runtime plugin instead: a compiled grammar + query + manifest dropped into the plugins dir, loaded at startup. Plugins can also override a built-in language's query or grammar (see PLUGIN.md, "Overriding a built-in language"). See the nginx example.

Honest status (not yet true)

Per the project's "every done needs a still-not-done" rule:

• External DB + OpenTelemetry: the Postgres backend and the OTLP exporter are built ✅ (Postgres conformance-passes — concurrent writers + server-side traversal are real) — but Postgres isn't yet benchmarked at scale vs. SQLite, OTel has no zero-to-dashboard guide yet, and the SurrealDB challenger (built behind --features surrealdb) has no open_store factory wiring and no bake-off verdict.
• Cloud collectors (AWS/Azure/GCP): read-only interfaces + tfstate work; live collectors are observe-only stubs. Estate maturity trails the code-intelligence core.
• Semantic embedder tests are feature-gated (need a model download) — they run in the CI semantic-embedders lane, not the default suite.
• Niche mainframe modeling gaps (VSAM AIX, RECFM, COMP-3 usage metadata) and a few deferred languages (nim, pony, asm, odin).

Docs

FEATURES.md (full inventory) · PLUGIN.md (authoring runtime language plugins) · docs/MIGRATION-0.15.md (upgrading a 0.14.x DB — the mandatory re-index runbook) · docs/ENGINE-CONTRACT.md (invariants) · docs/agent-behavior-rules.md (the runtime contract) · docs/adr/ (decisions; ADR-009 defines the intent-routed LSP edit plane) · docs/plan/WAVE-PLAN.md (tracker) · RELEASING.md (publishing to crates.io) · docs/DESIGN-NOTES.md (the design principles behind the engine).

License

MIT © Michael Parcewski — see LICENSE.