pacta-contract 0.1.0

The isolated core contract for the Pacta task runtime.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

# Pacta

Pacta is a thin, elegant durable contract fabric and governed pattern framework
for Rust user-defined obligations.

It is designed for the narrow space between "I need durable execution" and "I
do not want a broker-shaped framework to own my application semantics." Pacta
keeps the durable lifecycle small, then lets users attach obligation semantics,
execution composition, registry persistence, and integrations as governed
patterns.

```text
(Signal) -> Pact -> Claim -> Execution -> Settlement
```

`Signal -> Pact` is user-provided ingress: you turn your own events into pacts.
Pacta ships the lifecycle from `Pact` onward, not an ingress API.

## Status (0.1.0)

0.1.0 is the thin lifecycle foundation, not a complete durable runtime. It ships:

- a curated **facade** (`pacta`) — the recommended single entrypoint you depend on;
- the lifecycle **contract** (`Registry`) and a sans-I/O lifecycle **kernel**;
- **lease/lapse** semantics with injected time (the core reads no ambient clock);
- execution **composition** vocabulary (`Executor`, `Middleware`, `Policy`);
- a mechanical **driver** that runs the kernel against a registry and executor;
- an in-memory **reference backend** (`pacta-memory`);
- a backend-agnostic **conformance** suite (`pacta-conformance`);
- **executable governance** enforcing the architecture.

Durable/persistent backends deliberately live **outside** this workspace and prove
themselves against the conformance suite. No ingress API, framework adapters, or
retry/backoff/timeout orchestration ship in 0.1.0 — see `CHANGELOG.md`.

## Why Pacta

Many queue runtimes become heavy when retries, backoff, routing, scheduling,
dead-letter policy, and backend behavior all collapse into one storage-shaped
center. Pacta takes the opposite path:

- `Registry` preserves lifecycle authority.
- `Executor` handles claimed pacts.
- `Middleware` and `Policy` describe Pacta-native execution composition.
- Adapters and backends remain outside the core contract.
- Tianheng governance rejects architecture drift.

The result is deliberately thin: enough structure to bite, not enough bulk to
own the user's domain.

## Domain Language

Pacta uses contract and arbitration terms as architecture, not branding:

- `Pact` - durable unit of obligation.
- `Docket` - grouping from which pacts are selected.
- `Clause` - business data carried by a pact.
- `Brief` - non-business operational context attached to a pact.
- `Claim` and `Retainer` - short-term processing authority.
- `Fulfill` and `Breach` - settlement outcomes.
- `Tribunal` - terminal review for exhausted pacts.

See `docs/domain-language.md` for the full glossary and legacy mapping.

## Architecture

Start with:

- `PROJECT.md` for vision, positioning, and non-goals.
- `docs/blueprint.md` for extension surfaces and non-commitment boundaries.
- `openspec/specs/` for shipped requirements.
- `BACKLOG.md` for deferred decisions and candidate patterns.

## Contributing

This project uses OpenSpec and Tianheng-native governance.

```bash
openspec new change "your-change-name"

cargo build --workspace
cargo test --workspace
cargo clippy --all-targets -- -D warnings
cargo fmt --all --check
cargo run -p pacta-governance -- check --manifest-path Cargo.toml
```

Read `AGENTS.md` before making repository changes.