papeete-actor-message 0.1.0__tar.gz

papeete_actor_message-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,31 @@
+name: ci
+on: [push, pull_request]
+
+# NO CREDENTIAL. This pipeline reaches nothing outside its own checkout — both contracts are
+# committed source here, not something fetched from a private sibling.
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+      - name: the gate suite
+        # FIRST, because everything below it asserts that the package ARRIVED, and nothing below
+        # it asserts that the package is RIGHT.
+        run: uv run --extra dev pytest -q
+
+      - name: build
+        run: uv build
+      - name: the wheel must carry both contracts
+        # A wheel that installs cleanly and enforces nothing is the failure mode worth a gate.
+        run: |
+          uv venv /tmp/probe
+          uv pip install --python /tmp/probe/bin/python -q dist/*.whl
+          /tmp/probe/bin/papeete-actor-message contracts
+      - name: the gates must run
+        # The package validates its own worked example with its own contracts — the smallest
+        # end-to-end proof that both schemas shipped and both gates can read them.
+        run: |
+          /tmp/probe/bin/papeete-actor-message lint-data examples/waiter/actor-data.yaml
+          /tmp/probe/bin/papeete-actor-message lint-messages examples/waiter/actor-message.yaml

papeete_actor_message-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,30 @@
+name: release
+on:
+  push:
+    tags: ["v*"]
+
+# PyPI Trusted Publishing (OIDC) — no token is stored anywhere. The one-time setup is a pending
+# publisher on pypi.org naming this repo and this workflow; after the first release it becomes a
+# normal publisher. See README.
+permissions:
+  id-token: write
+  contents: read
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment: pypi
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+      - name: build
+        # No fetch step and no external token: both contracts are committed here. A release
+        # depends on nothing but this checkout and PyPI.
+        run: uv build
+      - name: verify the wheel carries both contracts
+        run: |
+          uv venv /tmp/probe
+          uv pip install --python /tmp/probe/bin/python -q dist/*.whl
+          /tmp/probe/bin/papeete-actor-message contracts
+      - name: publish to PyPI
+        run: uv publish --trusted-publishing always

papeete_actor_message-0.1.0/.gitignore

@@ -0,0 +1,6 @@
+__pycache__/
+*.pyc
+.pytest_cache/
+.venv/
+dist/
+*.egg-info/

papeete_actor_message-0.1.0/CLAUDE.md

@@ -0,0 +1,88 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## What this repo is
+
+`papeete-actor-message` ships two small, standalone contracts for the Papeete ecosystem:
+`papeete-actor-data/v0` (a per-actor dictionary of named, minimally-typed data items) and
+`papeete-actor-message/v0` (a per-actor catalog of named messages, each a pure regrouping of
+references into that dictionary, under an intent). It carries no wire protocol and no runtime —
+see `adr/ADR-PAM-0001-data-and-message-catalogs.md` for why, and for the reasoning behind every
+other non-obvious choice below.
+
+## Commands
+
+Dependency management and running are via `uv`.
+
+```bash
+uv run --extra dev pytest -q                                    # full test suite
+uv run --extra dev pytest -q tests/unit/test_messages.py         # one file
+uv run --extra dev pytest -q tests/unit/test_messages.py::test_lints_the_worked_example_clean  # one test
+
+uv build                                                          # build the wheel/sdist, no network needed
+uv run papeete-actor-message lint-data     examples/waiter/actor-data.yaml
+uv run papeete-actor-message lint-messages examples/waiter/actor-message.yaml
+uv run papeete-actor-message contracts
+```
+
+There is no linter/formatter configured in `pyproject.toml` — don't invent one.
+
+## Architecture
+
+Five small modules, each with one job:
+
+- **`data.py`** — the `papeete-actor-data/v0` gate. Loads `actor-data.yaml`, checks `items[]`
+  structurally (unique names, `type` in the closed vocabulary, `values:` present iff
+  `type: enum`, a non-empty `description`). A `data:` key naming an unrecognized version is
+  **UNMIGRATED**, reported as a warning, and not checked further — never treated as
+  non-conformant. Also exposes `names()`, the set of declared item names, used by `messages.py`.
+- **`messages.py`** — the `papeete-actor-message/v0` gate. Loads `actor-message.yaml`, checks
+  structure (`name`, `intent`, non-empty `references`), then resolves every `references` entry
+  against `data.names()` for the sibling `actor-data.yaml` (or an explicit `--data` path). **This
+  cross-file referential-integrity check is the one genuinely new mechanic this repo owns** — an
+  unresolved reference is an error; a missing data file is a warning, not a hard failure.
+- **`schemas.py`** — loads the two committed schema YAML files from
+  `src/papeete_actor_message/schemas/` as package data. **The package IS the contract** — no
+  fetch, no network call, in a source checkout or an installed wheel alike.
+- **`report.py`** — the shared `Report` dataclass (`oks`/`notes`/`warns`/`errors`) both gates
+  return. `errors` fail a run; `warns`/`notes` never do.
+- **`cli.py`** — argparse wiring for three subcommands: `lint-data`, `lint-messages` (with an
+  optional `--data` override), `contracts`.
+
+### The two contracts are deliberately separate files
+
+Splitting data definitions from message groupings is what makes "the same data item can be
+referenced by several messages within the same actor" a structural guarantee rather than a
+discipline someone maintains by hand — see ADR-PAM-0001 for the full rationale, including why a
+message may only *reference* a data item (never redefine, retype, or alias one) and why neither
+file carries a sync/async tag.
+
+### No dependency on `papeete-actor`
+
+This package never reads an actor's `name`/`description` — the coupling to "which actor" a pair
+of files belongs to is purely positional (same folder), not a Python import. `pyproject.toml`
+carries exactly one dependency, `pyyaml`.
+
+### The worked example lives at the repo root, not under tests/
+
+`examples/waiter/actor-data.yaml` and `examples/waiter/actor-message.yaml` are real files the
+README and both gate's tests point at directly (`tests/unit/test_data.py`,
+`tests/unit/test_messages.py`, `tests/unit/test_cli_contracts.py`) — not disposable fixtures.
+They reuse the `waiter` cast from `papeete-actor-synchronous-messaging`'s own worked example for
+continuity across the ecosystem's docs; there is no functional dependency between the two repos.
+
+## Relationship to other repos
+
+Nothing here is imported from or into `papeete-actor` or `papeete-actor-synchronous-messaging`.
+This repo's contracts are a content-modeling layer meant to sit *above* whichever wire protocol
+eventually carries a message (today: `simple-actor-protocol/v0`'s `request`/`ack`/`query`/
+`answer`, owned entirely by `papeete-actor-synchronous-messaging`) — mapping a message name to a
+verb is a downstream binding's job, not this repo's.
+
+## ADRs
+
+Design decisions live in `adr/` as one file per decision (`ADR-PAM-00NN-*.md`, `template.md` for
+the format). `adr/README.md` states the ownership line: decisions about either schema's shape or
+this repo's scope belong here; decisions about the wire protocol or actor identity belong
+upstream in the sibling repos' own logs.

papeete_actor_message-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Papeete Consulting
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

papeete_actor_message-0.1.0/PKG-INFO

@@ -0,0 +1,137 @@
+Metadata-Version: 2.5
+Name: papeete-actor-message
+Version: 0.1.0
+Summary: A per-actor data dictionary and message catalog contract for the Papeete ecosystem — papeete-actor-data/v0 and papeete-actor-message/v0.
+Author-email: Papeete Consulting <yoann.remy@outlook.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: actor-model,agents,contract,data,message,modeling
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.11
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# papeete-actor-message
+
+A per-actor data dictionary and message catalog for the [Papeete](https://github.com/papeete-hub)
+ecosystem: `papeete-actor-data/v0` and `papeete-actor-message/v0`.
+
+```
+papeete-actor-message lint-data     ACTOR-DATA.YAML                         papeete-actor-data/v0
+papeete-actor-message lint-messages ACTOR-MESSAGE.YAML [--data DATA.YAML]   papeete-actor-message/v0
+papeete-actor-message contracts                                            which contracts this build enforces
+```
+
+```bash
+pip install papeete-actor-message
+```
+
+## What it enforces
+
+An actor's data dictionary — `actor-data.yaml` — declares a flat list of named, minimally-typed
+items, and nothing else:
+
+| Field | Says |
+|---|---|
+| `data` | names this contract: `papeete-actor-data/v0` |
+| `items[].name` | the item's name, unique within this file |
+| `items[].type` | one of `string`, `integer`, `number`, `boolean`, `enum`, `list` |
+| `items[].values` | required when `type: enum`, disallowed otherwise |
+| `items[].description` | free prose — what this datum is |
+
+An actor's message catalog — `actor-message.yaml` — declares named messages that **reference**
+data items only, grouped under an intent:
+
+| Field | Says |
+|---|---|
+| `message` | names this contract: `papeete-actor-message/v0` |
+| `messages[].name` | the message's name, unique within this file |
+| `messages[].intent` | free prose — what this message is for |
+| `messages[].references` | a list of data-item names, resolved against the sibling `actor-data.yaml` |
+
+A reference that resolves nowhere in the actor's own `actor-data.yaml` fails `lint-messages` —
+the one referential-integrity rule this repo owns. The same data item may be referenced by any
+number of messages within the same actor; a message never redefines, retypes, or inlines a
+datum of its own.
+
+`data:` and `message:` each name their own contract version, the same role `manifest:` plays on
+`papeete-actor`'s `actor.yaml` — so each lineage can migrate (v0 → v1, warn-not-fail) on its own,
+and a file declaring some other value is read and warned as UNMIGRATED rather than failed.
+
+## Worked example
+
+```yaml
+# actor-data.yaml
+data: papeete-actor-data/v0
+items:
+  - name: table_number
+    type: integer
+    description: The table where the order was placed.
+  - name: dish
+    type: string
+    description: The name of the dish being ordered.
+  - name: order_id
+    type: string
+    description: The unique identifier assigned to a placed order.
+  - name: order_state
+    type: enum
+    values: [resolved, rejected, pending, unknown]
+    description: The current lifecycle state of an order.
+```
+
+```yaml
+# actor-message.yaml
+message: papeete-actor-message/v0
+messages:
+  - name: take-order
+    intent: Register what a customer wants to order, and where.
+    references: [table_number, dish]
+  - name: order-status
+    intent: Ask for and report the current state of a previously placed order.
+    references: [order_id, order_state]
+```
+
+See [`examples/waiter`](./examples/waiter) — the same cast `papeete-actor-synchronous-messaging`'s
+own worked example uses, for continuity across the ecosystem's docs, not a functional dependency.
+
+```bash
+papeete-actor-message lint-data     examples/waiter/actor-data.yaml
+papeete-actor-message lint-messages examples/waiter/actor-message.yaml
+```
+
+## What this repo deliberately does not do
+
+**It carries no wire protocol.** Whether `order-status` above ends up riding a synchronous
+`query`/`answer` exchange (today's only runnable case, owned by
+[`papeete-actor-synchronous-messaging`](https://github.com/papeete-hub/papeete-actor-synchronous-messaging))
+or a future asynchronous publication is a downstream binding's decision — never this catalog's.
+A message here is exactly a name, an intent, and a list of data references; nothing about how it
+is carried.
+
+**It ships no runtime.** No actor class, no engine, no mailbox. `v0` is the contract alone —
+schema files and the two lint gates that check them — the same sequencing `papeete-actor` itself
+followed (identity shipped alone, before anything ran it).
+
+**Data is scoped to one actor's own folder.** An external RDF/SHACL ontology governing data
+items across actors is out of scope for now — the door is not closed to it later, but nothing
+here anticipates its shape. See [ADR-PAM-0001](./adr/ADR-PAM-0001-data-and-message-catalogs.md)
+for the full reasoning behind every choice above.
+
+## The contract is in this repo
+
+[`src/papeete_actor_message/schemas/`](./src/papeete_actor_message/schemas/) — ordinary
+committed source. **The package IS the contract**, not a gate that goes looking for it, so a
+build needs no network and no credential for the schemas themselves.
+
+```bash
+uv build   # no network, no token, no fetch step for either contract
+```
+
+## Licence
+
+MIT.

papeete_actor_message-0.1.0/README.md

@@ -0,0 +1,119 @@
+# papeete-actor-message
+
+A per-actor data dictionary and message catalog for the [Papeete](https://github.com/papeete-hub)
+ecosystem: `papeete-actor-data/v0` and `papeete-actor-message/v0`.
+
+```
+papeete-actor-message lint-data     ACTOR-DATA.YAML                         papeete-actor-data/v0
+papeete-actor-message lint-messages ACTOR-MESSAGE.YAML [--data DATA.YAML]   papeete-actor-message/v0
+papeete-actor-message contracts                                            which contracts this build enforces
+```
+
+```bash
+pip install papeete-actor-message
+```
+
+## What it enforces
+
+An actor's data dictionary — `actor-data.yaml` — declares a flat list of named, minimally-typed
+items, and nothing else:
+
+| Field | Says |
+|---|---|
+| `data` | names this contract: `papeete-actor-data/v0` |
+| `items[].name` | the item's name, unique within this file |
+| `items[].type` | one of `string`, `integer`, `number`, `boolean`, `enum`, `list` |
+| `items[].values` | required when `type: enum`, disallowed otherwise |
+| `items[].description` | free prose — what this datum is |
+
+An actor's message catalog — `actor-message.yaml` — declares named messages that **reference**
+data items only, grouped under an intent:
+
+| Field | Says |
+|---|---|
+| `message` | names this contract: `papeete-actor-message/v0` |
+| `messages[].name` | the message's name, unique within this file |
+| `messages[].intent` | free prose — what this message is for |
+| `messages[].references` | a list of data-item names, resolved against the sibling `actor-data.yaml` |
+
+A reference that resolves nowhere in the actor's own `actor-data.yaml` fails `lint-messages` —
+the one referential-integrity rule this repo owns. The same data item may be referenced by any
+number of messages within the same actor; a message never redefines, retypes, or inlines a
+datum of its own.
+
+`data:` and `message:` each name their own contract version, the same role `manifest:` plays on
+`papeete-actor`'s `actor.yaml` — so each lineage can migrate (v0 → v1, warn-not-fail) on its own,
+and a file declaring some other value is read and warned as UNMIGRATED rather than failed.
+
+## Worked example
+
+```yaml
+# actor-data.yaml
+data: papeete-actor-data/v0
+items:
+  - name: table_number
+    type: integer
+    description: The table where the order was placed.
+  - name: dish
+    type: string
+    description: The name of the dish being ordered.
+  - name: order_id
+    type: string
+    description: The unique identifier assigned to a placed order.
+  - name: order_state
+    type: enum
+    values: [resolved, rejected, pending, unknown]
+    description: The current lifecycle state of an order.
+```
+
+```yaml
+# actor-message.yaml
+message: papeete-actor-message/v0
+messages:
+  - name: take-order
+    intent: Register what a customer wants to order, and where.
+    references: [table_number, dish]
+  - name: order-status
+    intent: Ask for and report the current state of a previously placed order.
+    references: [order_id, order_state]
+```
+
+See [`examples/waiter`](./examples/waiter) — the same cast `papeete-actor-synchronous-messaging`'s
+own worked example uses, for continuity across the ecosystem's docs, not a functional dependency.
+
+```bash
+papeete-actor-message lint-data     examples/waiter/actor-data.yaml
+papeete-actor-message lint-messages examples/waiter/actor-message.yaml
+```
+
+## What this repo deliberately does not do
+
+**It carries no wire protocol.** Whether `order-status` above ends up riding a synchronous
+`query`/`answer` exchange (today's only runnable case, owned by
+[`papeete-actor-synchronous-messaging`](https://github.com/papeete-hub/papeete-actor-synchronous-messaging))
+or a future asynchronous publication is a downstream binding's decision — never this catalog's.
+A message here is exactly a name, an intent, and a list of data references; nothing about how it
+is carried.
+
+**It ships no runtime.** No actor class, no engine, no mailbox. `v0` is the contract alone —
+schema files and the two lint gates that check them — the same sequencing `papeete-actor` itself
+followed (identity shipped alone, before anything ran it).
+
+**Data is scoped to one actor's own folder.** An external RDF/SHACL ontology governing data
+items across actors is out of scope for now — the door is not closed to it later, but nothing
+here anticipates its shape. See [ADR-PAM-0001](./adr/ADR-PAM-0001-data-and-message-catalogs.md)
+for the full reasoning behind every choice above.
+
+## The contract is in this repo
+
+[`src/papeete_actor_message/schemas/`](./src/papeete_actor_message/schemas/) — ordinary
+committed source. **The package IS the contract**, not a gate that goes looking for it, so a
+build needs no network and no credential for the schemas themselves.
+
+```bash
+uv build   # no network, no token, no fetch step for either contract
+```
+
+## Licence
+
+MIT.

papeete_actor_message-0.1.0/adr/ADR-PAM-0001-data-and-message-catalogs.md

@@ -0,0 +1,133 @@
+---
+id: ADR-PAM-0001
+title: "Two files, reference-only messages, and why this stays wire-agnostic and standalone"
+status: Accepted
+date: 2026-08-23
+supersedes: []
+references:
+  - ../src/papeete_actor_message/schemas/papeete-actor-data.schema.yaml
+  - ../src/papeete_actor_message/schemas/papeete-actor-message.schema.yaml
+  - ../src/papeete_actor_message/data.py
+  - ../src/papeete_actor_message/messages.py
+---
+
+# ADR-PAM-0001 — Two files, reference-only messages, and why this stays wire-agnostic and standalone
+
+## Context
+
+`papeete-actor-synchronous-messaging` already owns a wire protocol —
+`simple-actor-protocol/v0` — with an envelope and four payload kinds (`request`/`ack`/
+`query`/`answer`), each field tagged `judged:` or left deterministic. That repo's own README
+flags those four kinds as "candidates for a future `inter-agent-message/v0`" contract, and its
+`adr/README.md` is explicit that decisions about the protocol itself belong there, not here.
+
+What's missing across the ecosystem is a place to declare, per actor, **what data exists** and
+**how it groups into an intent** — independent of which verb eventually carries it, and
+independent of whether that verb is synchronous (an action or a query, today's only runnable
+case) or asynchronous (publications/subscriptions, deliberately excluded from the sync-messaging
+repo, but not from this one). This repo is that place.
+
+## Decision
+
+**Two files per actor, each a small, self-declaring contract:**
+
+`actor-data.yaml` — `papeete-actor-data/v0` — a dictionary of named, minimally-typed items:
+
+```yaml
+data: papeete-actor-data/v0
+items:
+  - name: order_id
+    type: string
+    description: The unique identifier assigned to a placed order.
+```
+
+`actor-message.yaml` — `papeete-actor-message/v0` — a catalog of named messages, each a pure
+regrouping of references into that dictionary:
+
+```yaml
+message: papeete-actor-message/v0
+messages:
+  - name: order-status
+    intent: Ask for and report the current state of a previously placed order.
+    references: [order_id, order_state]
+```
+
+**A message references data only.** No inline data, no per-reference metadata (no
+`required`/`optional` flag, no renaming or aliasing of a datum for one message's use). The same
+data item may be referenced by any number of messages within the same actor — that's the entire
+point of separating the two files.
+
+**Data typing is minimal but real: `string | integer | number | boolean | enum | list`, plus a
+`description`.** Not bare name-only placeholders (a datum should say what it is), and not an RDF/
+SHACL ontology (deliberately out of scope for this version — see below). `values:` is required
+exactly when `type: enum`, and disallowed otherwise.
+
+**A message carries no sync/async tag.** Whether `order-status` above ends up riding a `query`/
+`answer` pair, a future publication, or something else entirely is a downstream binding's
+decision (e.g. a card's `offers`), never this catalog's. This keeps the catalog useful to both
+messaging styles without hard-coding a guess about either's eventual shape.
+
+**Referential integrity is enforced across files, not within either schema alone.** A single
+YAML file's JSON Schema has nothing to compare a reference against; `messages.py` loads the
+sibling `actor-data.yaml` and resolves every name in `references` against it. An unresolved
+reference is an error (fails the run); a missing sibling data file is a warning (references are
+left unresolved, not silently assumed correct).
+
+**Filenames are singular, mirroring the repo's own name** — `actor-data.yaml` /
+`actor-message.yaml` — the same mechanical rule already in use elsewhere in the ecosystem
+(`papeete-actor` → `actor.yaml`, `papeete-actor-synchronous-messaging` →
+`actor-synchronous-messaging.yaml`: repo name minus the `papeete-` prefix, unpluralized).
+
+**No dependency on `papeete-actor`.** This package never needs an actor's `name`/`description` to
+validate its own two files or the references between them — the coupling to "which actor" is
+purely positional (both files live in the same folder), not a Python import. Unlike
+`papeete-actor-synchronous-messaging`'s `SimpleActor`, this repo ships no runtime actor class in
+v0.
+
+**Data is scoped to one actor's own folder, for now.** An external RDF/SHACL ontology governing
+data items across actors, or a shared vocabulary, is explicitly out of scope for `v0` — the door
+is left open, nothing here forecloses it, but nothing here anticipates its shape either.
+
+## Rationale
+
+**Why two files rather than one.** A single file mixing data definitions and message groupings
+would let the same datum drift into slightly different shapes each time a message redeclares it
+inline. Splitting them is what makes "the same data can be referenced several times by different
+messages" a structural guarantee rather than a discipline someone has to maintain by hand.
+
+**Why reference-only, with no per-reference metadata.** The instant a message can rename or
+retype a referenced datum for its own purposes, the dictionary stops being a single source of
+truth — a reader would have to check every message to know what a datum "really" is. Keeping
+`references` a flat list of names is the smallest contract that still lets a message mean
+something: *these facts, gathered under this intent.*
+
+**Why no sync/async tag here.** Baking a transport assumption into the catalog would recreate
+exactly the coupling `papeete-actor-synchronous-messaging` went out of its way to avoid between
+its protocol and its card contract. A message catalog that outlives any one binding is the
+reason this repo can serve both synchronous and (future) asynchronous messaging without a
+migration.
+
+**Why minimal-but-real typing, not bare placeholders and not RDF/SHACL.** A closed, tiny
+vocabulary is enough to catch real mistakes (an enum with no values, a duplicate name) without
+inventing a general type system this repo would then have to maintain. It also leaves room to
+grow it (`v0 → v1`, warn-not-fail, the same migration discipline `papeete-actor`'s `manifest:`
+key already established) rather than guessing ahead at a richness (RDF/SHACL) nobody has asked
+this repo to provide yet.
+
+**Why no dependency on `papeete-actor`.** Every check this repo performs is answerable from its
+own two files. Adding a dependency an actual gate never reads would be coupling for its own sake
+— the opposite of this ecosystem's demonstrated discipline of each package depending on exactly
+what it uses and nothing else.
+
+## Consequences
+
+- **A data/message catalog nobody consumes yet, on purpose.** Exactly like `papeete-actor`'s
+  manifest was consumable-but-unconsumed before any runtime read it, this repo ships the
+  contract alone in `v0`. A later repo or ADR is expected to wire a message name to a wire verb
+  (sync or async) — that wiring is deliberately not built here.
+- **`references` has no way to mark a reference optional or required for a given message.** If a
+  real need for that surfaces, it is a new, explicit field to design and version — not something
+  to retrofit silently into a flat string list.
+- **A missing `actor-data.yaml` degrades `lint-messages` to a warning, not a hard failure**, so a
+  message file can still be authored before its data file exists — but no reference is
+  considered resolved until both files are present together.

papeete_actor_message-0.1.0/adr/README.md

@@ -0,0 +1,20 @@
+# Decision log (`ADR-PAM-*`)
+
+Decisions owned by **this repo**: the shape of `papeete-actor-data/v0` and
+`papeete-actor-message/v0`, what a message is allowed to do with a data item, and this
+package's own boundary and scope.
+
+**What belongs here.** A change to either schema's fields; what a message is and is not allowed
+to declare; the referential-integrity rule between the two files; what stays deliberately out of
+scope (typing richness, an external ontology, wire-protocol/sync-async concerns) and why.
+
+**What does not.** Anything about the wire protocol itself — the envelope, verbs, or the
+judged/deterministic split belongs to `papeete-hub/papeete-actor-synchronous-messaging`'s own
+`ADR-PAS-*` log. Anything about actor identity belongs to `papeete-hub/papeete-actor`'s
+`ADR-PA-*` log. This repo consumes neither directly (see ADR-PAM-0001) and re-authors neither.
+
+## The log
+
+| ID | Title | Status |
+|----|-------|--------|
+| [ADR-PAM-0001](./ADR-PAM-0001-data-and-message-catalogs.md) | Two files, reference-only messages, and why this stays wire-agnostic and standalone | Accepted |

papeete_actor_message-0.1.0/adr/template.md

@@ -0,0 +1,18 @@
+---
+id: ADR-PAM-NNNN
+title: ""
+status: Proposed
+date: YYYY-MM-DD
+supersedes: []
+references: []
+---
+
+# ADR-PAM-NNNN — <title>
+
+## Context
+
+## Decision
+
+## Rationale
+
+## Consequences

papeete_actor_message-0.1.0/examples/waiter/actor-data.yaml

@@ -0,0 +1,19 @@
+data: papeete-actor-data/v0
+
+items:
+  - name: table_number
+    type: integer
+    description: The table where the order was placed.
+
+  - name: dish
+    type: string
+    description: The name of the dish being ordered.
+
+  - name: order_id
+    type: string
+    description: The unique identifier assigned to a placed order.
+
+  - name: order_state
+    type: enum
+    values: [resolved, rejected, pending, unknown]
+    description: The current lifecycle state of an order.

papeete_actor_message-0.1.0/examples/waiter/actor-message.yaml

@@ -0,0 +1,14 @@
+message: papeete-actor-message/v0
+
+messages:
+  - name: take-order
+    intent: Register what a customer wants to order, and where.
+    references:
+      - table_number
+      - dish
+
+  - name: order-status
+    intent: Ask for and report the current state of a previously placed order.
+    references:
+      - order_id
+      - order_state