> For the complete documentation index, see [llms.txt](https://docs.lpp-minduniverse.org/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.lpp-minduniverse.org/lingua-pactum-protocol-lpp-documentation/5.-lpp-admission-kernel/5.12-execution-permit-minting.md).

# 5.12 Execution Permit Minting

An **Execution Permit** may be created only after successful admission.

The canonical relationship is:

```
ADMIT
        ↓
Permit Minting
        ↓
Execution Permit
```

No other Layer 0 decision creates the normal execution path.

#### Authority Dependency

The formal Authority Object relation is:

```
PermitMinted(π, E, AO, G)
⇒
AuthorityAdmissible(AO, E, G)
```

Therefore:

```
¬AuthorityAdmissible(AO, E, G)
⇒
¬PermitMinted(π, E, AO, G)
```

#### Permit Binding

A valid Permit remains traceable to:

* Authority Object,
* admitted Execution Intent,
* authorized scope,
* applicable policy state,
* validity period,
* and the admission decision that produced it.

A representative binding is:

```
π.authority_id
=
AO.authority_id
```

```
π.intent_hash
=
H(E)
```

```
π.scope_hash
=
H(AO.action_scope)
```

```
π.policy_hash
=
AO.policy_binding.policy_hash
```

#### Permit Expiry

The Permit cannot legitimately outlive its upstream authority.

```
π.expiry
≤
AO.validity_window.end
```

#### Permit Is Not Authority

The Permit is a constrained operational derivative.

It does not become an independent authority source.

If the upstream legitimacy state changes, the Permit cannot be interpreted as permanently preserving the earlier authority.

#### Layer 1 Constraints

An Execution Permit may carry constraints such as:

* tool restrictions,
* target restrictions,
* time limits,
* rate limits,
* required human approval,
* sandbox-only execution,
* read-only operation,
* network restrictions,
* write restrictions,
* production restrictions,
* evidence-capture requirements,
* retry ceilings,
* task budgets,
* or revocation callbacks.

The exact constraint model is implementation- and profile-specific.