# Position statuses and lifecycle

**In one sentence:** the lifecycle constructs answer "what is the state of
the duty now: created, active, performed, breached, or gone
altogether". The author takes them when a norm cares not only about the conclusion ("due")
but about its fate in time: the performance window, breach, waiver,
defeat of a norm conclusion.

A position moves through a fixed ladder — created, active, satisfied or violated —
and can be defeated, waived, suspended, or terminated; breach, compensation,
and sanction chain from the breach. Norm syntax lives on the [duty](/constructs/duty/),
[prohibition](/constructs/prohibition/), [power](/constructs/power/), and
[liberty](/constructs/liberty-immunity/) pages; only statuses and lifecycle live here.

## 1. When to take it and when not to

| Instead | Selection rule |
|---|---|
| `positions()` vs `truth()` | Asking about the norm's fate ("is the duty performed") — `positions()` with a status (`SATISFIED`, `VIOLATED`, …); asking about a world fact ("is the fee paid") — `truth()`. The same fee is visible to both queries but they answer differently: the fact is `TRUE_ONLY`, the position is `SATISFIED` |
| `VIOLATED` vs `UNDETERMINED` after the deadline | Breach of achievement requires a completeness ground: explicit non-performance, a completeness certificate, or a decision. The deadline passed with no ground — `UNDETERMINED`, not `VIOLATED`. A silent case is no proof of non-payment |
| Achievement `VIOLATED` vs maintenance `VIOLATED` | Achievement is breached by silence under completeness; maintenance — only by an accepted counterexample: a recorded breaching action. No counterexample — no breach, even after the window |
| `DEFEATED` vs `NEITHER` | Defeat means a position created by a rule whose every ground is defeated (an `unless` defeater): it is VISIBLE in `positions` with status `DEFEATED` but publishes nothing. `NEITHER` means no position at all. "No norm" and "norm withdrawn" are different answers |
| A subject-matter predicate (`obligation_terminated`) vs a std literal (`terminated`) | The lifecycle runs on std literals `urn:law:std#waived/suspended/terminated` over the position id: only they move the waiver/suspension/termination ladder. The corpus's own predicates (`obligation_terminated(o)`) do not move the ladder — they are world facts, not lifecycle acts |
| `expired` vs the lifecycle outcomes | The 0.2 duty ladder does not produce `expired`: after the window closes — `SATISFIED`, `VIOLATED`, `UNDETERMINED`, for a `BOTH` pair — `CONFLICTED` plus the waiver/suspension/termination statuses |

## 2. Minimal example

Package `examples/achievement-ladder/`: a member's fee with a window until end of
March, two "as of" moments.

```law
rule MembershipFee(p: Person) strict {
    label ru-KZ official "Участник платит взнос до конца марта";
    when is_member(p);
    then duty PayFee {
        bearer p;
        goal achievement {
            condition fee_paid(p);
            window [@2026-01-01, @2026-03-31];
        }
    };
}
```

Case 1: `is_member(p)` + `fee_paid(p)`, `decision_time` inside the window.
Query: `evaluate positions()`. Case 2: `is_member(p)` only,
`decision_time` after the window.

The engine's actual answer:

```text
law test research.lifecycle.ladder: мир research.lifecycle.ladder
  ok   [research.lifecycle.ladder#authored] tests/01-satisfied.lawtest / urn:query:research-lifecycle-01
  ok   [research.lifecycle.ladder#authored] tests/02-overdue.lawtest / urn:query:research-lifecycle-02
итого: 2 проверено, 2 прошли, 0 не прошли, 0 не исполнены; код 0
```

`law engine check` — `check OK`, no warnings. Sensitivity:
case 1 answers `position(PayFee, SATISFIED)` (accepted support confirms
the condition in the window); case 2 — `position(PayFee, UNDETERMINED)` (window
closed, no performance, no completeness ground — silence is not
a breach). Deleting the `fee_paid` fact changes the outcome from `SATISFIED` to
`UNDETERMINED`, not to `VIOLATED` — the nearest wrong outcome
a newcomer expects.

Second package `examples/defeat-and-violation/` — two ladder rungs missing
from the first:

