Blockchain explorer for Lava Network. Tracks providers, chains (specs), relay payments, staking, and supply on Lava Mainnet.
# Local dev (requires Node 22 + pnpm 10)
pnpm install && pnpm dev
# Docker dev (zero prerequisites, hot reload on code changes)
docker compose -f docker-compose.dev.yml up --build
# API → localhost:8080 | Web → localhost:3001 | Indexer GraphQL → localhost:3000pnpm typecheck # type check all packages
pnpm test # vitest┌─────────────────┐ ┌───────────────────────────────────────┐
│ apps/web │ REST │ apps/api │
│ Next.js 15 │─────────────▶│ Fastify 5 (:8080) │
│ (:3001) │ │ │
│ │ │ ┌──────────┐ ┌──────────────────┐ │
│ SWR cache │ │ │ Redis │ │ Chain RPC/REST │ │
│ axios client │ │ │ (cache) │ │ (live state) │ │
│ TanStack Table │ │ └──────────┘ └──────────────────┘ │
│ Recharts │ │ │ │ │
└─────────────────┘ │ ┌─────┴──────────────────┴────────┐ │
│ │ Route handlers │ │
│ │ apps/api/src/routes/*.ts │ │
│ └─────────────────────────────────┘ │
└──────────────┬────────────────────────┘
│ GraphQL (PostGraphile)
┌──────────────▼────────────────────────┐
│ Indexer (:3000) │
│ PostgreSQL + PostGraphile │
│ lava-indexer repo │
│ │
│ Tables (1): │
│ relay_payments (18.8M rows) │
│ │
│ Materialized View (auto-created): │
│ mv_relay_daily │
│ → (date, chain_id, provider) │
│ → cu, relays, qos weighted sums │
│ Refreshed every 5 min via pg_cron │
└───────────────────────────────────────┘
Every API route uses exactly one data source per query. Never mix them in a single call.
| Source | What it provides | Access pattern |
|---|---|---|
Indexer GraphQL (INDEXER_GRAPHQL_URL, default http://localhost:3000) |
Historical relay data, events, reports, conflicts | gql<T>(query, vars) from graphql/client.ts |
Chain RPC REST (LAVA_REST_URL, default https://lava.rest.lava.build) |
Live state: specs, providers per spec, stakes, supply, subscriptions, staking pool | fetchRest<T>(path) from rpc/lava.ts |
Chain RPC Tendermint (LAVA_RPC_URL, default https://lava.tendermintrpc.lava.build:443) |
Latest block height and time; historical block-by-height lookup | fetchLatestBlockHeight(), fetchBlockAtTimestamp(unix) in rpc/lava.ts |
Redis — cache (REDIS_URL) |
Response-level cache (not a data source) | Automatic via cacheTTL in route config |
Redis — health store (REDIS_URL) |
Provider health probe results (gRPC Probe, 10min TTL) | readHealthMapForProvider() / readHealthByProviderForSpec() from services/health-store.ts |
Relays DB (RELAYS_DB_URL) |
Consumer optimizer metrics (aggregated hourly scores). DB resides outside AWS. TODO: evaluate a different approach for optimizer metrics data ingestion | app.relaysDb via plugins/relays-db.ts |
| Keybase API | Provider avatars from identity field | fetchProviderAvatar() in rpc/lava.ts |
CoinGecko API (COINGECKO_API_URL, default https://api.coingecko.com/api/v3) |
Current and historical LAVA/USD price | fetchLavaUsdPrice(), fetchLavaUsdPriceAt(date) in rpc/lava.ts |
Cache is set per-route via config, handled automatically by onRequest/onSend hooks:
app.get("/path", { config: { cacheTTL: 300 } }, handler)No cache calls inside handlers. TTL guidelines:
- Health/realtime: 10–30s
- Lists/aggregates: 60–300s
- Supply/TVL: 300s
- APR: 1800s (expensive — iterates all providers/validators)
- Avatars: 86400s (24h)
Never query raw relayPayments (18.8M rows) — it will timeout. Always use:
mvRelayDailies— aggregated by(date, chain_id, provider). Has:cu,relays,qosSyncW,qosAvailW,qosLatencyW,qosWeight,exQosSyncW,exQosAvailW,exQosLatencyW,exQosWeight, plus delta-compatible per-row sums (qosSyncSum,qosAvailSum,qosLatencySum,qosCount,qosCu,exQosSyncSum,exQosAvailSum,exQosLatencySum,exQosCount).
Date filters must use Date type with YYYY-MM-DD format (not Datetime, not ISO):
query($since: Date!) {
mvRelayDailies(filter: { date: { greaterThanOrEqualTo: $since } }) { ... }
}QoS is computed from weighted sums, not simple averages:
const qosSync = qosWeight > 0 ? qosSyncW / qosWeight : null;The MV is auto-created by a PostgreSQL event trigger in lava-indexer/docker/init.sql and refreshed every 5 minutes via pg_cron.
apps/
api/ Fastify 5 REST API (port 8080)
src/
routes/ One file per resource (index, providers, specs, etc.)
rpc/lava.ts All chain RPC/REST calls + business logic (supply, TVL, APR, display names)
graphql/client.ts GraphQL client wrapper — gql<T>(query, vars)
plugins/cache.ts Redis cache plugin (onRequest/onSend hooks, normalized keys)
plugins/pagination.ts Pagination with configurable per-route maxLimit
plugins/redis.ts Shared Redis client decorator (app.redis)
plugins/health-probe.ts Background gRPC health probe (ENABLE_HEALTH_PROBE=true)
services/grpc-probe.ts Native gRPC Relayer.Probe() client
services/health-store.ts Redis read/write for health data
proto/relay.proto Minimal proto for Lava Relayer.Probe RPC
web/ Next.js 15 App Router frontend
src/
app/ Pages mirror API structure (chains/, providers/, provider/[lavaid]/, etc.)
components/
ui/ shadcn primitives (badge, button, card, table, tabs)
data/ Domain components (ChainLink, ProviderLink, LavaAmount, StatCard, Chart, SortableTable)
layout/ Shell (Header, Footer, MobileNav, SearchBar)
hooks/ useApi (SWR), useChainNames
lib/ Utilities (api-client, chain-icons, format, cn)
public/chains/ 32 SVG chain icons, convention-based: /chains/{specId}.svg
packages/
shared/ Shared constants (BASE_SPECS, geolocation, block normalization)
| Endpoint | Cache | Source | Description |
|---|---|---|---|
GET /index/stats |
300s | Indexer MV + Chain RPC | Alltime totals (CU, relays), 30-day totals, total stake (sum across all providers), active provider count, latest block height/time |
GET /index/top-chains |
300s | Indexer MV | Top 20 chains by alltime CU. Groups mvRelayDailies by CHAIN_ID |
GET /index/charts?from=&to= |
300s | Indexer MV | Daily time-series per chain. Collapses provider dimension by re-aggregating MV by (date, chainId). Default 90 days. Returns: date, chainId, cu, relays, qosSync, qosAvailability, qosLatency |
| Endpoint | Cache | Source | Description |
|---|---|---|---|
GET /providers?page=&limit= |
300s | Chain RPC + Indexer MV | Paginated provider list. Fetches all providers from chain, enriches with 30d relay data from MV (grouped by PROVIDER). Sorted by totalStake desc. Returns: provider, moniker, identity, activeServices, totalStake, totalDelegation, commission, cuSum30d, relaySum30d |
GET /providers/:addr |
300s | Chain RPC | Provider detail. Fetches every spec and checks if provider is staked. Returns stakes array with: specId, stake, delegation, moniker, delegateCommission, geolocation, addons, extensions |
GET /providers/:addr/stakes |
300s | Chain RPC | Same as above but returns only the stakes array (no moniker) |
GET /providers/:addr/health?page=&limit= |
30s | Redis | Paginated health records from gRPC probe (stored in Redis with 10min TTL) |
GET /providers/:addr/charts?from=&to=&chain= |
300s | Indexer MV | Two modes: (1) No params → alltime summary grouped by chain (cu, relays per chainId). (2) With date params → daily time-series with QoS + excellence QoS. Can filter by chain |
GET /providers/:addr/avatar?identity= |
86400s | Keybase API | Avatar URL from Keybase identity. Hint param skips provider metadata lookup. Returns { url: string | null } |
GET /providers/:addr/delegator-rewards |
300s | Chain RPC | Delegator rewards from dualstaking module |
GET /providers/:addr/optimizer-metrics?from=&to=&consumer=&chain_id= |
300s | Relays DB | Consumer optimizer metrics for this provider. Returns WRS + score averages, possible consumers/chains for filters |
| Endpoint | Cache | Source | Description |
|---|---|---|---|
GET /specs |
300s | Chain RPC + Indexer MV | All specs (excluding base specs). Returns: specId, name (display name with proper casing), providerCount, relays30d, cu30d. Provider counts fetched per-spec from chain. 30d relay data from MV grouped by CHAIN_ID |
GET /specs/:specId/stakes |
300s | Chain RPC | Providers staked on this spec: provider, moniker, stake, delegation, delegateCommission, geolocation |
GET /specs/:specId/health |
30s | Redis | Health status distribution (grouped by STATUS, from gRPC probe) |
GET /specs/:specId/charts |
300s | Indexer MV | Alltime CU/relays for this chain (grouped by CHAIN_ID) |
GET /specs/:specId/optimizer-metrics?from=&to=&consumer= |
300s | Relays DB | Consumer optimizer metrics for this chain. Returns per-provider scores, possible consumers/providers for filters |
| Endpoint | Cache | Source | Description |
|---|---|---|---|
GET /supply/total |
300s | Chain RPC | Total supply in LAVA (plain text). fetchTotalSupply() / 1_000_000 |
GET /supply/circulating |
300s | Chain RPC | Circulating supply in LAVA (plain text). Formula: total - continuousVesting - periodicVesting - rewardPools. Paginates through all ~53K accounts to calculate locked vesting amounts. 5 reward pools subtracted: validators_rewards_distribution_pool, validators_rewards_allocation_pool, providers_rewards_distribution_pool, providers_rewards_allocation_pool, iprpc_pool |
| Endpoint | Cache | Source | Description |
|---|---|---|---|
GET /health |
— | — | Returns { health: "ok" } |
GET /health/status |
10s | Chain RPC | Block height + staleness check (>5 min = degraded). Returns 503 on RPC error |
GET /search?q= |
600s | Chain RPC | Searches providers (by address/moniker) and specs (by specId/name). Case-insensitive substring match. Returns all if no query |
GET /tvl |
300s | Chain RPC + CoinGecko | TVL (USD) = bonded tokens + reward pools + subscriptions + DEX liquidity. All components converted to USD via CoinGecko LAVA price |
GET /apr |
1800s | Chain RPC + CoinGecko | Per-entity APR percentiles matching jsinfo. Queries estimated_{provider,validator}_rewards for all providers/validators with 10k LAVA benchmark, converts multi-denom rewards to USD, compounds monthly, takes 80th percentile, caps at 30%. Returns { restaking_apr_percentile, staking_apr_percentile }. Uses 7-day weighted Redis history when available |
GET /all_providers_apr |
1800s | Chain RPC + CoinGecko + Indexer MV | Per-provider APR data matching jsinfo. Returns array of providers with: APR, commission, 30d CU/relays, 10k LAVA reward breakdown, per-spec rewards (rewards_last_month), specs, avatar |
GET /lava/specs |
300s | Chain RPC | All chain specs with { index, name, icon }. Used by frontend useChainNames hook; icon is an absolute URL (INFO_ICONS_BASE_URL + /chains/<slug>.svg) for cross-origin consumers |
GET /provider-rewards?from=&to=&groupBy= |
300s | Indexer MV | Per-provider (default) or per-(provider, spec) QoS-adjusted reward shares. Required: from, to (YYYY-MM-DD, exclusive end, max 6 months). Optional: specs (chain filter), groupBy (provider default, or spec). In provider mode the GraphQL pools all chains before computing cbrt(...) — required for parity with delta's adjustedRewards because the formula is non-linear. In spec mode each row is a (provider, spec) pair with within-spec rewardShare. Returns { meta, data: [{ provider, [spec]?, moniker, relays, cus, qosCus, avgLatency, avgAvailability, avgSync, avgLatencyExc, avgAvailabilityExc, avgSyncExc, adjustedRewards, rewardShare }] }. Replaces lava-ops Job 1. For USD estimates use /provider-estimated-rewards |
GET /provider-estimated-rewards?block=&spec= |
1800s (86400s with block) |
Chain RPC + CoinGecko | Per-provider actual chain rewards from estimated_provider_rewards RPC, grouped by spec. Optional block=N for historical queries (requires archive node; threads x-cosmos-block-height header). Optional spec=X filters response. USD values always use CURRENT CoinGecko price, even for historical blocks (matches lava-ops Job 2 behavior) — meta.priceLavaUsd / meta.priceTimestamp surface this explicitly. Returns { meta: { block, spec, priceLavaUsd, priceTimestamp }, data: [{ provider, moniker, rewards: [{ chain, spec, tokens, total_usd }], total_usd }] }. Sorted by total_usd descending. Replaces lava-ops Job 2 |
GET /provider-estimated-rewards/blocks?count= |
86400s | Chain RPC | Historical monthly-17th blocks for the block-selector UI. Maps each month's 17th at 15:00 UTC to a block height via fetchBlockAtTimestamp. Default 12 months, max 24. Returns { data: [{ height, time, date }] } |
GET /provider-claimable-rewards |
7200s | Chain RPC + CoinGecko | Per-provider self-delegation claimable rewards via /lavanet/lava/dualstaking/delegator_rewards/{addr}, converted to multi-denom USD. Returns { providers: { [addr]: { rewards: [{ amount, denom, usdcValue, provider }], timestamp } } }. Replaces jsinfo's /lava_mainnet_provider_claimable_rewards |
GET /validators-and-rewards |
7200s | Chain RPC + CoinGecko | All bonded validators with distribution rewards, outstanding rewards, estimated rewards, delegations, and unbonding — all converted to USD. 5 RPC calls per validator, batched RPC_BATCH_SIZE validators at a time. Returns { data: { height, datetime, validators: [...] } }. Replaces jsinfo's /lava_mainnet_validators_and_rewards |
GET /burn-rate?months= |
86400s | Chain RPC | Monthly total-supply snapshots sampled at the 17th of each past month at 15:00 UTC. supply_diff = previous_supply - current_supply (positive = burned, negative = minted). Default 12 months, max 36. Returns { generated_at, latest: { block, time, supply }, blocks: [{ block, time, date, supply, supply_diff }] }. Replaces lava-ops Job 3 |
GET /lava_chain_stakers |
300s | Chain RPC | Unique delegator counts across all active providers plus the empty_provider bucket (validator-only delegators). Returns { total, monthly } where monthly filters delegations by timestamp ≥ now-30d. Restored from jsinfo |
GET /lava_chain_restakers |
300s | Chain RPC | Same as /lava_chain_stakers but excludes empty_provider — counts only delegators that explicitly picked a provider via Lava CLI. Returns { total, monthly }. Restored from jsinfo |
GET /total_value_locked, GET /total_locked_value, GET /tlv |
300s | Chain RPC + CoinGecko | Aliases for /tvl, restored from jsinfo for backwards compatibility. Same handler, same payload |
All paginated endpoints accept: ?page=1&limit=20&sort=field&order=asc|desc
Response shape: { data: T[], pagination: { total, page, limit, pages } }
The API provides pagination via request.pagination (Fastify plugin). Default max limit is 100 per page, configurable per-route via config.maxLimit. Frontend fetches all providers client-side (?limit=10000) then sorts with TanStack Table.
useApi<T>(url)— SWR wrapper with 5-min refresh, returns{ data, isLoading, error }useChainNames()— fetches/lava/specsand returns agetName(chainId)lookup- API base URL from
NEXT_PUBLIC_API_URL
ChainLink— chain ID with SVG icon + link to/chain/{specId}.showNameprop renders full name on top, specId below in muted textProviderLink— provider address/moniker with Keybase avatar or letter placeholderLavaAmount— formats ulava string to LAVA with locale number formattingStatCard— metric card (label, value, optional icon)SortableTable— TanStack Table wrapper with sorting + paginationChart— Recharts ComposedChart wrapper for time-series
- Convention-based:
/chains/{specId}.svgwith aliases inlib/chain-icons.tsfor specIds that don't match filenames - Fallback: letter placeholder on
onError - To add a new chain: drop
{name}.svginpublic/chains/, add alias toALIASESmap if specId differs
- All tables use TanStack React Table with client-side sorting (
getSortedRowModel()) - Every column needs
accessorFnfor sorting to work - Columns with BigInt values need numeric accessors:
accessorFn: (row) => Number(toBigInt(row.field))
| Concept | Description |
|---|---|
| Provider | Node operator staked on one or more chains (specs). Identified by lava@... address. Has moniker, identity (Keybase), stake per spec, delegation, commission |
| Spec (Chain) | A supported blockchain network (e.g., ETH1 = Ethereum Mainnet). Has specId (uppercase) and display name |
| Relay | A single RPC request routed through Lava from consumer → provider. Tracked with CU (compute units) cost |
| CU (Compute Units) | Weight of a relay. Different RPC methods cost different CU amounts |
| Stake | Provider's own tokens locked per spec. In ulava |
| Delegation | Tokens delegated to a provider by third parties. In ulava |
| Commission | Percentage (integer, already a percentage — 75 means 75%) the provider takes from delegation rewards |
| QoS | Quality of Service scores: sync, availability, latency. Weighted averages stored in MVs |
| Excellence QoS | Better QoS metric — same fields prefixed with ex |
| Geolocation | Bitmask field. 0x1=US-Center, 0x2=Europe, 0x4=US-East, 0x8=US-West, 0x10=Africa, 0x20=Asia, 0x40=AU-NZ |
| Addons | Extra capabilities (comma-separated string from joined endpoint addons) |
| Extensions | Protocol extensions (comma-separated string from joined endpoint extensions) |
| Base Specs | Abstract specs (COSMOSSDK, COSMOSSDK50, COSMOSWASM, ETHERMINT, TENDERMINT, IBC, SUIGRPC, SUIJSONRPC) — not real chains, excluded from UI |
| IPRPC | Incentivized Public RPC — bonus rewards for specific specs |
- All token amounts from chain are in ulava (1 LAVA = 1,000,000 ulava)
- Always use
BigInt— ulava values overflow JavaScriptNumber - Display: divide by 1e6, format with locale (e.g.,
1,234,567 LAVA) - Circulating supply = total supply - locked continuous vesting - locked periodic vesting - 5 reward pools
rpc/lava.tshas aCHAIN_DISPLAY_NAMESoverride map for chains that need custom names (BSC→"BNB Chain Mainnet", ETH1→"Ethereum Mainnet", etc.)- Fallback:
titleCase(chainName)from chain RPC - Mainnet/Testnet suffix comes from chain name or is part of the override
The provider detail page (/providers/:addr) is expensive — it queries every spec on chain to find which ones the provider is staked on. This is done via fetchAllSpecs() then fetchProvidersForSpec(specId) for each spec, in batches of 5 to avoid rate limiting. The results are combined into a stakes array.
fetchAllProviders() does the same but also deduplicates by address and sums up totalStake/totalDelegation across all specs.
| Trap | Reality |
|---|---|
| Commission values | Already percentages from chain (75 = 75%). Do NOT multiply by 100 |
| Token amounts | In ulava (1 LAVA = 1,000,000 ulava). Use BigInt — Number overflows |
| Materialized view | Must use mvRelayDailies for relay aggregates. Raw relayPayments (18.8M rows) will timeout |
| MV date filters | Use Date type with YYYY-MM-DD format, NOT Datetime / ISO |
| QoS computation | Default is relay-weighted: qosSyncW / qosWeight. Exception: /provider-rewards uses unweighted row-level averaging (qosSyncSum / qosCount) for delta parity |
| Geolocation | Bitmask, not enum. A provider can be in multiple regions |
| Base specs | COSMOSSDK, COSMOSSDK50, COSMOSWASM, ETHERMINT, TENDERMINT, IBC, SUIGRPC, SUIJSONRPC — exclude from chain lists |
| React hooks | All useMemo/useState/useApi calls MUST come before conditional early returns |
next dev + standalone |
output: "standalone" crashes next dev. Docker dev mounts next.config.dev.ts without it |
| Provider detail perf | Queries every spec on chain — inherently slow. Cache is essential (300s TTL) |
delegate_commission |
API returns camelCase delegateCommission, not snake_case |
| Batch size for RPC | Fetch provider data in batches of 5 specs to avoid rate limiting on public RPC |
| Reward pools | Exactly 5 named pools. If Lava adds more, fetchRewardPoolsAmount() needs updating |
| Vesting calculation | ContinuousVesting uses linear interpolation between start/end time. PeriodicVesting sums future periods. Must paginate through ~53K accounts |
| Variable | Default | Used by |
|---|---|---|
API_PORT |
8080 |
API |
API_HOST |
0.0.0.0 |
API |
INDEXER_GRAPHQL_URL |
http://localhost:3000 |
API |
REDIS_URL |
(none, cache disabled) | API |
LAVA_REST_URL |
https://lava.rest.lava.build |
API |
LAVA_RPC_URL |
https://lava.tendermintrpc.lava.build:443 |
API |
RPC_BATCH_SIZE |
25 |
API — max concurrent chain-RPC calls per batch loop (raise on dedicated endpoints; lower on public RPC to avoid rate limiting) |
RELAYS_DB_URL |
(none, optimizer metrics disabled) | API — PostgreSQL connection to relays DB (external, outside AWS) |
ENABLE_HEALTH_PROBE |
false |
API |
HEALTH_PROBE_REGION |
Local |
API |
HEALTH_PROBE_INTERVAL_MS |
30000 |
API |
CORS_ORIGINS |
true (all) |
API — comma-separated origins, e.g. https://info.lavanet.xyz,http://localhost:3001 |
RATE_LIMIT_MAX |
100 |
API — global rate limit per IP per minute |
COINGECKO_API_URL |
https://api.coingecko.com/api/v3 |
API |
KEYBASE_API_URL |
https://keybase.io/_/api/1.0 |
API |
NEXT_PUBLIC_API_URL |
http://localhost:8080 |
Web |
NODE_ENV |
production |
Web |
- Provider errors — requires Relays DB (
lava_report_errortable), not in the indexer Optimizer metrics— Implemented. Reads fromaggregated_consumer_optimizer_metricsin relays DB viaRELAYS_DB_URL. TODO: evaluate a different approach for optimizer metrics data ingestion — the current direct DB connection to an external PostgreSQL is a stopgap- Logpush endpoints (
stats,entries) — separate Cloudflare Logpush service - Full validator list —
/validatorsreturns emptydata: [], only has staking pool info
See .claude/ for team-shared settings, commands, rules, agents, skills, and hooks:
.claude/settings.json— team permissions + hooks (committed)CLAUDE.local.md— personal overrides (gitignored)
.claude/rules/api-conventions.md— auto-loads when editingapps/api/**.claude/rules/frontend.md— auto-loads when editingapps/web/**.claude/rules/code-style.md— TypeScript, React, Tailwind conventions (always loaded).claude/rules/testing.md— Vitest patterns (always loaded).claude/rules/git-workflow.md— Commit conventions, branching, PR workflow (always loaded)
/project:fix-issue <number>— Fetch GitHub issue, analyze, implement fix, run tests/project:fix-pr— Fetch unresolved PR review comments, fix them all/project:deploy [target]— Pre-deploy checks + push + PR/project:context-prime— Prime context at session start or after compaction
- PostToolUse (Write|Edit) — Runs
pnpm typecheckon the affected package after every file edit. Catches TypeScript errors immediately instead of letting them compound.
Goal: Comprehensive parallel code review that catches architecture, security, performance, and style issues before merge.
Agents:
| Agent | Role |
|---|---|
| arch-reviewer | Data flow, separation of concerns, API contracts, dependency direction, domain model integrity |
| security-reviewer | Injection vectors, secrets exposure, input validation, SSRF, dependency risks, Docker security |
| perf-reviewer | N+1 queries, unbounded fetches, missing caches, React re-renders, bundle bloat, BigInt misuse |
| style-reviewer | TypeScript strictness, React patterns, Tailwind conventions, API conventions, domain correctness |
| refactor-planner | Plans refactoring strategies before execution (standalone, not part of review fan-out) |
Skills:
| Skill | Purpose | Used by |
|---|---|---|
| code-review | Orchestrator — fans out to 4 agents in parallel, merges findings into unified report | All review agents |
Execution rules:
- For code review, quality checks, PR review, or pre-push gates → use the
code-reviewskill to run the parallel agent review - Simple questions about code or quick checks → answer directly without agents
- All review agents use
model: "opus"and are read-only (no write access) - Intermediate results stored in
_workspace/directory - Re-reviews only re-run agents whose domain has new changes
Directory structure:
.claude/
├── agents/
│ ├── arch-reviewer.md
│ ├── security-reviewer.md
│ ├── perf-reviewer.md
│ ├── style-reviewer.md
│ └── refactor-planner.md
├── skills/
│ └── code-review/
│ ├── SKILL.md
│ └── references/
│ └── lava-domain.md
├── commands/
│ ├── fix-issue.md
│ ├── fix-pr.md
│ ├── deploy.md
│ └── context-prime.md
├── rules/
│ ├── api-conventions.md
│ ├── frontend.md
│ ├── code-style.md
│ ├── testing.md
│ └── git-workflow.md
└── hooks/
└── typecheck-on-edit.sh
Change log:
| Date | Change | Target | Reason |
|---|---|---|---|
| 2026-04-06 | Initial harness build | All agents + orchestrator | Parallel code review with domain-specific Lava rules |
| 2026-04-06 | Replaced code-reviewer + security-auditor | agents/ | Superseded by specialized 4-agent fan-out |
| 2026-04-06 | Removed /project:review command | commands/ | Superseded by code-review orchestrator skill |