# LDC-W4114 — Defeasible rule reads a position status it never sees

## What it means

A `defeasible`, `default` or `defeater` rule with an ordinary conclusion
reads the status of a normative position directly — `violated`,
`satisfied`, `active`, `created` or `undetermined` — in its body, its
scope or one of its `unless` conditions.

Position statuses are settled by the norm lifecycle, which runs after the
ranked rules of the package. The current release re-runs only strict
readers after that lifecycle, so this rule is evaluated before any status
exists and its conclusion stays unestablished, with no other signal. A rule
that creates a norm reads statuses at any strength and gets no warning;
neither do the position metadata readers `bearer_of` and `instance_of`, a
strict reader, or a local relation that happens to share a status name.

The warning disappears once the release your package selects declares that
ranked readers are supported. Until then, write the reader as `strict`, or
keep the status test in a strict rule that derives an ordinary fact for the
ranked rule to read. The warning never fails the check.

## Example

```law
language "law.core" version "0.2";
package demo.diagnostics version "0.1.0";
namespace "urn:law:demo:diagnostics";

entity Driver;
relation involved(d: Driver) kind empirical;
relation stopped(d: Driver) kind empirical;
relation breach(d: Driver) kind institutional;

rule MustStop(d: Driver) strict {
    when involved(d);
    then duty StopDuty { bearer d; maintain stopped(d) during [@2023-07-01, infinity); };
}

rule Breach(position: PositionInstance, d: Driver) defeasible {
    when violated(position); when instance_of(position, StopDuty); when bearer_of(position, d);
    then breach(d);
}
```

## Fix

```law
language "law.core" version "0.2";
package demo.diagnostics version "0.1.0";
namespace "urn:law:demo:diagnostics";

entity Driver;
relation involved(d: Driver) kind empirical;
relation stopped(d: Driver) kind empirical;
relation breach(d: Driver) kind institutional;

rule MustStop(d: Driver) strict {
    when involved(d);
    then duty StopDuty { bearer d; maintain stopped(d) during [@2023-07-01, infinity); };
}

rule Breach(position: PositionInstance, d: Driver) strict {
    when violated(position); when instance_of(position, StopDuty); when bearer_of(position, d);
    then breach(d);
}
```

## Engine message

The engine reports this in its own wording:

```text
example.law:16:10: warning LDC-W4114: rule Breach reads position status violated with defeasible strength and an ordinary conclusion; the selected release does not re-run that reader after the norm lifecycle, so it never sees the status (§143, §280.3)
```

## Related

- [Lifecycle statuses](/constructs/lifecycle-statuses/) — how positions become violated or satisfied.
- [Defeasible rules and exceptions](/constructs/rule-defeasible-unless/) — rule strength and `unless`.
- [Strict rules](/constructs/rule-strict/) — the reader form that sees statuses.