| Facts | Question | Answer | Why |
|---|---|---|---|
| member + waiver | `positions(), PayFee` | `DEFEATED` | every ground defeated by an `unless` defeater; the position visible, no publications |
| facility running + recorded discharge | `positions(), KeepClean` | `VIOLATED` | an accepted counterexample in the maintenance window |

Second-package sensitivity: deleting `fee_exempt` revives the position
(the ground is defeated no longer — the status leaves `DEFEATED`);
deleting `discharge_detected` lifts the breach (no counterexample).

## 3. Example across domains

- **Law:** Uzbekistan Civil Code (package `uz.civil_code`) — termination of an obligation
  (`rule TerminationOnGround`, see `corpus-forms.md`): the same ladder, but
  with the subject-matter predicate `obligation_terminated(o)` — a known boundary.
- **Standard/protocol:** weekly rest of at least 42 hours —
  package `uz.labor_code` — Labour Code of Uzbekistan
  (`then weekly_rest_violated(...)`): the breach is derived by a rule from
  a measurement, not by the lifecycle engine; the std ladder needs
  a counterexample in a maintenance window.
- **Religion/ethics:** Uzbekistan family code (package `uz.family_code`) — maintenance minimum:
  breach computed by comparison (`amount * 10000 < mrot * 1175`), the same
  boundary: a subject-matter predicate, not a std status.
- **Science/teaching case:** `examples/defeat-and-violation/` — norm-conclusion
  defeat (`DEFEATED`) and maintenance breach (`VIOLATED`) in
  miniature; the 1922 Union Treaty question catalogue
  (package `su.union_treaty_1922`)
  shows the corpus form of a `positions()` query with `ACTIVE`.

## 4. How the engine answers

Table — actual runs of this directory's examples:

| Facts | Question | Answer | Why |
|---|---|---|---|
| member + fee paid, decision in window | `positions(), PayFee` | `SATISFIED` | support confirms the condition in the window |
| member without fee, decision after window | `positions(), PayFee` | `UNDETERMINED` | window closed, no completeness |
| member + waiver | `positions(), PayFee` | `DEFEATED` | ground defeated by `unless` |
| facility + recorded discharge | `positions(), KeepClean` | `VIOLATED` | maintenance counterexample |
| facility without discharge | `positions(), KeepClean` | `ACTIVE` | window open, no counterexample |
| contract, decision before the window | `positions(), PayFee` | `PENDING` | the deadline has not started yet (before the window an unperformed duty is pending) |

- In `positions` every position carries payload, `createdBy`, and proof-refs;
  the `normative_status` summary never destroys the original support:
  on conflict — `CONFLICTED` plus `normative_status_supports`.
- A defeated position is visible and addressable but takes no part in conclusions:
  `normative_status` over it is `DEFEATED`, not `NEITHER`.
- A breach is a derived institutional fact about the position instance
  (`violated(P)`), not a logical conflict: an opposite norm
  alone never gives a breach.
- Chains run as separate rule applications and proof nodes:
  primary breach → compensatory duty → sanction; a step through
  a power effect enters the next step's fixpoint.
- In `why_not` a position with `UNDETERMINED` is explained by missing support and
  completeness, not by "a breach left unproven".

## 5. Common mistakes

1. Reading an overdue deadline without completeness as `VIOLATED` — the engine answers
   `UNDETERMINED` (see `pitfalls.md`).
2. Own predicates (`obligation_terminated`, `minimum_violated`) instead of
   std literals — the waiver/suspension/termination ladder does not move; these are world facts, not
   cycle acts (see `pitfalls.md`).
3. Expecting `DEFEATED` as absence of a position — it is visible in `positions`
   but silent in conclusions (see `pitfalls.md`).
4. Deriving a breach from an opposite norm — a breach is not a conflict (see `pitfalls.md`).
5. Expecting `expired` on a duty — the 0.2 ladder never produces it
   (see `pitfalls.md`).
6. Taking the "as of" moment from `legal_time` — it is
   `decision_time` (different axes: law vs deadline; see `pitfalls.md`).

## 6. References

- The language specification defines position statuses, activation, achievement,
  maintenance, deadlines, waiver, suspension, termination, breach, compensation,
  sanction, and chains; this page states how to use them.
- Tutorials: `/tutorials/writing-tests/` (test observations).
- Details: `corpus-forms.md`, `pitfalls.md`, `boundaries.md`.