# The honest gaps

> This section covers how a rule reports what it finds and how a method declares what it lacks.

Page: Architecture · Coverage
Canonical: https://banes-lab.com/software-architecture/coverage#the-honest-gaps

This section is stop 71 of 102 in the learning route. Previous: [03 - A cell that resists an invariant](https://banes-lab.com/software-architecture/coverage/a-cell-that-resists-an-invariant.md). Next: [01 - The principle architecture](https://banes-lab.com/software-architecture/glossary/the-principle-architecture.md). It builds on [02 - What can drift, seen through how it drifts](https://banes-lab.com/software-architecture/coverage/what-can-drift-seen-through-how-it-drifts.md), [03 - A cell that resists an invariant](https://banes-lab.com/software-architecture/coverage/a-cell-that-resists-an-invariant.md).

This section covers how a rule reports what it finds and how a method declares what it lacks. Every cell that earns a rule renders two ways from one entry, a detect half and a report half, as typed in [D1·b a rule entry](https://banes-lab.com/software-architecture/coverage#the-honest-gaps-panel-b). Every predicate the method calls for is either running in the tree or declared absent in the one document that binds the method to the tree, as shown in [D1·a running or absent](https://banes-lab.com/software-architecture/coverage#the-honest-gaps-panel-a). A method that cannot say which of its own predicates are missing has not measured itself, and a document that describes an upgrade the tree never made is the [schema drift](https://banes-lab.com/records/arch/schema-drift.md) described in [a system is a graph](https://banes-lab.com/software-architecture/model/a-system-is-a-graph.md).

### Detect, report, declare

Checks that only block teach nothing, and methods that only describe cannot say which of their own predicates exist. A check refuses a change with a message that names a rule id, the author works around the id, and the document that describes the method lists a predicate that has never run anywhere. A blocking message names a rule without its reason, so the same violation returns from the next author, and a document that only describes the ideal cannot be checked against the tree, so its gaps are found by failure rather than by reading.

For this reason a rule detects and reports from one entry, and a predicate the tree does not run is declared absent, never assumed. The report half is written beside the detect half rather than a blocking message alone, and an absence is named in the binding document rather than left to be assumed. In practice, each rule is authored as one entry with a detect half and a report half, discovered by shape and consumed whole by the gate. One document names every predicate the method calls for and states, for each, whether the tree runs it.

To check this, take any finding your gate prints and ask whether it names the invariant and the remediation. Then take the document that describes your method and ask, for each predicate it calls for, whether the tree runs it. A finding that names only a rule, or a predicate that cannot be located, is the gap. A declared gap is not a license. Naming a predicate as absent keeps the document honest and leaves the drift class unwatched, so an absent predicate is still a cell to decide, and the declaration only says that the decision has not been made yet.

### One entry, two halves

The detect half is the predicate that fires on the violating shape. The report half is the message that names the invariant and the remediation, so the failure teaches the convention rather than only blocking. [Auto-remediation](https://banes-lab.com/records/arch/auto-remediation.md) follows where the remediation has [one correct answer](https://banes-lab.com/disciplined-methodology/verify/one-correct-answer.md), and where it does not the report still carries the handle a reasoning agent needs.

Enforcement then follows the [registry pattern](https://banes-lab.com/records/arch/registry-pattern.md), with one entry per rule discovered by shape through [auto-discovery](https://banes-lab.com/records/arch/auto-discovery.md) and consumed by the gate, and the whole set failing the build on drift. Where a project already has a registry primitive for code, enforcement reuses it rather than inventing a second one.

### Declared absent, never assumed

The walk is also how the gaps are named. A predicate the method calls for and the tree does not have is declared absent, in the one document that binds the method to the tree, rather than assumed. The epistemic and structural predicates normally exist and run, deciding whether something is reachable, consumed, grounded, drifting or covered.

The conative ones are the usual gap, such as a computed worth over branches, a detector for a run that stops making progress, and a calibrated confidence rather than a threshold. The methodology page keeps its own list under the same title, [the honest gaps](https://banes-lab.com/disciplined-methodology/ship/the-honest-gaps.md), and the two lists are one declaration read from two sides.

D1·a running or absent

```mermaid
flowchart TB
called["A predicate the method calls for"]
exists{"Does the tree run it?"}
runs["Declared present · it runs in the chain"]
absent["Declared absent · named in the one document that binds method to tree"]
assumed["Assumed · the document describes an upgrade the tree never made"]
called --> exists
exists -- yes --> runs
exists -- no --> absent
exists -. neither written down .-> assumed
```

D1·b a rule entry

```typescript
export interface Rule<Shape> {
readonly cell: CellKey;
readonly detect: (tree: Tree) => readonly Shape[];
readonly report: (found: Shape) => { readonly invariant: string; readonly remediation: string };
}

export interface Declared {
readonly predicate: string;
readonly status: "runs" | "absent";
readonly because: string | null;
}
```

## Links to

- [Schema Drift](https://banes-lab.com/records/arch/schema-drift.md)
- [A system is a graph](https://banes-lab.com/software-architecture/model/a-system-is-a-graph.md)
- [Auto-Remediation](https://banes-lab.com/records/arch/auto-remediation.md)
- [One correct answer](https://banes-lab.com/disciplined-methodology/verify/one-correct-answer.md)
- [Registry Pattern](https://banes-lab.com/records/arch/registry-pattern.md)
- [Auto-Discovery](https://banes-lab.com/records/arch/auto-discovery.md)
- [The honest gaps](https://banes-lab.com/disciplined-methodology/ship/the-honest-gaps.md)

## Linked from

- [The drop-in](https://banes-lab.com/disciplined-methodology/start/onboarding.md)