Configure domains

Domains are named groups of source paths with their own coverage minimums. They work the same way for all sorts of languages — Python, TypeScript, Java, Rust, Go, and the rest. They are not language constructs and do not wrap packages, modules, or crates — they match directories and files in your repo so auth can require 90% while utilities stay at 60%.

Not Go cover, not a Go-package wrapper

coverctl is agent-loop coverage governance for all sorts of languages. It is separate from go tool cover / go test -cover (those remain the Go substrate when the project is Go). Domains are path patterns: most languages use globs such as src/api/**; Go projects may use ./internal/... because that is how Go tools name packages. Same product concept, two match dialects — vs native coverage commands.

Domain Configuration

Each domain has a name, match patterns, and a minimum coverage threshold:

Path globs (most languages)

policy:
  domains:
    - name: core
      match: ["src/core/**"]
      min: 85
    - name: api
      match: ["src/api/**"]
      min: 80

Go package paths

policy:
  domains:
    - name: core
      match: ["./internal/core/..."]
      min: 85
    - name: api
      match: ["./internal/api/..."]
      min: 80

Match Patterns

match accepts either dialect. coverctl picks the resolver from the pattern shape and the project’s language:

Dialect	When to use	Examples
Path globs	Python, JavaScript/TypeScript, Rust, Java, C#, and most non-Go trees	src/api/**, lib/**, app/services/**
Go package paths	Go modules (go.mod present)	./internal/auth/..., ./pkg/utils, ./cmd/...

Path globs

Pattern	Matches
src/core/**	Everything under src/core/
src/api/**	Everything under src/api/
lib/**	Everything under lib/
src/*/service/**	service trees one level under src/

Go package paths

Pattern	Matches
./internal/core/...	All packages under internal/core/
./cmd/...	All packages under cmd/
./pkg/utils	Only the pkg/utils package
./internal/*/service	service packages one level deep

Examples

TypeScript / Python / Rust

domains:
  - name: core
    match: ["src/core/**"]
    min: 85

  - name: api
    match:
      - "src/api/**"
      - "src/handlers/**"
    min: 80

  - name: utils
    match: ["src/utils/**"]
    min: 70

Go

domains:
  - name: core
    match: ["./internal/core/..."]
    min: 85

  - name: api
    match:
      - "./internal/api/..."
      - "./internal/handlers/..."
    min: 80

  - name: utils
    match:
      - "./pkg/utils"
      - "./pkg/helpers"
    min: 70

Language-specific starter configs (including language: and profile:) are in Quick start.

Excluding Files

Use the exclude field to skip files from coverage analysis:

exclude:
  - "**/generated/**"
  - "**/mocks/**"
  - "**/*_test.go"
  - "**/testdata/**"
  - "**/migrations/**"

Glob Patterns

Pattern	Matches
**/generated/**	Any file under a generated directory
**/*_mock.go	Any file ending in _mock.go
src/legacy/*	Files directly in src/legacy/

Auto-Detection

coverctl can automatically detect domains from your project structure:

# Preview detected domains
coverctl detect --dry-run

# Write config
coverctl detect

Detection follows the layout of the detected language, not a single package model:

Language family	Typical detected match shapes
Go	./internal/..., ./cmd/..., ./pkg/...
Python / JS / TS / Rust / …	src/**, src/api/**, lib/**, crate/layout-specific globs

Go layout heuristics (when go.mod is present)

Directory	Detected Domain
cmd/	CLI entry points
internal/core/	Core business logic
internal/domain/	Domain layer
internal/application/	Application services
internal/infrastructure/	Infrastructure adapters
internal/api/	API layer
pkg/	Public packages

Directories named generated, mocks, testdata, or vendor are automatically excluded. For other languages, run coverctl detect --dry-run to see the proposed globs for your tree.

Domain Overlap

When a file matches multiple domains, it’s assigned to the first matching domain. Order your domains from most specific to least specific:

Path globs

domains:
  - name: core-critical
    match: ["src/core/critical/**"]
    min: 95

  - name: core
    match: ["src/core/**"]
    min: 85

Go

domains:
  - name: core-critical
    match: ["./internal/core/critical/..."]
    min: 95

  - name: core
    match: ["./internal/core/..."]
    min: 85

Code Annotations

With annotations.enabled: true, you can override domain assignment in source comments (language comment syntax varies; Go shown):

// coverctl:domain=critical
package validator

func Validate() error {
    // This file belongs to "critical" domain
}

Ignoring Files

// coverctl:ignore
package generated

// This file is excluded from coverage

Best Practices

1. Start with auto-detection: Use coverctl detect --dry-run to see suggested domains for your language
2. Group by criticality: Higher thresholds for core business logic — names are labels, not package wrappers
3. Use meaningful names: Domain names appear in reports and agent tool output
4. Keep excludes minimal: Only exclude truly non-testable code
5. Review overlaps: Check for unintended domain assignments

See Also

PoliciesSet coverage thresholds

Quick startPer-language example configs

AdvancedAnnotations and more