Skip to content

Latest commit

 

History

History
394 lines (329 loc) · 28.6 KB

CLAUDE.md

File metadata and controls

394 lines (329 loc) · 28.6 KB

Info — Lava Network Explorer

Blockchain explorer for Lava Network. Tracks providers, chains (specs), relay payments, staking, and supply on Lava Mainnet.

Quick Start

# 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:3000
pnpm typecheck    # type check all packages
pnpm test         # vitest

Architecture

┌─────────────────┐              ┌───────────────────────────────────────┐
│   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    │
                                 └───────────────────────────────────────┘

Data Source Rules

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

Caching

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)

Materialized View (Critical)

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.

Monorepo Layout

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)

API Endpoints — Complete Reference

Index (/index)

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

Providers (/providers)

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

Specs/Chains (/specs)

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

Supply (/supply)

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

Other (root-level)

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

Pagination Convention

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.

Frontend Patterns

Data Fetching

  • useApi<T>(url) — SWR wrapper with 5-min refresh, returns { data, isLoading, error }
  • useChainNames() — fetches /lava/specs and returns a getName(chainId) lookup
  • API base URL from NEXT_PUBLIC_API_URL

Key Components

  • ChainLink — chain ID with SVG icon + link to /chain/{specId}. showName prop renders full name on top, specId below in muted text
  • ProviderLink — provider address/moniker with Keybase avatar or letter placeholder
  • LavaAmount — formats ulava string to LAVA with locale number formatting
  • StatCard — metric card (label, value, optional icon)
  • SortableTable — TanStack Table wrapper with sorting + pagination
  • Chart — Recharts ComposedChart wrapper for time-series

Chain Icons

  • Convention-based: /chains/{specId}.svg with aliases in lib/chain-icons.ts for specIds that don't match filenames
  • Fallback: letter placeholder on onError
  • To add a new chain: drop {name}.svg in public/chains/, add alias to ALIASES map if specId differs

Tables

  • All tables use TanStack React Table with client-side sorting (getSortedRowModel())
  • Every column needs accessorFn for sorting to work
  • Columns with BigInt values need numeric accessors: accessorFn: (row) => Number(toBigInt(row.field))

Domain Knowledge

Lava Network Concepts

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

Token Math

  • All token amounts from chain are in ulava (1 LAVA = 1,000,000 ulava)
  • Always use BigInt — ulava values overflow JavaScript Number
  • 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

Chain Display Names

  • rpc/lava.ts has a CHAIN_DISPLAY_NAMES override 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

Provider Detail Data Flow

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.

Gotchas — Things That Have Burned Us

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

Environment Variables

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

Not Covered (external data sources needed)

  • Provider errors — requires Relays DB (lava_report_error table), not in the indexer
  • Optimizer metrics — Implemented. Reads from aggregated_consumer_optimizer_metrics in relays DB via RELAYS_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 — /validators returns empty data: [], only has staking pool info

Claude Configuration

See .claude/ for team-shared settings, commands, rules, agents, skills, and hooks:

Settings & Permissions

  • .claude/settings.json — team permissions + hooks (committed)
  • CLAUDE.local.md — personal overrides (gitignored)

Rules (auto-loaded context)

  • .claude/rules/api-conventions.md — auto-loads when editing apps/api/**
  • .claude/rules/frontend.md — auto-loads when editing apps/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)

Commands (slash commands)

  • /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

Hooks (automated checks)

  • PostToolUse (Write|Edit) — Runs pnpm typecheck on the affected package after every file edit. Catches TypeScript errors immediately instead of letting them compound.

Harness: Code Review

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-review skill 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