# The Invention Commons Protocol Specification

**Agent-to-Agent-to-Physical — a protocol for moving intent into physical reality.**

Version 1.90.0-draft · 2026-09-24 · Editor: the Invention Commons Protocol project · License: CC0 1.0 (public domain)

This revision supersedes Version 1.89.0-draft while preserving its fail-closed
execution, evidence, and authority requirements.

---

## 0. Status and intent

This document specifies a wire format and a set of behaviours for systems that
turn an AI agent's need for a physical object into that object existing.

It is deliberately **separable from any implementation**. a2a2p.com is *a*
reference implementation; it is not the protocol. Anyone — including direct
competitors of a2a2p.com — may implement this specification, in whole or in
part, for any purpose, without permission or attribution. That is not
generosity; it is the design. A protocol that only one party can implement is
a vendor API, and vendor APIs do not become defaults.

The specification is released under **CC0 1.0** — no rights reserved. Reference
implementations may carry their own licences.

### 0.1 Reference qualification surface (non-normative)

The reference implementation exposes `qualify_specification_exchange_need` and
`POST /api/specification-exchange/qualify` for a fixed cohort of ten complete,
unaffiliated low-voltage outdoor sensor enclosure needs. Submission content is
private; public evidence is content-free. Incomplete requests and marked probes
do not consume a cohort slot. This surface grants no engineering, supplier,
payment, order, or fabrication authority. a2a2p's open tools are free for any
agent, with no account and no charge. There is no commission on orders or
suppliers. The only charge is the AI models' cost plus 20% for the run. A full
invention run in deb8 is shown at that price after the run.

The reference implementation at a2a2p.com is operated by **Physical Membrane
LLC** (Wyoming, USA; formed 2026-08-06). That is stated so callers can identify
the responsible principal behind it, as §5.5 asks of anything that eventually
fabricates. It confers nothing over this specification: the document is CC0,
and any implementation — including one competing with a2a2p.com — stands on
equal footing. Should this specification ever gain a governance body, that body
should not be a single company.

**Requirement levels.** MUST, MUST NOT, SHOULD, SHOULD NOT, and MAY are used as
defined in RFC 2119.

---

## 1. Why a protocol is needed

Agents can already reason about physical objects. They cannot cause them to
exist. The gap is not intelligence; it is the absence of a shared way to say
*what is needed* precisely enough for a machine on the other end to act.

Today that gap is bridged by humans: an engineer writes a drawing, emails a
shop, interprets a quote, negotiates a change. Every step is a translation
between incompatible private formats. The cost is measured in days per
iteration, and it is the dominant reason physical iteration is slow while
software iteration is instant.

This specification defines that shared way. Its goal is that the distance
between an agent knowing what is needed and the thing existing collapses toward
zero.

## 2. Scope

**In scope:** representing a physical requirement; assessing whether that
requirement is complete and physically sound enough to manufacture; obtaining
pricing and lead time; screening requests for harm; carrying a requirement
through to fulfilment.

**Out of scope:** CAD authoring, machine control, payment rails, shipping and
logistics formats, and supplier-internal operations. Implementations SHOULD
interoperate with existing standards in those areas rather than replacing them.

---

## 3. The two-layer model

The core idea of the Invention Commons Protocol is that a physical requirement has two layers, and that
**conflating them is the primary cause of failed manufacturing communication.**

| Layer | Question it answers | Owned by |
|---|---|---|
| **Intent** | *What must be true about the world?* | The requester |
| **Specification** | *What object satisfies that?* | The engineer, human or machine |

An agent that knows only "this shelf must hold 15 kg outdoors for ten years"
has complete **intent** and no **specification**. An agent handed a STEP file
has a specification and, often, no recorded intent — which is why substitution
decisions later in the supply chain go wrong: nobody downstream knows what the
part was *for*.

An implementation MUST accept a requirement with intent alone, and MUST NOT
require a specification in order to respond usefully. Deriving specification
from intent is the protocol's central act of value.

### 3.1 Entry modes

| Mode | Condition |
|---|---|
| `intent_only` | Intent present, specification absent |
| `fully_specified` | Specification present |
| `partial` | Some fields in both, neither complete |

### 3.2 Lifecycle

`intent` → `drafting` → `specified` → `quoting` → `resolved` → `ordered` → `closed`

An implementation MAY collapse states it does not use, but MUST NOT report a
state it has not reached.

---

## 4. Core objects

### 4.1 Requirement

```jsonc
{
  "intent": {
    "purpose": "string",              // REQUIRED. What the thing must accomplish.
    "environment": ["outdoor", "saltwater", "food_contact", "..."],
    "functional_requirements": {
      "max_load": 150,             // N by default; { "value": 150, "unit": "N" } also accepted
      "load_case": {
        "model": "cantilever_end_load", "load_n": 150, "span_mm": 200,
        "section": { "width_mm": 20, "height_mm": 10 },
        "max_deflection_mm": 2
      },
      "thermal_range": { "min": -20, "max": 85, "unit": "C" },
      "flexibility":   "rigid | semi_rigid | flexible",
      "electrical":    "string"
    },
    "geometric_envelope": { "max_x": 120, "max_y": 80, "max_z": 10, "unit": "mm" },
    "quantity": 10,
    "timeline": "string",
    "budget_envelope": { "max": 900, "type": "total | per_unit", "currency": "USD" },
    "priority": "cost | speed | strength | precision | aesthetics",
    "compliance": ["ISO 9001", "RoHS", "..."]
  },
  "specification": {
    "part_type": "bracket | housing | gear | ...",
    "material": "string",             // controlled vocabulary with open fallback
    "process": "cnc_milling | sheet_metal | fdm_3d_print | ...",
    "dimensions": {},
    "tolerance_class": "coarse | medium | fine | precision",
    "surface_finish": "string",
    "post_processing": ["anodizing", "..."],
    "design_files": [{ "url": "https://...", "format": "stl | step | dxf | pdf | ...", "role": "geometry | drawing | reference" }]
  },
  "rejected_alternatives": [
    { "field": "material", "value": "PLA", "reason": "Creeps above 50 C" }
  ]
}
```

**`intent.purpose` is the only universally required field.** It MUST be a
non-empty string containing at least one non-whitespace character. A published
JSON Schema for requirement intake MUST encode that same minimum (for example,
`minLength: 1` plus `pattern: "\\S"`) so a generated client does not have to
discover the rule by failing a live call. Everything else is optional at every
stage; an implementation MUST resolve or flag what is missing rather than
reject the request. An implementation MUST NOT infer or synthesize purpose from
part, material, process, filename, or any other surrounding field.

`rejected_alternatives` is normative and frequently omitted by implementers to
their cost: recording what was ruled out and why prevents downstream systems
from re-proposing it, and is the cheapest available form of institutional
memory.

### 4.2 Units

All lengths are millimetres, mass grams, force newtons, temperature Celsius,
and currency ISO 4217 (default USD) unless a `unit` field states otherwise.
Mesh formats that carry no units (notably STL) MUST be treated as millimetres
and the assumption MUST be stated in the response.

An implementation MAY create a unit-normalized derivative when reliable
evidence establishes that a unitless mesh exporter used another coordinate
unit. It MUST NOT infer that unit from the filename, a plausible size, or an
expected envelope alone. The conversion MUST bind the exact source bytes by a
content digest, name the source system and revision, preserve the source, write
the converted coordinates into a distinct derivative, and give that derivative
its own content digest. A sidecar label beside unchanged geometry is not a
conversion. The implementation MUST separately validate the derivative against
an expected finished envelope and explicit tolerance, and MUST fail visibly on
missing evidence, digest mismatch, unsupported representation, non-finite
coordinates, or dimension disagreement. The conversion grants no supplier,
quote, order, payment, engineering-approval, or fabrication authority.

### 4.3 Geometry provenance (normative where geometry is reported)

An implementation that reports geometry derived from an attached design file
**MUST** state how it obtained each figure, using at least these kinds:

- `measured_mesh` — the implementation computed it from mesh data it parsed.
- `declared_validation_property` — the originating CAD system computed it and
  wrote it into the file (in STEP, a geometric validation property); the
  implementation read and unit-converted it but did not compute it.
- `declared_envelope` — the requester stated it; nothing was read from a file.

The distinction matters because these fail differently. A measured mesh is
wrong when the mesh is not closed; a declared property is wrong when the
exporter wrote it for a different configuration. A caller deciding whether to
commit money needs to know which risk it is holding.

Further requirements:

- An implementation **MUST NOT** report a declared property as measured.
- Where a file declares units, an implementation **MUST** resolve them from the
  geometry's own representation context rather than by scanning for unit-like
  text. Where a file declares conflicting units and assigns none to a context,
  the implementation **MUST** report an assumption rather than choose one. A
  unit error is silent and enormous: reading inches as millimetres understates
  volume by 16,387x.
- An implementation **SHOULD** cross-check a declared solid volume against a
  measured bounding volume and **MUST NOT** report a solid volume that exceeds
  its own envelope.
- An implementation **MUST NOT** compose per-component declared properties into
  a single part or assembly figure unless it has resolved occurrence
  multiplicity. Reporting the set is correct; summing it on assumption is not.

### 4.4 Optional declared assembly

`specification.assembly` MAY declare the parts a requirement decomposes into and
the interfaces between them:

```jsonc
"assembly": {
  "parts": [
    { "name": "scoop", "material": "aluminum_6061", "process": "sheet_metal" },
    { "name": "bracket", "material": "steel_304", "process": "cnc_milling" }
  ],
  "interfaces": [
    { "between": ["scoop", "bracket"], "method": "bolted", "environment": "submerged" }
  ]
}
```

An implementation that accepts a declared assembly:

- **MUST NOT** price it as a single part. Each part is manufactured and quoted
  separately, and a single material and process cannot describe the set.
- **SHOULD** run cross-part checks that a single-part review cannot: material
  pairing at a joint, fit and tolerance across a mating interface, and any
  compatibility that depends on two parts rather than one. This is where the
  distinct value lies — a caller can decompose a concept perfectly well itself,
  and still not recall a materials-compatibility table correctly under time
  pressure.
- **MUST NOT** infer interfaces that were not declared. Which parts touch is a
  design fact the requester holds; guessing it produces confident findings about
  joints that do not exist. An implementation **MUST** state that undeclared
  interfaces are unchecked rather than implying whole-assembly coverage.
- **MUST** report which cross-part checks it ran and which it did not, and why.
  A short list of checks with stated omissions is more useful than a long list
  whose boundary is invisible.

Environment matters at the joint specifically: an interface MAY carry its own
`environment` where it differs from the assembly's. A galvanic couple needs an
electrolyte, so the same pair of metals is a defect in one place and unremarkable
in another. An interface SHOULD state its `method`, because whether a joint
constrains movement or accommodates it changes the consequence of every
mismatch across it.

A cross-part check that depends on an operating condition — a temperature range,
a load, a duty cycle — **MUST** run only against a condition the requester
declared, and **MUST NOT** substitute a plausible default. The same rule already
governs the structural checks in §4.5, and for the same reason: a criterion the
implementation invented produces a finding the requester never asked for and
cannot act on. Where a check reports a physical quantity it **MUST** state the
arithmetic, the property values used, their source, and what the result is not —
free differential expansion is not a joint stress, and presenting it as one
would require constraint data no declaration carries.

### 4.5 Optional structural load case

`intent.functional_requirements.load_case` MAY carry an explicit, idealized
beam case for deterministic early-stage checking. Its fixed-unit fields are
`load_n` (N), `span_mm` (mm), a rectangular `section.width_mm` and
`section.height_mm` (height is the bending direction), and optional
requester-supplied acceptance criteria. The initial model vocabulary is
`cantilever_end_load` and `simply_supported_center_load`. Implementations
MUST preserve an unsupported model and SHOULD report that it needs an external
solver rather than silently substituting a supported case.

For a solid rectangular section, an implementation MAY also report nominal
maximum transverse shear using `tau_max = 3*V_max/(2*b*h)`. For the two initial
models, `V_max = F` for the cantilever endpoint load and `V_max = F/2` for the
simply supported centered point load. This is the elementary straight-beam
shape factor published by the USDA Forest Service in
[`General Technical Report FPL-GTR-113`](https://research.fs.usda.gov/download/treesearch/5734.pdf).
The implementation MUST identify the reaction equation used for the selected
support condition and MUST NOT silently reuse the cantilever reaction for the
simply supported case.

An implementation that returns `derived.structural_sanity_check`:

- MUST identify the model, equations, fixed units, assumptions, and limitations;
- MUST identify whether elastic modulus came from requester data or a reference;
- MUST NOT treat a handbook-typical yield strength as a certified design
  allowable; strength acceptance or factor of safety may be evaluated only
  against requester-supplied allowable/yield data; and
- MUST NOT declare a pass or failure unless the requester supplied the relevant
  acceptance criterion;
- MUST evaluate `allowable_shear_stress_mpa`, when supplied, as an independent
  requester-asserted limit against the nominal rectangular-section transverse
  shear result. It MUST NOT infer this allowable from handbook strength data;
- MUST label every requester-supplied acceptance limit or material-strength
  basis used by a criterion as a requester assertion, and MUST state that the
  assertion was not independently verified. A pass or failure against those
  values is a conditional deterministic comparison, not evidence that the
  inputs are true, a design allowable is valid, or the design is certified;
- MUST report a criterion as `not_evaluated` when a required material property
  is not acceptance-eligible. It MAY report the numerical estimate and whether
  that estimate lies above or below the declared limit, but MUST label that
  comparison `reference_only` and MUST NOT turn it into a blocker; and
- MUST report an aggregate criterion result as `not_evaluated` when no requested
  criterion failed but at least one requested criterion remains unevaluated. A
  known failure MAY still make the aggregate `fail`; an unevaluated criterion
  MUST NOT be silently dropped to produce `pass`.

The result is a bounded sanity check, not a general solver or certified design.
An aggregate result MUST state that it is conditional on the declared inputs
and bounded model, and MUST explicitly deny engineering-validation and
design-certification authority. Neither a requester assertion nor a calculation
that consumes one becomes a verified physical fact merely because it is
machine-readable.
Maximum bending stress and maximum transverse shear occur at different section
locations and may occur at different positions along the beam. Reporting both
does not establish a combined-stress interaction result. The Euler–Bernoulli
deflection remains bending-only and does not include transverse-shear
deformation. Connections, holes, stress concentrations, combined-stress
interaction, buckling, fatigue, impact, vibration, creep, process anisotropy,
temperature effects, and regulatory factors remain outside this model.

### 4.6 Bounded rectangular section derivation

An implementation MAY expose `derive_rectangular_beam_section` to bridge one
small part of intent into candidate geometry. The operation derives only the
height of a prismatic rectangular section. The requester MUST supply a
substantive `purpose`, one model from §4.5, positive `load_n`, `span_mm`, fixed
`section_width_mm`, explicit `elastic_modulus_gpa`, positive
`manufacturing_increment_mm`, and at least one positive acceptance criterion:
`max_deflection_mm` or `allowable_stress_mpa`. An unused criterion MUST be
represented as `null`; an implementation MUST NOT invent it.

The closed-form derivation uses `I = b*h^3/12`, `S = b*h^2/6`, and the exact
deflection and moment equations named by the selected §4.5 model. For each
supplied criterion it solves the corresponding minimum height:

- deflection: `h_min = cbrt(12*F*L^3/(D*E*b*delta_limit))`, where `D` is 3 for
  `cantilever_end_load` and 48 for `simply_supported_center_load`;
- stress: `h_min = sqrt(6*C_M*F*L/(b*sigma_allowable))`, where `C_M` is 1 for
  `cantilever_end_load` and 1/4 for `simply_supported_center_load`.

Where both criteria are present, the greater continuous minimum governs. The
implementation MUST round that height upward—not to nearest—to the caller's
manufacturing increment, and MUST then pass the exact rounded load case through
the canonical §4.5 evaluator. It MUST fail closed rather than emit a candidate
if the rounded case does not conditionally pass every supplied criterion.

This operation is a bounded proposal generator, not a general geometry or
topology optimizer. It MUST preserve the requester-supplied purpose and screen
it before derivation. It MUST bind the exact input and candidate with canonical
content digests, while stating that digests prove content identity only. Its
receipt MUST:

- identify every solved equation, fixed unit, governing criterion, assumption,
  limitation, and upward-rounding increment;
- label acceptance limits and modulus as unverified requester assertions;
- explicitly deny material selection, manufacturing-feasibility validation,
  general or multi-objective optimality, physical validation, engineering
  approval, supplier handoff, purchasing, and fabrication authority; and
- state that shear, buckling, fatigue, impact, vibration, creep, temperature,
  connections, tolerances, process anisotropy, and stress concentrations remain
  unevaluated.

The MCP and REST bindings MUST expose the same exact input and receipt semantics.
A rejection MUST state whether any candidate, network call, supplier contact,
order, payment, or persistence occurred. This capability does none of them.

An implementation MAY expose
`validate_rectangular_beam_section_derivation` as a separate replay boundary.
It MUST accept the exact declared derivation input and a caller-held receipt,
recompute the derivation, and compare every canonical receipt field. It MUST
reject an undeclared field, changed candidate or digest, changed assumption or
claim limit, non-false external effect, or non-false authority value. Where a
screening receipt is carried, the implementation MUST validate its closed shape
and SHOULD compare it with screening recomputed from the declared purpose.

A successful replay validation establishes only deterministic content identity.
It MUST return a digest over the exact canonical derivation receipt while
stating that the digest proves neither authorship, requester assertions,
material applicability, engineering validity, physical truth, nor approval. It
MUST NOT make the candidate simulation-eligible or supplier-ready. A separate
compiler still needs explicit objectives, material applicability, omitted
failure-mode disposition, and a physical-validation plan before any simulation
study can consume the candidate. Validation performs no network, model, solver,
provider, supplier, persistence, order, payment, or fabrication action and
grants no corresponding authority.

#### 4.6.1 Finite width design-space comparison

An implementation MAY expose `explore_rectangular_beam_sections` to compare a
finite caller-declared set of rectangular widths without pretending to perform
general optimization. The input MUST carry the same purpose, model, load, span,
modulus, criteria, and manufacturing increment as §4.6, but MUST replace the
single fixed width with 2–12 unique positive `section_width_options_mm` values.
The implementation MUST NOT invent, interpolate, or silently remove a width.
Input order has no decision meaning; the implementation MUST normalize widths
into ascending numeric order before assigning stable candidate identifiers.

Each width MUST run through the exact canonical §4.6 derivation, including
upward manufacturing rounding and conditional re-verification. The result MUST
preserve the complete replayable derivation receipt and content digests for
every candidate. One candidate's failure MUST fail the complete operation;
partial success MUST NOT be represented as a complete design space.

The initial comparison has exactly two protocol-fixed dimensions:
`section_height` in millimetres and `idealized_prismatic_volume` in cubic
millimetres, both minimized. It MUST compute exact pairwise Pareto dominance: a
candidate dominates another only when it is no worse on both dimensions and
strictly better on at least one. It MUST expose every candidate's disposition
and all candidate identifiers that dominate it. It MUST NOT collapse the
dimensions into an opaque aggregate score.

The operation MUST return `selected_candidate_id: null` and MUST NOT recommend
or apply a candidate. Idealized volume is a transparent geometry quantity, not
a material-cost, manufacturing-cost, lifecycle-cost, environmental-impact, or
business-case estimate. The frontier applies only to the finite declared width
set and MUST NOT be described as a global or general optimum. Material state,
manufacturing feasibility, interfaces, tolerances, cost, omitted failure
modes, and physical validation remain separate evidence. The operation performs
no network, model, solver, supplier, provider, persistence, quote, order,
payment, or fabrication action and grants no corresponding authority.

#### 4.6.2 Finite design-space replay validation

An implementation MAY expose
`validate_rectangular_beam_section_design_space` as a separate replay boundary.
It MUST accept the exact declared §4.6.1 input and caller-held receipt, rerun
the complete finite design space, and compare every canonical field. This
includes every embedded §4.6 derivation, normalized width order, candidate
identifier and digest, exact pairwise Pareto disposition, aggregate
design-space digest, claim limit, external-effect value, and authority value.

The validator MUST reject an undeclared receipt field, any candidate or
comparison mutation, a changed aggregate digest, a non-false external effect,
or a non-false authority value. Where a screening receipt is carried, it MUST
validate the closed receipt and SHOULD compare it with screening recomputed
from the declared purpose. The validation input MUST be bounded and purpose
screened; a failed validation MUST NOT yield a partial replay or promote any
candidate.

A successful validation proves only deterministic replay and content identity.
It MUST NOT select a candidate, make the finite width set exhaustive, establish
requester assertions or material applicability, verify manufacturing
feasibility, promote a candidate into a simulation or supplier input, or grant
engineering, purchasing, fabrication, or physical authority. It performs no
model, network, solver, provider, supplier, persistence, quote, order, payment,
or fabrication action.

An implementation MAY expose `prepare_derived_beam_simulation` to compile a
replay-verified §4.6 proposal into the bounded simulation-study contract. The
compiler MUST preserve the derivation as its actual source kind; it MUST NOT
fabricate a domain-solutioning case, candidate-result digest, or other upstream
provenance merely to satisfy an existing study shape. A simulation-study schema
that accepts more than one candidate producer MUST use a closed, typed source
union whose members identify their own contracts, versions, and content
digests.

Before preparing a study, the compiler MUST replay the exact declared
derivation input and receipt, MUST require the exact successful replay-validation
receipt, and MUST reject any mismatch. It MUST independently require:

- source-bound material-property evidence whose property value matches the
  derivation modulus and whose grade, condition, product form, orientation,
  process, method, uncertainty, and freshness make it simulation-eligible;
- at least one explicit dimensional objective that the bounded adapter can
  produce; and
- a physical-validation plan for the same measured quantity and unit.

The compiler MUST derive a stable candidate identifier from the bound receipt
rather than accept a caller-selected identity, MUST repeat deterministic review
of the exact rounded section, and MUST preserve each supported requester
acceptance limit as an independent hard constraint. It MUST NOT infer a material,
objective, acceptance criterion, omitted failure mode, or validation plan.
The compiled simulation predicts nominal rectangular-section transverse shear,
but the §4.6 derivation did not size against a shear allowable and the compiler
MUST NOT imply otherwise. Connections, holes, combined-stress interaction,
transverse-shear deformation, buckling, fatigue, impact, vibration, creep,
temperature effects, tolerances, process anisotropy, and stress concentrations
remain explicitly unevaluated unless a later solver contract covers them.

Successful compilation establishes only that a deterministic proposal and its
declared inputs were replayed and packaged consistently for a bounded model. It
does not establish material identity or applicability, physical truth, general
optimality, engineering approval, supplier readiness, purchasing authority, or
fabrication authority. Compilation performs no model, external solver,
provider, supplier, persistence, order, payment, or fabrication action.

---

## 5. Capabilities

An implementation declares which capabilities it provides. Each is defined by
its response contract, not by transport.

### 5.1 `review_specification` — assess

Returns an engineering assessment of a requirement. Synchronous, side-effect
free.

```jsonc
{
  "quote_readiness": { "score": 0-100, "grade": "quote_ready | needs_detail | underspecified | blocked", "how_scored": "string" },
  "engineering_evaluation": {
    "contract": "a2a2p.engineering-evaluation", "version": "1.0.0",
    "status": "not_evaluated | partial", "checks_run": ["string"],
    "canonical_input_paths_present": ["RFC 6901 JSON Pointer"],
    "purpose_constraints_extracted": false,
    "finding_penalty_score": 0-100,
    "authority": {
      "engineering_validation": false, "design_certification": false,
      "physical_truth": false, "supplier_acceptance": false, "fabrication": false
    }
  },
  "findings": [ { "severity": "blocker | warning | info", "check": "string", "message": "string" } ],
  "completeness": { "score": 0-100, "missing": ["string"] },
  "clarification_plan": {
    "next_fields": [ { "path": "string", "question": "string", "why": "string", "example": "shape only" } ],
    "remaining_fields": [ /* known later inputs; never a hidden requirement */ ],
    "accelerators": [ /* optional inputs that tighten a supplier handoff */ ],
    "next_action": { "action": "apply_next_clarification | submit_for_specification_resolution | request_labeled_pricing" },
    "next_call": {
      "action": "string", "operation": "review_specification | submit_requirement | get_supply_options",
      "persistence": "stateless | create_request",
      "mcp": { "tool": "string" }, "rest": { "method": "POST", "path": "string" },
      "input": "same requirement plus known facts only"
    },
    "continuation_options": [
      { "purpose": "budgetary_pricing | supplier_handoff", "operation": "string",
        "persistence": "stateless", "external_action": false, "authorization": "none",
        "mcp": { "tool": "string" }, "rest": { "method": "POST", "path": "string" } }
    ],
    "after_intent_complete": { "action": "submit_for_specification_resolution", "derivation_targets": ["string"] },
    "delivery": { "optional": true, "path": "callback_url" }
  },
  "material_reference": {
    /* properties plus machine-readable provenance */
    "provenance": {
      "evidence_class": "string",
      "source_identifier": "string | null",
      "source_verified": false,
      "exact_material_state_verified": false,
      "design_allowable": false,
      "simulation_eligible": false,
      "permitted_use": "string"
    }
  },
  "derived": {
    "structural_sanity_check": { /* optional explicit-model result, equations, criteria, assumptions, and limitations */ }
  }
}
```

- Findings MUST be actionable: name what is wrong and what to do about it.
- `blocker` MUST mean the requirement cannot be manufactured as stated.
- An implementation MUST NOT return a `quote_ready` grade for a requirement
  containing a blocker.
- A requirement containing intent alone MAY be ready to submit for specification
  resolution, but it is not supplier-quote-ready until a material, process,
  functional dimensions, and tolerance have been derived or supplied. An
  implementation MUST NOT label intent completeness alone `quote_ready`.
- An implementation that returns `clarification_plan` SHOULD expose the compact
  next patch and every known follow-on requirement separately. It MUST distinguish
  optional delivery preferences and quote accelerators from physical requirements,
  and MUST NOT present example values as defaults or facts.

**Engineering-evaluation boundary (normative).** `intent.purpose` records why a
thing is needed. It is not a machine-readable load case, geometric envelope,
environment declaration, interface, material specification, or acceptance
criterion merely because those facts appear as prose inside it. An
implementation **MUST** preserve purpose prose, but **MUST NOT** claim that a
physical clause participated in an engineering check unless it either arrived
in a published canonical field or the implementation returns a machine-readable
extraction receipt identifying the exact clause, canonical target, units,
confidence, and verification state. Heuristic part classification or material
keyword matching is not such a receipt and **MUST NOT** by itself make an
engineering evaluation `partial` or complete.

An implementation that returns findings or readiness **MUST** return a versioned
engineering-evaluation receipt equivalent to
`a2a2p.engineering-evaluation@1.0.0`. It **MUST** identify the canonical input
paths present, the exact deterministic checks that ran, whether purpose clauses
were extracted, and false authority for engineering validation, design
certification, physical truth, supplier acceptance, and fabrication. Where no
deterministic engineering check ran, `status` **MUST** be `not_evaluated`,
`checks_run` **MUST** be empty, and an actionable finding **MUST** say which
canonical inputs would enable evaluation. A response with no findings is not
evidence that an engineering evaluation occurred.

A numerical score calculated only by subtracting finding severities **MUST** be
labeled a finding-penalty score, not engineering soundness, physical confidence,
or design quality. A score of 100 means only that no emitted finding reduced the
score; it **MUST NOT** imply that relevant loads, geometry, environments,
interfaces, failure modes, or acceptance criteria were evaluated. The receipt's
`status` and `checks_run` are authoritative for evaluation coverage; a readiness
score is not.

**Material-reference evidence boundary (normative where `material_reference` is
returned).** A material property without provenance is not engineering evidence.
Every returned material reference **MUST** carry machine-readable provenance that
states its evidence class, a resolvable source identifier or `null`, whether the
source was verified, whether the exact material grade/condition/product form was
verified, whether the value is a design allowable, whether it is eligible as a
simulation input, and its permitted use.

An uncited handbook compilation **MUST** identify itself as such, **MUST** use a
`null` source identifier, and **MUST** set `source_verified`,
`exact_material_state_verified`, `design_allowable`, and `simulation_eligible`
to `false`. An implementation **MUST NOT** silently promote such a value into a
design acceptance criterion, certified property, or source-bound simulation
input. In particular, a computed value that depends on the uncited property MAY
be returned as a reference-only estimate, but its acceptance criterion MUST use
`passed: null` (or an equivalent `not_evaluated` outcome), MUST NOT create an
acceptance blocker, and MUST NOT be omitted from an aggregate result in order to
produce `pass`. A requester-supplied scalar is still an assertion, not verified evidence,
unless a separate evidence object establishes a resolvable source, applicability
to the exact material state, and the required verification semantics. Content
identity or a digest alone does not establish the truth or applicability of a
material property.

**§5.1.1 Readiness stages (normative).** §3 makes deriving specification from
intent the protocol's central act of value. An implementation that does so
**MUST NOT** report its own derivation targets as inputs the requester has
failed to supply. Where a completeness report lists them — and it should, since
a supplier quote needs them — it **MUST** distinguish fields awaiting the
requester from fields the implementation will derive.

An implementation **SHOULD** report readiness per stage rather than as one
blended number, because the two answer different questions:

- **Resolution readiness** — has the requester supplied enough for the
  implementation to derive a specification? This is the only axis a requester
  can drive to completion by answering questions, and it is what a
  clarification loop should be measured against.
- **Quote readiness** — is this ready to put in front of a supplier? This stays
  bounded by the specification layer however complete the intent is.

Reaching full resolution readiness **MUST NOT** be reported as quote readiness
(§5.1). The failure this prevents is concrete: a single blended score capped by
un-derived fields tells an agent that answering every question it was asked
barely improved anything, which is indistinguishable from the protocol not
working.
- A `clarification_plan` SHOULD identify its immediate supported operation in
  `next_call`. When the implementation advertises a transport binding for that
  operation, it SHOULD include the binding's exact invocation details so a
  stateless caller need not rediscover them. A navigation hint is not
  authorization for any irreversible action.
- Where a complete specification has more than one valid non-authorizing next
  operation, the plan SHOULD publish them in `continuation_options`, with a
  purpose, exact binding, persistence, external-action status, and authorization
  status for each. It MUST NOT include an operation merely because that operation
  is discoverable; upload, polling, revision, durable resolution, and fulfilment
  have different preconditions. An implementation MUST refuse to construct a
  review continuation that contacts an external party or grants order,
  payment, or fabrication authority.
- Every continuation SHOULD state how its arguments are derived. A continuation
  that operates on the same requirement MUST direct the caller to reuse the
  original arguments, MUST preserve requester intent, and MUST name any paths
  that may be added. A caller MUST NOT reconstruct, rename, or summarize
  canonical fields between operations. This prevents a valid review from losing
  `intent.purpose`, design-file provenance, or dimensions at supplier handoff.

  A complete intent can also have a stateless design-brief alternative before
  specifications exist. The reference implementation labels that optional path
  `design_brief` and binds it to `prepare_domain_solutioning_case`. It prepares
  a portable case for the caller's design agent; it does not generate a design,
  run a model or create a durable request. The existing durable-resolution
  `next_call` remains available and unchanged. Incomplete intent still receives
  clarification questions first. This is an implementation example of the same
  non-authorizing continuation fields, not a new lifecycle or approval.

- During the 1.x compatibility window, `next_call` MAY repeat the recommended
  member of `continuation_options` for older callers. It is a compatibility
  alias, not a second definition: implementations MUST derive both from the
  same operation declaration, and their serialized values MUST be identical.

**§5.1.2 Intake classification (normative where the implementation derives specification).**
§3 lets a requester arrive with intent alone. Nothing in §3 guarantees that the
intent describes *one object*. "A device that detects debris on my pool floor
and removes it" is a legitimate intent and is not a part: it names a behaviour,
and the design decisions that would produce a part have not been made.

An implementation that derives specification from intent **MUST NOT** proceed as
though every requirement describes a single manufacturable part. Where it can
tell that a requirement describes a system or an undesigned capability, it
**SHOULD** say so and **SHOULD NOT** request part-level attributes — material,
process, tolerance, dimensions — that cannot be answered for it. Asking for a
tolerance class on something nobody has designed yet costs the caller a
clarification loop and ends at a supplier asking what it is being shown.

An implementation that classifies intake:

- **MUST** treat the classification as advisory. It MUST NOT reject, block, or
  down-grade a request on this basis, and MUST NOT let it affect screening.
- **MUST** state the basis of the classification, so a caller can disagree with
  it. A label without its evidence is not reviewable.
- **MUST** defer to a supplied specification. A requester who has named a
  process and a material has decided what object they want, whatever the prose
  sounds like.
- **SHOULD** name the honest next step — typically checking whether an existing
  product already satisfies the need, then decomposing into individually
  fabricable parts — and **SHOULD NOT** imply it can perform that decomposition
  unless it can. Choosing a mechanism is engineering judgement. An
  implementation whose deterministic review layer does not perform that
  judgement SHOULD provide a versioned handoff to a compatible system or state
  that the requester must supply it; it MUST NOT leave the ownership ambiguous.

**§5.1.3 Domain-solutioning interoperability (normative when offered).**
An implementation MAY expose a stateless case that lets an engineering-
intelligence system propose mechanisms, functional decomposition, and candidate
specifications from intent. This is a judgement boundary, not a physical-
authority boundary. A conforming case:

- **MUST** preserve the caller-supplied intent separately from every proposed
  specification and MUST bind the case to a deterministic digest;
- **MUST** identify deterministic evidence, cited source values, model
  proposals, assumptions, unknowns, supplier statements, and measured outcomes
  as distinct provenance classes;
- **MUST** apply the implementation's own intake screening before the handoff
  and MUST NOT let the intelligence system override that decision;
- **MUST NOT** include credentials, contact fields, callback routes, private
  design-file URLs, signed URLs, or design-file bytes unless the requester has
  explicitly authorized that separate disclosure;
- **MUST** require each candidate to state its mechanism, functional
  decomposition, specification patch, assumptions, unknowns, tradeoffs,
  evidence references, validation plan, and rejected alternatives;
- **MUST** bind returned candidates to the source case and the versioned domain
  framework and model provenance that produced them; and
- **MUST** state, as machine-checkable false authority, that preparing or
  returning a candidate does not mutate requirement facts, validate
  engineering, contact a supplier or provider, request a quote, create an
  order or payment, or authorize fabrication.

Every candidate specification **MUST** pass the implementation's screening and
deterministic engineering review before supplier use. An implementation whose
public operation only prepares the case **MUST** say that no collective or
model call occurred and MUST NOT present the artifact as a proposed solution.

An implementation that accepts a returned result **MUST**:

- require the exact case and result contract versions, recompute the source-case
  digest, and reject a result whose digest does not match;
- require a versioned domain framework and per-model provider, model, and role
  provenance;
- reject any attempt to promote physical authority, alter caller-owned intent,
  delete requirement facts, or add design-file references or bytes that were
  absent from the privacy-minimized case;
- apply each candidate only as a proposal-only patch to the specification,
  screen both the reconstructed requirement and the candidate's mechanism,
  decomposition, assumptions, tradeoffs, evidence, and validation narrative at
  the supplier-quote boundary, and run deterministic engineering review only
  after screening returns `allow`;
- state when design-file bytes were unavailable and therefore file-dependent
  geometry, format, and manufacturability checks were not repeated; and
- return the candidate as an unapplied proposal with no requirement mutation,
  supplier or provider contact, quote request, order, payment, or fabrication
  authority.

A digest establishes content integrity, not authorship or truth. It **MUST NOT**
be represented as authentication of the system that produced the case, proof
that a named model ran, or validation of any engineering claim. A screening
`review` or `deny` disposition **MUST** stop the candidate before deterministic
engineering review; it cannot be averaged away by a recommendation or panel
consensus.

The engineering claim units inside each candidate **MUST** be machine-checkable
rather than empty objects or untyped prose containers. At minimum, every
functional-decomposition item **MUST** name `function` and `part`; every
tradeoff **MUST** name `choice`, `benefit`, and `cost`; every evidence reference
**MUST** name `kind` and `path`; every validation step **MUST** name `test` and
`criterion`; and every rejected alternative **MUST** name `mechanism` and
`reason`. Every value named here **MUST** be a non-empty bounded string. Each
candidate **MUST** carry at least one evidence reference. Dissent **MUST** name
a candidate returned in the same result and a concern, and every
`recommendation.overturn_if` item **MUST** be a non-empty bounded string.
These requirements make claims comparable; they do not prove the cited fact,
establish that a test ran, or make a recommendation executable.

An external framework's score, rank, recommendation, or verdict is advisory
metadata. It **MUST NOT** authorize execution or override case integrity,
contract shape, provenance, false physical authority, candidate screening, or
deterministic engineering review. These gates **MUST** be evaluated as
independent all-required conditions: a failed or unresolved gate cannot be
offset by weighted score, model agreement, or a nominal `EXECUTE` verdict. An
`allow` screening result with no deterministic engineering-review result
**MUST** fail closed.

A validator offering this boundary **SHOULD** return a machine-readable
governance receipt that names its gate mode and required gates, states whether
external scores or verdicts were considered, identifies the failed gate on a
rejection, records whether screening stopped deterministic review for each
candidate, and states that execution remains unauthorized. The reference
receipt is `a2a2p.domain-solutioning-governance@0.1.0-draft` with gate mode
`all_required_fail_closed`.

Where a domain framework declares lifecycle activation stages for engineering
dimensions, those stages **MUST** define the minimum stages at which each
dimension is required, not a ceiling that forbids earlier relevant evidence.
An implementation **MUST** reject omission of an active hard gate, but **MUST
NOT** reject an evidence-backed early warning merely because its dimension is
mandatory only at a later stage. Such an early assessment **MUST** carry typed
evidence establishing why the dimension is relevant now; the evidence may
trigger the assessment without pretending to resolve it. An unsupported future
concern **MUST NOT** create a hard-gate blocker merely by being named. Any early
`unknown` or `blocked` hard gate retains the same next-action and fail-closed
semantics and grants no engineering or physical authority. This prevents a stage
label from suppressing an early wind-load, slip, condensation, durability, or
scale-transition risk without turning every conceivable later concern into an
unbounded checklist.

If a caller submits a malformed or non-prepared case, a validator **MUST NOT**
weaken the case shape or reconstruct an integrity-bound case from the rejected
payload. It **SHOULD** return a versioned, machine-readable caller recovery
plan that names the exact preparation and validation operations, identifies
the caller-held original requirement as the input source, requires the exact
prepared output to be passed unchanged, and binds any returned result to that
case's digest. The workflow **MUST NOT** infer or mutate requester facts, retry
automatically, add a parallel endpoint, call a model/provider/supplier, store
the payload, or grant quote, order, payment, or fabrication authority. The plan
is guidance for caller-orchestrated local protocol steps; it is not a claim that
the validator performed recovery. The plan is derived at response time and is
not persisted. Its exact-case and digest references mean either an exact prior
preparation output still held by the caller or the future output of the named
prerequisite; the rejected payload is never their source. If the caller no
longer holds the exact prepared case, it must prepare a new one from
the caller-held original requirement and obtain a result bound to the new
digest. The reference recovery-plan contract is
`a2a2p.domain-solutioning-recovery@1.0.0`.

The reference contract is `a2a2p.domain-solutioning@0.3.0-draft`; its JSON
Schema is published at `/schema/domain-solutioning`. The reference result
validator is `a2a2p.domain-solutioning-result-validation@0.5.0-draft`, exposed
as MCP `validate_domain_solutioning_result` and REST
`POST /api/domain-solutioning/validate`. It is stateless and makes no model or
external call.

When validation succeeds, the validator **MUST** content-address the exact
returned candidate result after shape and authority checks. Canonical JSON
object-key ordering **MUST** make the digest invariant to object insertion
order; array ordering remains part of the exact content and **MUST NOT** be
silently sorted. Changing a candidate mechanism, claim, evidence reference,
recommendation, dissent item, or provenance value **MUST** change the digest.
The digest establishes content integrity only: it does not prove authorship,
model execution, engineering truth, safety, or approval.

An implementation that also offers §5.1.4 **MUST** return a copy-ready source
binding containing the exact case digest, candidate-result digest, and validated
candidate IDs. The binding **MUST** name the next preparation operation and
**MUST** state that every objective, hard constraint, experiment, physical
input, unit, source, solver setting, validity condition, assumption, and
physical-validation plan remains caller-supplied. Producing the binding **MUST
NOT** run a solver or model, persist a study, select or apply a candidate, or
grant engineering, safety, ordering, payment, or fabrication authority. A
rejected result **MUST NOT** receive this handoff.

**Canonical interoperability profile.** An implementation offering this
boundary SHOULD publish at least one complete case/result/validation vector so
an independent engineering-intelligence system can integrate without inventing
its first payload or reading implementation source. The profile SHOULD also
publish negative vectors for source-case mutation, authority promotion,
invented design evidence, and screened narrative outside the specification
patch. Each vector MUST state what it proves and what it does not prove, MUST
identify a non-model fixture as such, and MUST be safe to execute without
storage or any model, supplier, provider, quote, order, payment, or fabrication
action. The reference profile is CC0 at
`/profile/domain-solutioning`.

**§5.1.3.1 Actualization Plan projection (normative when offered).**
An implementation MAY project one validated §5.1.3 candidate into a portable
plan of physical work. The projection MUST bind the exact case digest,
candidate-result digest, candidate identifier, and result-validation contract.
It MUST NOT copy the upstream candidate into a second generic node ontology.

The plan MUST name its actual entities: decisions, bought components, fabricated
parts, assemblies, interfaces, verification steps, and supplier handoffs.
Dependencies MUST be caller-supplied typed foreign keys whose field name defines
their meaning. An implementation MUST NOT infer an interface, assembly member,
verification dependency, or supplier-handoff dependency merely to complete a
graph. Evidence MUST remain a typed reference to the canonical domain-scaffold
evidence vocabulary; it MUST NOT become a generic plan entity or acquire a
second evidence-state vocabulary.

Publishing or validating a plan MUST NOT select or apply a candidate, mutate a
requirement, validate engineering, persist the plan, call a model or provider,
contact a supplier, request a quote, create an order or payment, or authorize
fabrication. A rejection SHOULD carry a stable reason and exact caller-owned
repair. The service MUST NOT silently edit the caller's plan. The reference
contract is `a2a2p.actualization-plan@0.1.0-draft`; its schema and CC0 profile
are published at `/schema/actualization-plan` and `/profile/actualization-plan`.

A successful validation SHOULD return an evidence-linkage projection bound to
the exact plan digest. Each linkage MUST preserve the canonical evidence kind,
locator, optional source digest, and the plan subjects that reference it. It
MUST NOT promote evidence to a graph node or claim that an unverified source is
verified merely because the linkage is content-addressed.

An implementation MAY accept a caller-held correction history with a later
validation attempt. If offered, every rejection MUST append rather than rewrite
one entry containing the stable reason, exact repair, rejected-plan digest, and
previous-entry digest. It MUST verify the complete supplied chain before
appending; a changed, internally missing, reordered, or malformed supplied entry
MUST fail closed as `correction_history_invalid` and MUST NOT extend the chain.
Because a caller-held hash chain cannot reveal removal of a suffix without an
independently retained checkpoint, an implementation MUST disclose that limit
and MUST NOT claim authorship or completeness from the chain alone. The service MUST
NOT retain the history, infer a repair, edit a plan, or retry automatically.
Callers remain responsible for retaining and resubmitting the complete history.
The reference recovery contract is
`a2a2p.actualization-plan-recovery@0.1.0-draft`.

A successful validation MAY return an execution projection for fabricated
parts. Each executable item MUST bind the exact plan digest, MUST state the
source path for every projected input, and MUST copy rather than infer those
inputs. The reference projection uses the caller-authored
`fabricated_parts[].function` as that part's `intent.purpose` and the exact
`fabricated_parts[].specification_patch` as its `specification`. It MUST NOT
inherit or synthesize a part purpose from broader system prose.

An item with a blocked required decision or a non-empty part `unknowns` list
MUST return no executable call. An unblocked item MAY return a complete
`review_specification` call over the projected arguments. Returning that call
does not execute it, perform engineering review, create a supplier package,
contact a supplier, request a quote, create an order or payment, begin
fabrication, or grant authority. The reference execution projection is
`a2a2p.actualization-plan-execution-projection@0.1.0-draft`.

**§5.1.4 Simulation-study interoperability (normative when offered).**
A domain-solutioning candidate is a proposed mechanism, not a simulation model
and not a verified design. An implementation MAY expose a side-effect-free
simulation-study boundary that references candidate IDs from §5.1.3 without
redefining the candidates themselves. The boundary exists to make a solver's
inputs, failures, predictions, and candidate tradeoffs inspectable before any
prototype or fabrication decision.

This section is the canonical owner of simulation-scope objectives, hard
constraints, evidence classes, experiments, and dispositions. §5.1.3 remains
the canonical owner of candidate identity and requester intent. If a later
domain-solutioning revision absorbs a simulation-scope concept, it **MUST**
reference this contract's canonical ID and publish an explicit deprecation or
deferral; the same field **MUST NOT** acquire two independent definitions.

Field provenance is explicit in this revision:

| Entity | Declared at write time | Derived at validation/read time |
|---|---|---|
| Study definition | source bindings, candidate IDs, objectives, constraints, experiments, provenance, assumptions, validation plan | none |
| Prepared study | the normalized definition | settings digests, study digest, planned state, false authority |
| Experiment result | solver identity, state or failure reason, evidence, objective and constraint observations | none |
| Validated comparison | none | digest verification, constraint eligibility, Pareto dispositions, stable serialization, false authority and evidence semantics |

Candidate IDs are opaque identities owned by §5.1.3. Preparation and validation
**MUST** preserve their exact bytes; changing an ID creates a different candidate,
not a migration or alias.

A conforming prepared study:

- **MUST** bind the exact §5.1.3 contract version, source-case digest, and
  candidate-result digest, and **MUST NOT** introduce a candidate ID absent
  from that result;
- **MUST** name each objective by the exact physical or economic quantity,
  unit, direction, and requester priority. A proxy objective **MUST** identify
  the canonical ID of the real requirement it stands in for, the validity
  domain where the proxy is meaningful, and the documented regime where it
  diverges; a boolean `is_proxy` alone is insufficient;
- **MUST** represent hard safety and engineering constraints separately from
  optimization objectives. A hard constraint is an eligibility gate and
  **MUST NOT** be converted into a penalty that a better score elsewhere can
  offset;
- **MUST** identify every physical property, constraint, and boundary condition
  through one typed, versioned source snapshot carrying a SHA-256 content digest
  and a bounded staleness interval. The only source kinds in this revision are
  `plm_record`, `materials_database`, `cited_reference`, and
  `requester_declaration`; an unknown kind fails closed rather than becoming an
  implied canonical source. A snapshot at or beyond its `refresh_after` instant
  is expired and **MUST** fail validation until refreshed and re-digested;
- **MUST** record solver adapter and model IDs and versions, inputs, boundary
  conditions, discretization or mesh settings, random seed where relevant,
  validity domain, assumptions, and a content digest over the settings; and
- **MUST** declare whether the model is deterministic or non-deterministic. A
  non-deterministic model without a recorded integer seed is invalid; a
  deterministic model **MUST** use a null seed so hidden randomness is not
  implied. Declared determinism is versioned provenance, not proof of
  reproducibility; absent adapter-specific repeat-run evidence, an implementation
  **MUST** report that declaration as unverified; and
- **MUST** carry a bounded physical-validation plan that could confirm or
  invalidate the simulated prediction. The existence of the plan is not
  evidence that the test ran.

An implementation validating returned experiment results:

- **MUST** distinguish `requester_fact`, `cited_reference`,
  `deterministic_calculation`, `simulated_prediction`, `supplier_statement`,
  and `physical_measurement` as separate evidence classes;
- **MUST** treat timeout, non-convergence, solver-boundary violation, missing
  units, missing provenance, unsupported model, and solver error as explicit
  invalid states. It **MUST NOT** map any of them to zero, a low score, or a
  default value while leaving the candidate eligible;
- **MUST** verify the exact candidate, experiment, solver, model, and settings
  identities against the prepared study, and **MUST** reject missing or extra
  objective and hard-constraint observations;
- **MUST** recompute hard-constraint pass or failure from the declared operator,
  threshold, unit, and observed value rather than trust a returned pass label;
- **MUST** preserve each objective dimension in the disposition record and
  **MUST NOT** accept an opaque aggregate fitness as the evidence for choosing
  a candidate; and
- where it reports a non-dominated set, **MUST** produce the same dispositions
  under every permutation of candidate and result order. Equal vectors remain
  non-dominated unless a separately declared tie rule says otherwise; arrival
  order is never a tie rule. Serialized dispositions SHOULD sort by stable
  candidate ID so equivalent runs are byte-comparable.

A completed simulation remains a prediction, not physical measurement,
engineering validation, safety approval, candidate selection, supplier contact,
quote authority, order, payment, or fabrication authority. Preparing or
validating a study **MUST** make each of those authority values machine-checkable
and false. A simulation-study implementation **MUST NOT** call a solver merely
because it validates a returned result; execution is a separate adapter concern.
Every independently consumable objective, constraint, experiment, evidence item,
candidate disposition, comparison, and evidence-semantics object **MUST** carry
its own false advisory-authority marker so partial deserialization cannot strip
the boundary and promote a prediction into physical truth.

**Bounded reference adapter.** An implementation MAY execute a prepared study
through a named, versioned local adapter as a separate operation. The adapter
MUST fail an affected experiment closed when its model, unit, input, boundary
condition, discretization, or requested output is outside the adapter's
published vocabulary; it MUST NOT substitute a nearby model or infer a missing
physical value. Adapter execution MUST produce the same experiment-result shape
accepted by the independent validator, and the returned result MUST pass that
validator before an implementation presents a comparison.

The reference adapter `a2a2p.bounded-beam@1.1.0` implements only the two
rectangular Euler–Bernoulli cases in §4.5. It requires explicit positive `load`
(N), `span` (mm), `section_width` (mm), `section_height` (mm), and
`elastic_modulus` (GPa); exact zero-valued support translation/rotation boundary
conditions; and `closed_form` rectangular-section settings with height declared
as the bending axis. Its output vocabulary is `maximum_deflection` (mm),
`nominal_bending_stress` (MPa), `nominal_transverse_shear_stress` (MPa), and
`idealized_prismatic_volume` (cm3). The last quantity is the volume of the declared rectangular idealization, not a
measured or CAD-derived part volume. The adapter does not infer a material
property, load, geometry, support condition, strength allowable, or
acceptance threshold. It is a deterministic early-stage prediction, not FEA,
physical measurement, engineering validation, or design certification.

**Reviewed-load-case compilation.** An implementation MAY offer a convenience
operation that compiles an already-reviewed load case into this study contract.
That operation **MUST** preserve the same evidence boundary as direct study
preparation. In particular, it:

- **MUST** accept one caller-selected candidate ID already present in the exact
  content-addressed §5.1.3 result; it **MUST NOT** select a candidate or imply
  that naming one is evidence it is best;
- **MUST** repeat deterministic review and screening before compilation;
- **MUST NOT** borrow a handbook-typical elastic modulus or infer a load,
  geometry, objective, source-freshness interval, or physical-validation plan;
- **MUST** convert every requester deflection, bending-stress allowable, or
  transverse-shear allowable supported by the adapter into a separate hard
  constraint; and
- **MUST** fail closed rather than discard an acceptance criterion, objective,
  model, or unit the bounded adapter cannot represent.

The reference compiler is
`a2a2p.reviewed-beam-simulation-bridge@0.4.0-draft`, exposed as MCP
`prepare_reviewed_beam_simulation` and REST
`POST /api/simulation-study/from-reviewed-beam`. It prepares but does not run a
study. Its source digest establishes content integrity for the exact requester
purpose and load-case snapshot, not authorship, accuracy, candidate fidelity,
engineering validation, or approval.

**Material-property evidence.** A compiler MAY accept a content-bearing source
snapshot that supports an explicit property already present in the load case.
If it does, the evidence envelope:

- **MUST** state the property quantity, value, and unit; material name, grade,
  condition, and product form; applicable temperature, orientation, and
  manufacturing process; evidence class, method, and uncertainty; and source
  kind, identifier, version, freshness interval, and exact source excerpt;
- **MUST** content-address the exact source snapshot and complete evidence
  envelope, and **MUST NOT** echo the source excerpt in its normalized receipt;
- **MUST** require exact agreement between the evidence value and the explicit
  load-case value. A compiler **MUST NOT** choose between conflicting values;
- **MUST** preserve `engineering_datasheet`, `experimental_measurement`, and
  `computed_crystal` as distinct evidence classes and **MUST NOT** relabel a
  materials-database calculation as experimental or datasheet evidence; and
- **MUST** state separately whether it retrieved the source, verified the
  source claim, verified the material identity, independently established the
  uncertainty, or established a design allowable. A digest proves content
  identity only; absent separate evidence, every one of those claims is false.

The scalar bounded-beam adapter in this revision **MUST NOT** use
`computed_crystal` evidence as an engineering-product modulus. A first-principles
elastic tensor for an inorganic crystal does not by itself establish an alloy
grade, temper, product form, manufacturing state, temperature-dependent value,
or the scalar orientation required by this model. It MAY be preserved for
screening or reference. Engineering-datasheet or experimental evidence is
eligible only for preliminary scalar linear-elastic simulation when grade,
condition, product form, temperature, orientation, and process are explicit;
eligibility is not source verification, a design allowable, engineering
validation, or physical truth.

**Source observations.** An implementation MAY publish an immutable observation
of what a primary source reports before that source is eligible to drive a
simulation. Such an observation **MUST** separate, field by field:

- source-document identity and exact-byte integrity;
- transcription of the reported claim;
- independent reproduction of that claim;
- applicability to the declared grade, condition, product form, orientation,
  temperature, and manufacturing process;
- identity of the requester's actual material lot;
- design-allowable, engineering-validation, design-certification, and physical-
  truth authority; and
- candidate-selection, supplier-contact, order, payment, and fabrication
  authority.

A single `verified` boolean **MUST NOT** stand for more than one of those claims.
Verifying a document digest or page transcription verifies neither the material
nor the value's applicability. Missing temperature, manufacturing-process, or
actual-lot identity **MUST** remain explicitly unestablished and **MUST** make
the observation ineligible for simulation and design acceptance. Publisher
reputation, a source heading, or an `A basis` label **MUST NOT** fill an absent
applicability field. A source caveat visible on the observed page **MUST** remain
visible to downstream consumers.

The reusable observation contract is
`a2a2p.material-source-observation@0.2.0-draft`; its schema is published at
`/schema/material-source-observation`. The schema **MUST NOT** pin the values of
one reference source as though copying that source were interoperability.
Consumers **MUST** additionally enforce semantic invariants that JSON Schema
cannot express alone: the observation identifier binds the exact digest and
page; established and unestablished applicability fields do not overlap;
document and transcription claims are supported by retrieval evidence; and no
field promotes the observation beyond its non-authorizing ceiling. The CC0
profile at `/profile/material-source-observation` publishes a valid canonical
observation and adversarial vectors for each boundary.

A source observation is permanently ineligible for simulation and design
acceptance. An implementation **MUST NOT** promote one by flipping an
eligibility or authority field. Promotion requires a separate transformation
into a simulation-consumable evidence contract whose additional applicability,
method, uncertainty, and freshness requirements have independently been
satisfied.

**Promotion planning.** An implementation MAY expose a deterministic planning
operation that compares one valid source observation with a caller-declared
target property, material state, temperature, orientation, and manufacturing
process. The planner is a gap assessment, not the transformation itself. It:

- **MUST** validate the source observation's semantic invariants before making
  any comparison;
- **MUST** bind the exact source observation, target context, and planner
  algorithm/version with separate content digests;
- **MUST** label each compared dimension as `match`, `conflict`, or
  `unestablished`, and **MUST NOT** choose a value when source and target
  conflict;
- **MUST NOT** infer material family, evidence class, method, uncertainty,
  freshness, or a content-bearing excerpt from publisher identity, document
  title, record label, digest, or transcription alone;
- **MUST** name each missing evidence field required by the target material-
  property contract; and
- **MUST NOT** mutate the source observation, create material-property evidence
  or simulation input, call a model or solver, or grant engineering, safety,
  supplier-contact, ordering, payment, or fabrication authority.

The reference assessment contract is
`a2a2p.material-evidence-promotion-assessment@0.1.0-draft`, exposed as MCP
`plan_material_evidence_promotion` and REST
`POST /api/material-evidence/plan-promotion`. Its exact input schema is at
`/schema/material-evidence-promotion`; the CC0 executable profile at
`/profile/material-evidence-promotion` publishes a canonical gap plan plus
conflict, authority-laundering, digest-drift, and generic-verification negative
vectors. Satisfying a plan requires a distinct, separately inspectable
evidence-producing operation. The plan itself remains permanently
non-authorizing.

**Standalone material-property evidence validation.** An implementation MAY
expose the material-property envelope as an independently callable validation
operation before a caller attaches it to any simulation. Such an operation:

- **MUST** consume the same canonical material-property evidence definition
  used by the compatible simulation operation, rather than maintaining a second
  independently authored shape;
- **MUST** validate the closed property, material-state, applicability,
  evidence-class, method, uncertainty, source-kind, freshness, and content-
  bearing excerpt requirements;
- **MUST** bind the exact caller-supplied source snapshot and complete evidence
  envelope with separate content digests;
- **MUST** distinguish an engineering envelope that is eligible only as a
  preliminary scalar input from computed-crystal or semantically incomplete
  evidence that remains `reference_only`;
- **MUST NOT** relabel a materials-database source as an engineering datasheet
  or experimental measurement, or relabel another source class as computed-
  crystal evidence;
- **MUST** omit the source excerpt from its compact receipt while preserving
  the excerpt byte count and source-snapshot digest; and
- **MUST NOT** claim that shape/content validation retrieved the source,
  verified its claim, identified the actual material, independently established
  uncertainty, created physical evidence, established a design allowable,
  created a simulation input, validated engineering, certified a design, or
  granted any physical or external authority.

An implementation accepting this operation from untrusted callers **MUST**
apply its published intake-screening policy to the complete evidence content
before producing a binding receipt. A screening denial creates neither a
binding receipt nor deterministic permission to retry.

The reference validation contract is
`a2a2p.material-property-evidence-validation@0.1.0-draft`, exposed as MCP
`validate_material_property_evidence` and REST
`POST /api/material-evidence/validate-property`. Its exact wrapper schema is at
`/schema/material-property-evidence-validation`; the CC0 executable profile at
`/profile/material-property-evidence-validation` publishes one preliminary
engineering envelope, one explicitly synthetic computed-crystal class vector
that asserts no live database value, and fail-closed freshness, source-class,
root-authority, and future-check vectors. A successful binding receipt proves
only contract shape and exact caller-supplied content identity.

**Materials Project elasticity adapter.** An implementation MAY translate one
projected Materials Project elasticity response into the canonical
material-property evidence envelope. Such an adapter:

- **MUST** bind one exact requested Materials Project identifier to one
  non-deprecated document whose elasticity fit state is `successful`;
- **MUST** preserve the API version, database version, document update time,
  record license, warnings, and an exact digest of the supplied bounded
  response projection;
- when a caller locally retrieved and projected a larger upstream envelope,
  **MUST** bind the caller-asserted raw-response digest separately, enumerate
  the exact projected document and response-metadata fields, state that the
  representation changed, and **MUST NOT** claim the service verified that raw
  digest or upstream origin;
- **MUST** validate positive Reuss, Voigt, and Voigt-Reuss-Hill bulk and shear
  moduli with `Reuss <= VRH <= Voigt`, and **MUST** fail closed when the
  reported homogeneous Poisson ratio disagrees materially with the same VRH
  inputs;
- MAY derive an isotropic aggregate Young's modulus from the reported VRH bulk
  and shear moduli using `E = 9KG/(3K+G)`, but **MUST** publish that equation,
  its exact inputs, its unit, and the fact that it is an isotropic aggregate
  derivation rather than a directional product-form property;
- **MUST** preserve the evidence class as `computed_crystal`, source kind as
  `materials_database`, unestablished engineering grade, condition, product
  form, manufacturing state, and temperature applicability, and
  `reference_only` simulation use;
- **MUST** carry an attribution URL, license URL, whether attribution and change
  indication are required, and whether upstream guidance is required before
  public redistribution;
- **MUST NOT** interpret a database record's license marker as legal permission
  for a use, relabel computed data as experimental or datasheet evidence, or
  grant design-allowable, engineering-validation, certification, safety,
  supplier-contact, order, payment, or fabrication authority; and
- when it consumes a caller-supplied response rather than retrieving the source
  itself, **MUST** state that the source origin was not verified and that no
  upstream network call occurred.

For `computed_crystal` evidence only, `applicability.temperature_c` MAY be
`null` when the upstream record does not establish a finite-temperature
applicability. A null temperature is an explicit missing dimension and **MUST
NOT** be replaced by 0 °C, 0 K converted to Celsius, ambient temperature, or
another inferred value. Engineering-datasheet and experimental evidence still
require a finite Celsius value for preliminary simulation eligibility.

The reference adapter is
`a2a2p.materials-project-elasticity-adapter@0.2.0-draft`, exposed as MCP
`translate_materials_project_elasticity` and REST
`POST /api/material-evidence/from-materials-project`. Its exact caller-supplied
projection schema is at `/schema/materials-project-elasticity`; the CC0 profile
at `/profile/materials-project-elasticity` is explicitly synthetic, includes
commercial and noncommercial record-license vectors, and asserts no live
Materials Project value. Live upstream retrieval is a separate capability and
**MUST NOT** be implied by the translator.

**Credential-local Materials Project retrieval.** A public implementation
**MUST NOT** turn one operator's Materials Project API key into an anonymous
shared-key proxy. A companion client MAY instead retrieve the record in the
caller's own process with the caller's own key and send only the bounded
response projection—not the key—to the translator. Such a client:

- **MUST** read the key from a local secret boundary, send it only in the
  `X-API-KEY` header to `https://api.materialsproject.org`, and **MUST NOT** put
  it in a URL, command argument, output, error, persisted record, or request to
  an Invention Commons Protocol implementation;
- **MUST** discover the adapter endpoint and field projection from the public
  manifest rather than maintain a second hand-authored field list, but **MUST**
  also compare the canonical projection digest with a version-pinned digest in
  the immutable client artifact before calling the source. A manifest may
  describe a newer projection; it cannot silently make an installed client
  retrieve or transmit new fields;
- **MUST** hash the exact raw response bytes before projecting the allowlisted
  document and response metadata, carry both raw and projected identities, and
  indicate that fields were removed;
- **MUST** fail closed on authentication failure, rate limiting, oversized or
  malformed responses, missing projected fields, adapter drift, and unknown
  record-license codes without exposing arbitrary upstream response content;
- **MUST** return stage-aware effects on both success and rejection, separately
  stating whether the manifest, Materials Project source, and hosted adapter
  were called and whether the key was sent to Materials Project. A generic
  `network_called` flag is insufficient to prove that a pre-source refusal kept
  the credential away from the source;
- **MUST** refuse a record marked `BY-NC` before sending its content to the
  hosted commercial reference implementation; and
- **MUST** distinguish transport origin observed by the caller's local process
  from source origin verified by the hosted translator, physical truth,
  engineering applicability, simulation eligibility, and every physical
  authority.

The CC0 reference client is
`a2a2p.credential-local-materials-project-client@0.3.0`, distributed in the
versioned public protocol package as `a2a2p-mp-elasticity`. It makes network
calls from the caller's process; the hosted translator remains stateless and
makes none.

The immutable reference observation at
`/evidence/materials/nasa-6061-t6-sheet` content-addresses the exact NASA NTRS
PDF and page containing an embedded MAPTIS record for 6061-T6 sheet. It verifies
document bytes and transcription only. Temperature, process state, actual-lot
identity, independent reproduction, physical measurement, design allowable,
simulation eligibility, engineering validation, certification, and physical
truth remain false or unestablished. The observation is therefore a citable
source asset, not an accepted model input.

For this eligibility decision, a syntactically nonempty placeholder is absent,
not explicit. Implementations **MUST** normalize case, surrounding whitespace,
punctuation separators, and repeated spaces before comparing these closed values:
`unknown`, `unspecified`, `not specified`, `not applicable`, `n/a`, `na`,
`none`, `null`, `tbd`, `to be determined`, and `pending`. A normalized match in
material name, grade, condition, product form, orientation, or manufacturing
process **MUST NOT** qualify evidence for simulation. A rejection **MUST** name
the exact absent fields and MAY permit deterministic retry only by replacing
them with substantive evidence. Computed-crystal ineligibility is not repaired
by relabeling fields and therefore **MUST NOT** receive that retry guidance.

The reference evidence envelope is
`a2a2p.material-property-evidence@0.3.0-draft`. Its exact input shape is
published once at
`/schema/simulation-study#/$defs/materialPropertyEvidence`. MCP discovery for
`prepare_reviewed_beam_simulation` **MUST** publish a byte-equivalent copy of
`/schema/simulation-study#/$defs/reviewedBeamBridgeInput`; an implementation
**MUST NOT** maintain a second independently authored input definition whose
accepted fields can drift from the public REST schema.

The reference contract is `a2a2p.simulation-study@0.5.0-draft`; the shared JSON
Schema is published at `/schema/simulation-study`, and the CC0 executable
study/run fixture is at `/profile/simulation-study`. A separate CC0 compiler
fixture at `/profile/reviewed-beam-simulation` publishes one harmless canonical
request/result pair plus fail-closed vectors for evidence-value disagreement,
computed-crystal ineligibility, expired source evidence, and semantic
placeholders. The positive
vector cites NASA MAPTIS 6061-T6 sheet data, while stating that the profile
runtime did not retrieve or verify the source and grants no design-allowable,
engineering-validation, selection, supplier, or fabrication authority. The
fixture declares its own 20°C applicability context rather than attributing
that context to the cited source. The
reference operations are MCP
`prepare_simulation_study` / `prepare_reviewed_beam_simulation` /
`run_bounded_simulation_study` /
`validate_simulation_study_result` and REST `POST /api/simulation-study/prepare`
/ `POST /api/simulation-study/from-reviewed-beam` /
`POST /api/simulation-study/run` / `POST /api/simulation-study/validate`.
All are stateless. Preparation and validation run no solver; bounded execution
runs only the named local closed-form adapter. None calls a model, external
solver, provider, supplier, quote, order, payment, or fabrication operation.

**§5.1.5 Prospective decision-lift evidence (normative when claimed).**
An implementation MAY compare two domain-reasoning systems, but it **MUST NOT**
describe a system as improving decisions merely because its models agree, its
supervisor recommends an option, or its output appears persuasive. Before
either arm runs, a conforming comparison **MUST** publish or immutably register:

- the exact case, evidence snapshot, tool policy, output schema, and evaluation
  rubric, each bound to an exact-byte SHA-256 digest;
- the estimand and claim ceiling, including whether the study compares equal
  compute or complete recorded system bundles;
- a hidden two-arm assignment commitment and an isolation policy that forbids
  either arm from seeing the other's output;
- retry, artifact-selection, compute-cost, latency, model-roster, failure, and
  prompt-observability policies; and
- the qualified label sources, blinded evaluation procedure, hard-gate
  precedence, and complete invalidation vocabulary.

The implementation **MUST** preserve exactly one authored artifact from each
arm, disclose all registered arms, and **MUST NOT** select among unreported
retries or alter the rubric after seeing an arm. A transport retry is permitted
only when no artifact was returned and the attempt is recorded. If an arm sees
the other's output, the evaluator is unblinded or participated in an arm, the
hidden mapping is disclosed before labeling, a source digest differs, or an
output fails its frozen schema, the study **MUST** remain on record as
invalidated rather than be silently rerun.

A participating model or model panel **MUST NOT** supply the independent label.
In this revision, qualified label sources are an independent human domain
expert, a supplier disposition, or a physical outcome. Hard safety and
engineering gates take precedence over a preference score. Without a qualified
label, a completed pair is `artifact_comparison_unlabeled`; before either arm
runs it is `preregistered_not_run`.

One paired case can establish only a case-level artifact preference. It
**MUST NOT** be generalized to system-level decision lift; that claim requires
a separate prospective multi-case design. A digest establishes content
integrity, not authorship, truth, timestamp authority, engineering correctness,
or proof that a named model ran. Hidden system prompts or reasoning that the
host cannot export **MUST** be disclosed as partially observable rather than
represented as captured.

Every registration and result **MUST** make requirement mutation, engineering
validation, safety override, supplier or provider contact, quote request,
order, payment, and fabrication authority machine-checkable and false. The
reference registration contract is `a2a2p.decision-lift-study@0.1.0-draft`;
its schema is at `/schema/decision-lift-study` and the first prospective
registration is at `/evidence/decision-lift-study`. Paired capture is published
separately as `a2a2p.decision-lift-result@0.1.0-draft`, with schema at
`/schema/decision-lift-result` and evidence at
`/evidence/decision-lift-result`. The first pair is
`artifact_comparison_unlabeled`: both artifacts exist, no qualified label or
winner exists, and recorded provenance conflicts make system-bundle attribution
ineligible. The result grants no physical or commercial authority.

### 5.2 `get_supply_options` — price

Returns pricing and lead time. Synchronous.

```jsonc
{
  "options": [
    { "source": "provider", "pricing_kind": "provider_quote", "provider": "string",
      "unit_price_usd": 12.40, "total_usd": 124.00, "lead_time_days": {...}, "quote_reference": "string" },
    { "source": "provider", "pricing_kind": "provider_estimate", "provider": "string",
      "total_usd": 120.00, "disclaimer": "Indicative provider price; not a commitment." },
    { "source": "estimate", "pricing_kind": "model_estimate", "method": "string", "confidence": "low | moderate | good",
      "unit_price_usd": { "low": 17, "high": 40 }, "basis": "string", "disclaimer": "string" }
  ]
}
```

**§5.2.1 The honesty rule (normative).** An implementation **MUST** distinguish
a provider quote, a provider-generated estimate, and an implementation's own
model estimate, and **MUST NOT** present either kind of estimate as a quote.
Every new pricing option MUST carry `pricing_kind`:

- `provider_quote` means a named manufacturer indicates it will honour the
  price under stated terms. It MUST identify the provider and SHOULD include a
  quote reference, expiry, and material terms.
- `provider_estimate` means a named provider's API calculated an indicative
  price but did not commit to honouring it. It MUST identify the provider and
  carry a not-a-quote disclaimer.
- `model_estimate` means the implementation calculated the price itself. It
  MUST carry its method, basis, confidence, and a not-a-quote disclaimer.

`source` remains a coarse provenance field for compatibility: `provider` for
either provider-origin kind and `estimate` for a model estimate. When
`pricing_kind` is absent, legacy `source: "provider"` retains the stricter
`provider_quote` meaning and legacy `source: "estimate"` means
`model_estimate`. The additive field is forward-compatible under §8.

This is the specification's sharpest requirement, and it exists because the
failure mode it prevents is fatal to trust: an agent that cannot tell a
computed guess from a commitment will eventually commit real money to a
fiction. An implementation that blurs the two is **not conformant**, however
accurate its numbers.

### 5.2.2 Deferred pricing (normative for implementations that offer it)

Some providers answer slower than a caller can reasonably block — the reference
implementation's sole provider answers in ~13 seconds against a 15-second
transport budget. An implementation MAY therefore offer pricing as a **job
resource**: submission returns immediately with an identifier, the provider
interaction happens out-of-band, and the caller polls. An implementation that
offers deferred pricing **MUST** satisfy all of the following; transport and
storage are its own business.

**Lifecycle.** A job has exactly four states, and the terminal three are
distinct on purpose:

| State | Meaning |
|---|---|
| `pending` | Accepted; provider path not yet finished. |
| `completed` | A provider figure was obtained (`provider_estimate` under §5.2.1). Terminal. |
| `degraded` | No provider figure; the implementation's own `model_estimate` is returned **with a stated machine-readable reason** the provider figure is absent. Terminal. |
| `refused` | Screening stopped the job; no provider was contacted. Terminal. |

The only allowed transition source is `pending`. An implementation **MUST NOT**
collapse `degraded` into `completed`: a caller deciding whether to wait, retry,
or escalate needs to know the provider was not the source, and a success label
over a fallback is the §5.2.1 failure wearing job clothing.

**Acceptance is authoritative at submission.** The submission response **MUST**
carry the complete initial job representation. If the implementation's storage
is eventually consistent, a poll that finds nothing **MUST** answer
"unknown or not yet visible" rather than asserting the job does not exist —
claiming certainty the storage cannot provide is a false statement in a
protocol whose currency is labeled honesty.

**Execution is an explicit contract.** An implementation **MUST** disclose
whether its deferred executor can contact a provider, how pending work is
scheduled, and whether an environment or configuration change can grant that
authority. A post-response callback **MUST NOT** be the sole executor when the
published or measured provider path can exceed that callback's execution
budget. A pending job MAY expose subordinate execution states such as `queued`
or `running`, but those states do not add pricing lifecycle states and grant no
order, payment, or fabrication authority.

Where more than one executor can observe the same pending job, an
implementation **MUST** acquire an atomic execution claim in a transactional
primary-write store before beginning work. An eventually consistent
read-then-write lease is not an atomic claim. An expired claim MAY be reclaimed
only while durable state proves that provider contact has not begun. Before the
first provider interaction, the implementation **MUST** durably record contact
intent. After that boundary, lease expiry **MUST NOT** authorize another
provider interaction; the implementation MUST reconcile the prior attempt or
report an ambiguous outcome.

The durable contact-intent record **MUST** identify the provider path and bind
the attempt to a stable, implementation-unique operation key before contact.
That key **MUST** remain available to read-only reconciliation for as long as
the no-retry tombstone exists. Reusing one operation key for two jobs is an
invalid state. An operation key alone **MUST NOT** be treated as evidence that
the provider honors idempotency: automatic repetition remains forbidden unless
the provider's idempotency or read-only lookup semantics have been separately
verified.

If an execution claim or tombstone is later removed for data minimization, it
**MUST** outlive every queue marker, job record, or other executable source that
could cause the same interaction to run again. An implementation **MUST**
disclose both retention periods. Expiry of the executable source permits claim
removal; it does not retrospectively establish whether provider contact or an
external result occurred.

If an execution ends after provider contact may have occurred but before a
terminal receipt is durably stored, the implementation **MUST** treat the
external outcome as ambiguous. It **MUST NOT** automatically repeat the
provider interaction unless the provider offers a verified idempotency or
read-only reconciliation contract that makes duplication impossible. A local
fallback MAY end the job as `degraded`, but it MUST name interruption as the
reason and MUST NOT imply that the provider returned no result.

**Screening precedes the provider** (§5.5, §7.3): the requirement before the
job is stored, and any fetched design-file bytes before provider contact. A
screening verdict other than allow either rejects the submission or completes
the job `refused`, and in neither case is the provider contacted.

**Bounded spend.** An implementation that pays for provider calls **MUST**
bound them (the reference implementation publishes per-caller and global
budgets and content-addressed idempotency) and **SHOULD** disclose the bound
rather than failing mysteriously when it is reached.

**Admission is a result, including when rejected.** A deferred-pricing
submission that reaches domain admission assessment **MUST** return a
machine-readable `admission` object whether it is admitted or rejected. The
object MUST carry a stable contract identifier and version, `status` (`admitted`
or `rejected`), `job_created`, and `provider_contacted`. A rejection MUST also
carry a reason code from a documented closed vocabulary, whether retry is
available through a deterministic input repair, the required input when one is
missing, and a deterministic next action. Human prose MAY accompany these
fields but MUST NOT be the only repair instruction. A screening appeal is not a
deterministic repair retry: it MAY invite materially new benign context while
`deterministic_retry_available` remains false.

The initial reason-code vocabulary is:

| Code | Meaning |
|---|---|
| `unsupported_process` | This provider path does not support the declared process. |
| `required_design_file_missing` | A provider-required design artifact is absent or not identified in a supported form. |
| `screening_not_allowed` | Screening stopped admission before any provider contact. |
| `decomposition_required` | `specification.assembly` declares two or more fabricated parts; no job is created until they are decomposed into one requirement per part. |

Implementations MAY add reason codes under §8, but MUST NOT silently change the
meaning of a published code, and adding one requires a compatible contract
version increment. A caller receiving an unknown reason code MUST preserve the
overall `rejected` status and MUST NOT auto-retry; it SHOULD use the explicit
retry and next-action fields if it understands them. Thus the vocabulary is
closed for a declared contract version without making newer implementations
fail open in older clients. `screening_not_allowed` MUST NOT direct a caller to
retry unchanged or suggest that rephrasing can bypass screening. An admitted
receipt is not evidence that the provider was contacted: at admission,
`provider_contacted` is false and later job state supplies that evidence.

A read of an unknown job identifier MUST distinguish `unknown_or_not_yet_visible`
from a terminal outcome. It SHOULD say that retry with backoff is valid only
when the identifier came from an authoritative admitted response; callers MUST
NOT infer an identifier after rejection. Neither admission rejection nor an
unknown-job read contacts a provider.

Estimate-only remains estimate-only: a deferred job returns §5.2.1-labeled
pricing and confers no order, payment, or fabrication capability.

### 5.3 `submit_requirement` — resolve

Accepts a requirement for full resolution and returns a durable identifier.
Asynchronous work is permitted, but:

- The response MUST be synchronous and MUST carry immediate value (at minimum a
  `review_specification` result). An identifier alone is not a response — the
  calling agent's session may not exist when the work completes.
- The identifier MUST remain resolvable.

### 5.4 `check_status` — retrieve

Returns lifecycle state and, once available, the resolution.

An implementation that generates a report asynchronously **MUST** distinguish
report delivery from request lifecycle. Its status response **MUST** include a
versioned delivery receipt with one of these states:

- `pending_machine_draft` — no report is available and the implementation's
  declared automatic retry window has not elapsed;
- `generation_failed` — no report is available and the implementation's
  finite automatic attempt budget is exhausted or its persisted generation
  state is invalid; the existing identifier will not be retried;
- `generation_expired` — no report is available and the implementation's
  declared automatic retry window has elapsed; the existing identifier will
  not be retried;
- `machine_draft` — a generated report is available but has not been published
  by an operator; or
- `operator_published` — an operator has published the report.

The receipt **MUST** state whether a report is available and whether it is
operator-published. It **MUST NOT** represent either available state as
professional engineering certification, a supplier quote, or external action.
Supplier contact, purchase, payment, fabrication, and shipment authority **MUST**
all remain false. `pending_machine_draft`, `generation_failed`, and
`generation_expired` require
`available:false`;
`machine_draft` requires `available:true` and `operator_published:false`; and
`operator_published` requires both values true.

The receipt **MUST** also carry a versioned, read-derived automatic-generation
projection. That projection **MUST** distinguish a complete observed attempt
history from a legacy or unavailable history; disclose the observed attempt
count when complete, the fixed maximum, whether an automatic attempt is
eligible now, and the earliest automatic-attempt time when one is scheduled;
and use `null` rather than inventing an attempt count or time. An implementation
**MUST NOT** expose model errors, prompts, responses, request content, or
credentials in this projection. Malformed persisted generation state **MUST**
fail closed and **MUST NOT** restart an automatic attempt budget.

The projection's fields **MUST** agree. An exhausted state requires the observed
attempt count to equal the declared maximum. A succeeded, exhausted, or invalid
state requires automatic eligibility false and no next-attempt time. For an
attempting or retry-scheduled state, current eligibility true requires no
future next-attempt time; current eligibility false requires an exact
next-attempt time. These are schema invariants, not prose-only guidance.

An automatic attempt **MUST** be durably counted before its external model call
begins. The same finite policy **MUST** govern immediate background work and
scheduled recovery. An interrupted task MAY consume an attempt because the
external provider may already have accepted the call; it **MUST NOT** become an
unrecorded retry.

An asynchronous implementation **MUST** publish its automatic retry window and
**MUST NOT** describe a request as pending after that window has elapsed. A
`generation_failed` or `generation_expired` receipt **MUST** state that the
same identifier cannot be retried. Its repair MAY permit a new
`request_physical_solution` call only with caller confirmation and caller-held
input; the implementation **MUST NOT** reconstruct or infer missing input from
the terminal record. Failure or expiration confers no external authority and
**MUST NOT** mutate, contact, purchase, fabricate, or ship anything.

An implementation **MUST NOT** withhold an available machine draft merely because
operator publication has not occurred. It **MUST** label the draft and its
limitations instead. An implementation **MUST NOT** promise an operator-review
service level it has not actually staffed and measured. The reference schema is
published at `/schema/resolution-report-delivery`.

### 5.5 Screening (normative for any implementation that fabricates)

An implementation that can cause an object to be manufactured **MUST** screen
requirements before fabrication and **MUST** publish its screening policy at a
stable, machine-readable location.

```jsonc
{
  "verdict": "allow | review | deny",
  "categories": ["string"],
  "reasons": ["string"],
  "message": "string",
  "appeal": {                              // SHOULD be present on a deny
    "method": "resubmit_with_context | contact | human_review",
    "instructions": "string",              // what the requester should actually do
    "contact": "string"                    // OPTIONAL; required only for method=contact
  }
}
```

- Screening MUST be graduated by irreversibility: assessment and pricing MAY be
  permissive; fabrication MUST apply the strictest bar.
- A `deny` MUST be a structured response stating the category and reason, and
  SHOULD offer an appeal path **in a named field with a stated method**, not
  only in prose. An appeal route that a caller has to find by reading a message
  cannot be acted on programmatically, and cannot be checked by a conformance
  suite without guessing — before 2026-08-03 this specification asked for an
  appeal path without giving it a shape, and the suite resorted to searching the
  whole response for an "@". Silent failure is **not conformant** — an agent
  that cannot learn why it was refused cannot correct course, and opaque
  refusal is indistinguishable from malfunction.
- An implementation **MUST** require a traceable responsible principal before
  fabrication, and MAY remain anonymous for assessment and pricing. The
  principal **MUST** be a named person or a named legal entity that can be
  identified and reached; a product name, agent identifier, wallet, API key, or
  pseudonymous account alone is not sufficient. The principal is accountable
  for the request and does not replace the implementation's screening owner
  under §7.3 or the supplier's independent compliance duties.
- A published policy SHOULD state its own limits in a machine-readable field.
  No filter judges intent perfectly, and a policy that describes only what it
  catches invites the reader to assume it catches everything. Say what it
  cannot do.
- An implementation that claims screening auditability **MUST** expose whether
  known audit writes were lost and **MUST NOT** present a partial trail as
  complete. Audit-storage failure MAY remain independent of the request outcome
  so an unavailable log does not silently convert an allow into a denial, but
  the loss itself MUST be visible to the accountable operator. A loss-integrity
  marker **MUST NOT** retain rejected request content, design-file content,
  contact details, caller identity, or raw error text merely to prove that a
  write failed.
- Screening audit records **SHOULD** retain the decision, stage, closed
  category, policy version, time, and a content-free correlation reference
  needed for accountable review, rather than the raw request or the exact text
  matched by a screening rule. If an implementation retains raw request or
  matched text, its published policy **MUST** identify the exact retained
  fields, purpose, access boundary, and retention period. It **MUST NOT** retain
  that content merely to count decisions, categories, or screening failures.
- Successful concurrent audit writes **MUST NOT** depend on a shared
  read-modify-write index unless the storage system provides an atomic mutation
  primitive for that index. Otherwise two successful writes can leave only one
  discoverable record without producing an error for the integrity marker to
  observe. An implementation **SHOULD** use independently discoverable,
  expiring entry keys or an atomic append store. If discovery is eventually
  consistent, the operator evidence **MUST** disclose that consistency bound
  rather than describe the visible trail as immediately complete.
- A bounded audit read **MUST** publish its record limit, whether the returned
  window is complete, whether more records are known to exist, and that all
  counts apply only to the returned window. A capped read **MUST NOT** label its
  returned count as the total trail or report zero retained-content records
  without disclosing that older or undiscovered records were not inspected.

### 5.6 Conformance probes (normative)

A conformance suite must be able to exercise §5.3 — which creates a durable
record — without that record being mistaken for real work. Otherwise testing an
implementation pollutes its operator's alerts, its demand data, and its
fulfilment queue. This is not hypothetical: the reference implementation's own
suite generated three false "new order" notifications before this section
existed.

A requester MAY mark a request as a probe, either by sending the header

    X-A2A2P-Probe: conformance

or by setting `"_probe": true` in the request body.

An implementation that honours probes:

- **MUST** return a response of the same shape as a real request, including a
  resolvable identifier — otherwise the probe cannot test anything.
- **MUST NOT** notify operators, enqueue the request for fulfilment, or place
  any order as a result of it.
- **SHOULD NOT** count the request as demand in operator-facing metrics; if it
  is recorded, it MUST be distinguishable from real traffic.
- **SHOULD** expire probe records rather than retaining them.
- **MUST NOT** treat the marker as authorisation for anything. A probe is a
  request to be *ignored downstream*, never a request to be trusted: screening
  and validation apply unchanged.

An implementation MAY ignore the marker entirely and treat probes as real
requests. That remains conformant — but it means every conformance run leaves
litter in its operator's queue, so honouring probes is strongly encouraged.

### 5.7 Provider status reporting (normative where published)

An implementation that names the providers behind it SHOULD publish their
status, because an agent choosing whether to depend on a fulfilment path needs
to know whether that path is currently reachable. A published status is a
factual claim about a third party, so it carries the same honesty duty as
§5.2.1 carries for prices.

```jsonc
{
  "providers": [{
    "id": "string", "configured": true,
    "status": "up | degraded | down | auth_error | configuration_error | unknown | not_configured",
    "checked_at": "ISO-8601",
    "last_sample": { "ok": false, "status": "string", "latency_ms": 15000, "attempts": 2, "at": "ISO-8601" },
    "reliability": {
      "window_hours": 24, "samples": 20, "successful_samples": 18, "availability": "90%",
      "sufficient_for_trend": true, "last_failure": { "status": "string", "at": "ISO-8601" },
      "probe_latency_ms": { "median": 180, "max": 15000 }, "basis": "string"
    }
  }]
}
```

An implementation that publishes provider status:

- **MUST NOT** present a single failed probe as an outage. A transient failure
  that has not been confirmed by a further probe MUST be reported as `degraded`
  rather than `down`. This is not a courtesy to the provider: on 2026-08-02 one
  15-second timeout published `down` for a provider API that was answering
  external callers in ~150 ms, and a status that wrong is worse than none.
- **MUST NOT** delay a deterministic wiring fault behind that confirmation. A
  rejected credential or a missing account (`auth_error`,
  `configuration_error`) does not improve on retry and MUST be published at
  once.
- **MUST** state the basis of any availability figure, including the
  observation window and the fact that it is the implementation's own
  measurement.
- **MUST NOT** present its own reachability measurement as a provider
  service-level commitment.
- **MUST NOT** treat provider status as fulfilment capability. Reachability
  proves a dependency answers; it proves nothing about authorisation, ordering,
  payment, fabrication, shipment, or delivery. An implementation MUST NOT claim
  L4 on the strength of a healthy provider (§7).
- **SHOULD** publish the most recent raw probe alongside the confirmed status,
  so a caller can see an unconfirmed failure rather than only its summary.
- **SHOULD** report the sample count with any availability figure, and SHOULD
  indicate when the sample count is too small to read as a trend.
- **SHOULD** publish latency against the deadline it has to meet, not as a bare
  number. **Availability is not usability.** A provider that answers every probe
  can still be unusable: on 2026-08-02 the reference implementation measured 97%
  availability with a 12,474 ms median probe latency against a 15,000 ms
  timeout, while the workflow that provider supports makes five sequential
  calls — roughly 73 seconds at the observed p95, against a 20-second
  synchronous budget. Every availability figure was healthy and the capability
  was impossible. An implementation reporting latency SHOULD state the probe
  timeout the figures were measured under, a tail percentile rather than a
  median alone, and the arithmetic linking observed latency to the workflow's
  own deadline.

### 5.8 Ambiguous external operations (normative where external state may be created)

If a provider operation may have created external state but its response does
not prove success or non-allocation, an implementation **MUST** classify the
outcome as unresolved. It **MUST NOT** retry, replace, advance, pay for, or
fabricate from that operation. Read-only reconciliation is permitted, but an
empty lookup **MUST NOT** be treated as proof of non-allocation unless the
provider publishes the lookup's consistency bound and that bound has elapsed.

The unresolved state may close only when authoritative provider evidence
establishes its disposition. Any later external action still requires explicit
authorization from the responsible human or accountable principal; resolving
ambiguity does not itself authorize the next step.

---

## 6. Transport bindings

The protocol is transport-agnostic. Two bindings are defined; others MAY exist.

**MCP** (recommended): capabilities exposed as MCP tools over Streamable HTTP.
Implementations SHOULD NOT require authentication for assessment and pricing —
the cost of an API key is paid in adoption, and an agent that must stop and
register will use something else.

**REST/JSON**: `POST /api/review`, `POST /api/supply`, `POST /api/requests`,
`GET /api/requests/{id}`. Responses are the objects in §5. CORS SHOULD be open
for assessment and pricing.

### 6.1 Temporary design-file ingress (optional capability)

A requester may hold design bytes locally while the canonical requirement carries
an HTTPS reference. An implementation MAY expose an ingress capability that turns
those bytes into a temporary §4.1 `design_files` item. If it does, the following
requirements apply:

- **Purpose is declared.** Manufacturing-file intake MUST be distinguished from
  general chat or reference attachments by an explicit purpose field. An
  implementation MUST NOT infer manufacturing purpose only from a filename or MIME
  type.
- **Bytes outrank names.** The implementation MUST decode and identify the bytes
  before making them retrievable. Unknown bytes and a declared/detected format
  mismatch MUST be refused with a stable error. A filename is not evidence.
- **One executable contract.** Accepted formats, aliases, signatures, decoded-size
  ceilings and retention MUST have one code-owned definition shared by ingress,
  retrieval and inspection. A binding-specific ceiling MAY be lower, but MUST NOT
  exceed any downstream ceiling.
- **A temporary reference says when it ends.** Success MUST return the canonical
  `{url, format}` item, an absolute `expires_at`, and the retention interval. The
  implementation MUST enforce expiry when the reference is read even if storage
  cleanup lags, and MUST return a stable caller-visible expired-reference error.
- **Role is declared, capability is not invented.** `role` MAY be `geometry`,
  `drawing`, or `reference`. A drawing does not become measurable geometry merely
  because the same ingress accepted it.
- **Storage is not action.** Ingress MUST NOT create a requirement, contact a
  provider, request a quote, order, charge, or fabricate. Those remain separate
  capabilities with their own screening stage.
- **Telemetry is content-free.** An implementation MAY record a closed result,
  detected format and coarse size bucket. It MUST NOT put bytes, filenames,
  extracted metadata, or requirement text in demand telemetry.

These rules do not require any specific encoding. An MCP binding may use bounded
base64 while an HTTP binding uses multipart form data; both produce the same
canonical reference and the same refusal semantics.

**Discovery.** An implementation SHOULD serve `/llms.txt` describing its
capabilities in prose, and SHOULD publish its JSON Schema at a stable URL. It
SHOULD also publish the text or version of the specification it implements, at
a stable URL, so a caller can tell which revision it is talking to rather than
inferring it from behaviour.

**Request shape.** A binding MUST accept the §4.1 object form. An implementation
MAY additionally accept its own convenience aliases, but MUST NOT require them,
and a conformance check MUST NOT depend on one: an assertion that only passes
for an implementation's private input shape tests that implementation, not this
specification. The reference implementation's suite made exactly this mistake
until 2026-08-03, when a clean-room build failed three assertions for using the
documented shape.

---

## 7. Conformance

An implementation is **the Invention Commons Protocol conformant at level N**:

| Level | Requires |
|---|---|
| **L1 — Speaks** | Accepts §4.1 requirements with `intent.purpose` alone; returns §5.1 assessment |
| **L2 — Prices** | L1 + §5.2 with the honesty rule of §5.2.1 |
| **L3 — Resolves** | L2 + §5.3/§5.4 with synchronous first-response value |
| **L4 — Fabricates** | L3 + §5.5 screening with a published policy + a traceable responsible principal + real fulfilment |

An implementation MUST NOT claim a level it does not meet. Claiming L4 without
screening or without a traceable responsible principal is a conformance
violation regardless of manufacturing capability.

Conformance is self-declared; there is no certifying authority, deliberately.
Implementations SHOULD publish which level they meet and where they fall short.

**A conformance suite is published alongside this specification** and runs
against any implementation:

```bash
node tests/conformance.mjs https://your-implementation.example
```

Every assertion cites the section it enforces. It is CC0 like the rest of the
spec — run it against your own implementation, or against someone else's.

A machine-run assertion has exactly three possible outcomes: `pass`, `fail`,
or `not_evaluated`. A conforming runner **MUST NOT** turn an HTTP 429 response
into either a semantic failure or a pass. It MAY report `not_evaluated` only
when the target explicitly returned 429, and it **MUST** preserve the retry
horizon and any machine-readable rate-limit scope the target supplied. A
`not_evaluated` assertion is excluded from the evaluated denominator, cannot
contribute to a conformance level, and makes the current run indeterminate.
Returning 429 for every probe therefore never creates conformance. Transport
errors and semantic mismatches remain failures; they are not rate limits.

### 7.0.1 Rate-limit receipts

An HTTP implementation that rate-limits a public JSON operation **MUST** return
status 429 and a `Retry-After` header whose value is either an HTTP date or
non-negative delta-seconds as defined by RFC 9110 §10.2.3. Its JSON body
**MUST** carry `code: "rate_limited"` plus a machine-readable `rate_limit`
object with a versioned contract identifier, stable scope, maximum accepted
requests, window length, retry horizon, and window kind. When both header and
body express delta-seconds, the values **MUST** agree.

The receipt **MUST** state whether the denied attempt was counted, whether
retrying before the horizon can extend recovery, and the enforcement precision
the implementation actually provides. If a rate-limit identity can represent
shared traffic, the receipt **MUST** state whether another attributed request
can consume allowance or extend recovery. It **MUST NOT** expose a raw IP
address, client fingerprint, credential, or other underlying identity value.
Scope names are policy identifiers, not client identifiers.

A conforming client **MUST NOT** assume a fixed window unless the receipt says
so. For `fixed_window`, a denied retry **MUST NOT** move the disclosed boundary;
the retry horizon can only remain equal or decrease until that boundary. A
counter implemented on an eventually consistent store **MUST NOT** claim exact
distributed enforcement. Changing storage-key generations MAY reset the active
allowance once, but the implementation **MUST** disclose that migration instead
of silently treating old counters as equivalent. The reference implementation
uses UTC epoch-aligned fixed windows, publishes
`enforcement_precision: "best_effort_distributed_counter"`, and moved from
legacy `rl` keys to `rl2` keys with one clean allowance at deployment. Its
receipt also discloses storage-error behavior and the fixed-window tradeoff
that up to twice the configured allowance can pass across two adjacent windows.
The reference receipt schema is published at `/schema/rate-limit`. This contract
relies on standardized `Retry-After`; it does not claim that evolving
experimental rate-limit header fields are an RFC.

### 7.0.2 Versioned conformance distribution

An implementation that publishes a conformance runner or companion client at a
versioned immutable URL **MUST** keep every released coordinate retrievable
after later versions ship. “Immutable” means both that bytes at a released URL
never change and that a later deployment does not erase the URL. A current-only
route in front of retained asset bytes does not satisfy this requirement.

Each released artifact **MUST** have a same-version integrity manifest that
states its canonical URL, exact byte length, and SHA-256 digest. Artifact and
manifest responses **MUST** use an immutable cache policy. An unknown version
**MUST** return a stable not-found response; an implementation **MUST NOT**
silently serve the current artifact at an older or unknown coordinate. A missing
current release binding is an operational failure and SHOULD be distinguished
from an unknown historical version.

One limit is stated in the suite itself: **whether an implementation can
actually fabricate cannot be verified over HTTP**, since finding out would mean
placing real orders. The suite therefore verifies the machine-checkable L4
*prerequisites* (screening, a published policy, and a declared
traceable-principal requirement) and separately records the implementation's
fulfilment claim, marking it unproven. Without that distinction any
implementation could publish a policy, make nothing, and pass as L4 — which
would make the suite a way to launder an unearned claim.

---

## 7.1 Supplier profile (normative for implementations that route to suppliers)

Everything above faces the requester. An implementation that never produces
something a supplier can act on cannot reach L4 no matter how good its
assessment is, and the gap is not incidental — it is why implementations
accumulate decision depth and produce no objects.

A **supplier request package** is the projection of a §4.1 requirement into what
a supplier needs in order to quote.

### 7.1.1 What the package MUST carry

- The requested action, stated as pricing rather than manufacture, and an
  explicit statement that it is **not an order**.
- The requirement fields the supplier needs: purpose, quantity, material,
  process, tolerance, dimensions, finish, environment, compliance.
- **Gaps, named rather than filled.** An implementation **MUST NOT** substitute a
  plausible value for an absent quote-critical field. It **MUST** distinguish
  fields that block a firm quote from fields that merely widen the range. A
  quote produced from an invented tolerance is worse than no quote, because
  someone may make the part.
- **Geometry must fit the requested process, not merely exist.** A presence
  check is not a fitness check. An STL carries no tolerances and no units of
  record and cannot be programmed for machining; a DXF profile cannot describe a
  3D milled part. An implementation **MUST** assess the attached geometry against
  the declared process and treat an unusable file as a blocking gap, with the
  same force as no file at all. Where it cannot assess a format it **MUST**
  report that rather than assume the favourable case. The reference
  implementation fixed the missing-file case on 2026-08-04 and was found within
  the hour still grading an STL attached to a milling request `quote_ready` —
  fixing one instance of a defect class is not fixing the class.
- **Geometry is quote-critical, not an accelerator.** Without a model or a
  dimensioned drawing a shop cannot compute cycle time; it declines or pads. An
  implementation **MUST NOT** report a requirement as supplier-quote-ready, by
  any grade or flag, when no design file is attached — however complete the rest
  of the specification is. The reference implementation graded such a part
  `quote_ready` at 95 until 2026-08-04, while the package built from the same
  record told the shop it would be padded.
- **A class label is not a specification.** A tolerance class is not a machinable
  callout, an alloy designation without a temper is not a metal specification,
  and a polymer family without grade, feedstock and additive details is not a
  polymer purchasing specification. An implementation **MUST** transmit the
  appropriate family-specific facts as open questions inviting the shop's
  standard, and **MUST NOT** ask for an inapplicable property (such as a metal
  temper for PETG) or promote an unstated value into a specification.
- **Commercial scope.** The package **SHOULD** carry quote-by date, ship-to
  region, required certifications and inspection documents, and whether
  material or process alternates are acceptable — each supplied or explicitly
  marked unstated. It **MUST** state whether the requested price includes
  freight. Without a declared ship-to region, it **MUST NOT** claim that a firm
  delivered total is obtainable; it MAY remain quote-ready for a firm
  manufacturing price only when it explicitly excludes freight. A shop prices
  freight and inspection, not only the part.
- **No self-assessment may contradict the package's own contents.** Where an
  implementation includes its own readiness score, that score **MUST** be
  consistent with the gaps it reports. An artifact asserting readiness beside a
  note saying the shop will decline is worse than one that says nothing.
- **Provenance.** The package **MUST** disclose that it was machine-generated and
  whether a human reviewed it before sending. Concealing agent origin poisons
  the channel for every later agent-originated request.
- **An accountable principal.** The delivery binding **MUST** supply someone the
  supplier can identify, reach, and hold to the request: a named person, **or** a
  named legal entity with a verifiable registered address. An implementation
  **MUST NOT** require that this be an individual — a registered company with a
  published address is a stronger accountability claim than a personal name with
  nothing verifiable behind it. What is forbidden is anonymity, not legal form.
  The package **MUST** state whether its delivery binding satisfied this
  requirement; the existence of a mailbox alone is not sufficient evidence of
  an accountable organisation.
- **Screening**, in the payload: verdict, stage, policy version, and a
  resolvable policy URL. It **MUST NOT** travel only in a covering note, which a
  forwarding step can drop.

### 7.1.2 Geometry

An implementation **SHOULD** prefer **STEP AP242 with semantic PMI**, which
carries tolerances and notes inside the model and removes the need for a separate
drawing. It **MUST** describe each file by what it actually is: a triangulated
mesh offered as a solid model costs a shop an hour to discover. Where the
implementation has not verified a file's contents it **MUST** say so rather than
asserting a capability the file may not have (§4.3).

A format label without a usable file reference is not attached geometry. When
an implementation performs current file inspection, an unreadable, expired,
unrecognized, mismatched, or unsuccessfully parsed attachment **MUST** prevent
supplier-quote-ready status. An empty or partial inspection **MUST NOT** fall
back to the declared filename or format as evidence that every attachment is
usable. The response **MUST** identify the missing check and explain how to
repair it, for example by reattaching the original file and reviewing again.
A saved package identity proves which JSON was saved, not that its file links
still work. Format recognition and bounded parsing do not establish engineering
correctness, supplier acceptance, or authorization to manufacture.

Where both a declared XYZ envelope and a parseable design file are present, an
implementation **MUST** compare the declaration with geometry measured or read
from that file and publish the result with its provenance and tolerance. A
disagreement **MUST** block supplier-quote-ready status until one source is
confirmed as governing; the implementation **MUST NOT** silently prefer the
file, silently prefer the declared dimensions, or pass both contradictory facts
to a supplier as though they agree. Where the dimensions or file cannot be
compared, the implementation **MUST** say that the check was not evaluated
rather than report a match. A canonical test vector is subject to the same rule
as a caller's requirement.

### 7.1.3 Responsibility, stated and not assumed

An implementation **MUST** state what it expects supplier-side review to catch
and where responsibility sits. "Human in the loop" names no mechanism and
assigns no duty. At minimum the package **MUST** make clear that screening does
not transfer, reduce, or satisfy the supplier's own regulatory and compliance
obligations, and that a shop auto-quoting without human review changes nothing
about them.

### 7.1.4 Delivery is a binding, not the protocol

The package **MUST NOT** assume its own transport. §6 makes this protocol
transport-agnostic and that applies in both directions; a package that hard-codes
its delivery channel is a fulfilment pipeline wearing a specification's clothes.

Defined bindings, all non-normative and extensible:

| Binding | Notes |
|---|---|
| **Email** | The package as a structured attachment with design files attached. Reaches the installed quoting tooling at near-zero cost to the supplier, which ingests forwarded RFQ email today. Requires no supplier engineering and no permission from anyone. |
| **HTTP** | `POST` of the package to a supplier-published endpoint. Requires supplier engineering; almost no small shop has one. |
| **cXML `QuoteRequest`** | Where a supplier already speaks enterprise procurement. Mapping is a profile concern, not a protocol change. |

An implementation **MAY** define others. It **MUST NOT** claim that supporting one
binding constitutes supplier coverage.

### 7.1.5 Test vectors

An implementation claiming this profile **SHOULD** publish canonical example
packages at a stable URL, including at least one quotable and one with blocking
gaps, so a third party can verify conformance **without reading the
implementation's source**. A profile whose only reference is one codebase is not
a profile.

It **SHOULD** also publish a versioned, implementation-independent JSON Schema
for the package at a stable URL, and each vector set SHOULD identify the exact
schema version it targets. The schema MUST encode the non-order assertion and
the screening envelope as machine-checkable constraints; prose that says “not
an order” while the contract accepts `not_an_order: false` is not a control.

### 7.1.6 Rejection receipts

An implementation that exposes a supplier-package operation **MUST** return a
versioned, machine-readable rejection receipt when it cannot produce the
package. Prose alone is insufficient: an agent must be able to distinguish a
repairable missing input from a screening refusal without interpreting natural
language.

The receipt **MUST** include:

- a stable `reason_code` from a published closed vocabulary;
- a `vocabulary` identifier containing the rejection contract and its exact
  version (for example, `a2a2p.supplier-package-rejection@1.2.0`);
- `deterministic_retry_available`, which is true only when supplying named
  missing input is sufficient to make the same operation eligible;
- `required_input` and a structured `next_action` where deterministic repair is
  available; and
- a `repair` value on every receipt. It MUST be `null` when deterministic repair
  is unavailable. Where repair is available it MUST name the original argument
  object as its target, use a closed operation and path, define the required
  caller-supplied value shape, state whether unspecified fields are preserved,
  and state whether inference is allowed. A missing safety-critical value such
  as purpose MUST require a caller value and MUST NOT be inferred from part,
  material, process, filename, or other surrounding fields; and
- explicit false assertions for `package_created`, `supplier_contacted`,
  `provider_contacted`, `order_created`, `payment_created`, and
  `fabrication_authorized`.

The initial rejection vocabulary is:

| Code | Meaning | Deterministic retry |
|---|---|---|
| `purpose_required` | `intent.purpose` (or a documented compatibility alias) is absent or empty. | Yes: provide the purpose and retry the same package operation. |
| `screening_denied` | The requirement did not pass quote-stage screening. | No: do not retry unchanged; use a structured appeal path where one is offered. |
| `decomposition_required` | `specification.assembly` explicitly declares two or more fabricated parts, which §4.4 forbids pricing or packaging as one part. | No: decompose first, then create one requirement and package per fabricated part. |

For `purpose_required`, the reference repair contract is
`a2a2p.argument-repair@1.0.0`: set the exact caller-supplied answer at
`intent.purpose`, preserve every other original argument, and retry the same
operation. It is executable guidance, not permission to synthesize purpose.

Unknown codes **MUST** be surfaced to the caller, treated as rejected, and
**MUST NOT** authorize an automatic retry or be promoted into a consumer's
closed telemetry vocabulary. An implementation MAY extend the vocabulary compatibly, but
changing an existing code's meaning requires a contract-version change. REST
and MCP bindings for the same implementation MUST return identical receipt
semantics. A rejection receipt records a local derivation failure only; it is
not evidence that a supplier or provider saw the request.

### 7.1.7 Package artifact identity

A supplier quote or correction is reusable evidence only when it identifies the
exact package it answered. Every emitted supplier package **MUST** therefore
carry a deterministic SHA-256 identity over the complete package excluding the
identity field itself. The identity **MUST** state the canonicalization rule,
digest input, canonical byte length, and exact digest. Identical package content
MUST produce the same identity; changing any request, geometry, commercial,
gap, provenance, screening, delivery, or authority field MUST change it.

The initial identity contract is
`a2a2p.supplier-package-artifact-identity@1.0.0`. It uses
`a2a2p.sorted-json-v1`: object keys sorted lexicographically, array order
preserved, omitted values excluded, and ordinary JSON scalar encoding. The
digest input is the complete supplier package excluding `artifact_identity`.

A consumer that relies on the identity **MUST** recompute it from the package
it received. A supplier response, quote, revision, or later outcome **SHOULD**
carry the package digest it concerns. The digest proves content identity only.
It does not prove delivery, supplier authorship, a supplier response, quote
acceptance, order, payment, fabrication, physical correctness, or fitness for
purpose.

### 7.1.8 Quote-stage lane eligibility

An implementation that brokers only a bounded initial class **SHOULD** return a
machine-readable eligibility receipt with its supplier package. The receipt
MUST identify the program and version, list every deterministic check, separate
missing input from work outside the class, and state the exact next action.

Eligibility for a local program is not supplier-package quotability, payment
authorization, supplier contact, quote acceptance, an order, or fabrication
authority. A receipt **MUST** state each of those authority boundaries. It MUST
also state whether commercial terms are active; an implementation MUST NOT
silently attach a commission or fee merely because a request is eligible.

The exact material, process, size, quantity, geography, budget, and evidence
limits belong to the named program, not to this protocol. An implementation
MUST NOT describe work outside its first lane as invalid the Invention Commons Protocol work; it remains
eligible for the general protocol path.

### 7.1.9 Supplier-fit assessment

An implementation MAY compare one content-addressed package projection with a
supplier capability declaration. It MUST assess every declared lane and report
each compared fact as `match`, `conflict`, or `unknown`. It MUST NOT collapse
those facts into an opaque score or select a supplier.

The projection MUST identify the exact supplier-package SHA-256 and state its
provenance. When the implementation has not recomputed the projection from the
complete package, it MUST label the facts as caller assertions. A supplier
import observation counts only when its package digest and opaque supplier
alias match the assessed pair. An accepted import proves only that one exact
file reached the observed interface state; it does not establish general file
acceptance.

A result that matches a declared lane is not current availability, a quote,
supplier acceptance, supplier selection, contact permission, purchase
authority, or fabrication authority. Those boundaries MUST remain explicit in
the receipt. REST and MCP bindings for the same implementation MUST return the
same deterministic semantics.

---

## 7.2 The email binding (normative for implementations that use it)

§7.1.4 names email as a binding. This section defines it well enough to
implement without reading anyone's source. It is normative for implementations
that claim the email binding, and irrelevant to those that do not.

Email is specified first because it is the only supplier-side channel that
requires no permission, no supplier engineering, and no vendor's approval — and
because the dominant job-shop quoting tools already ingest forwarded RFQ mail.
That makes it the binding a new implementation can actually use.

### 7.2.1 Bona fide procurement gate

A technically valid request can still waste a supplier's time. Before a
message leaves the accountable principal's control or enters a supplier-owned
inbox, the implementation **MUST** establish either:

1. a documented real-world need for the requested object;
2. an accountable buyer with authority to make the purchase;
3. genuine intent to purchase if the supplier returns acceptable terms; and
4. a plausible pre-approved budget envelope for the expected transaction;

or the supplier's explicit consent to participate in a disclosed research,
interoperability, or test exercise. Where compensation has been agreed for that
exercise, it **MUST** be disclosed and honored.

Learning whether a supplier can quote a package, collecting benchmark prices,
or creating adoption evidence is not by itself a buyer need. Software-origin
disclosure, quote-stage screening, and human review remain required where
applicable, but none substitutes for bona fide purchase intent or supplier
consent. A quote request consumes supplier labor even though it is not an
order.

An implementation **MAY** render local drafts, use reserved or sandbox
recipients, and exercise test providers without satisfying this gate, provided
those operations cannot enter a real supplier's systems. Such an artifact
**MUST NOT** be represented as externally contact-authorized. If the need,
buyer authority, intent, or budget ceases to exist before contact, the
implementation **MUST** stop the handoff. If it ceases after contact, the
accountable principal **SHOULD** close the exchange transparently and **MUST
NOT** solicit further work on that request.

### 7.2.2 Message structure

A conforming message **MUST** be `multipart/mixed` containing, in order:

1. **A `text/plain` part.** Written for a person, because a person opens it. It
   **MUST** state in its first sentence that the request was generated by
   software. It **MUST NOT** be the only place any quote-critical fact appears —
   a forwarding step that drops it must not lose data.
2. **The package**, as `application/json`, filename `a2a2p-request.json`,
   conforming to §7.1. This is the authoritative content. Where the prose and
   the JSON disagree, the JSON governs.
3. **Zero or more design files**, each as its own part with its declared media
   type, or referenced by URL inside the package when size forbids attachment.

An implementation **MUST NOT** place quote-critical fields (§7.1.1) only in the
prose part. An implementation **MUST NOT** require the recipient to parse the
JSON: a shop that reads only the prose and replies in prose is behaving
correctly, and the binding exists to make that possible, not to prevent it.

### 7.2.3 Headers

| Header | Requirement |
|---|---|
| `X-A2A2P-Origin` | **MUST** be present, value `automated_agent`. Machine origin is disclosed in the envelope, not only in the body, so filters and tooling can act on it without parsing prose. |
| `X-A2A2P-Profile` | **MUST** carry the profile identifier and version from §7.1. |
| `X-A2A2P-Screening` | **MUST** carry the screening verdict (`allow`, `flag`, `deny`). A message whose verdict is `deny` **MUST NOT** be sent. |
| `Reply-To` | **MUST** be an address monitored by the accountable principal of §7.1.2. It **MUST NOT** be an address that identifies a natural person where the principal is an organisation. |
| `Subject` | **SHOULD** state the part and quantity in plain words. It **MUST NOT** be machine-encoded; a subject line is read by a human deciding whether to open the message. |

**Sender identity is a conformance property, not a preference.** The `From`
address **MUST** belong to the accountable principal's domain, and the message
**MUST** authenticate as that domain (SPF and DKIM aligned, `DMARC` published).
A request that cannot be attributed to the principal it names has not met §7.1.2
however complete its JSON is. Implementations **SHOULD** enforce sender identity
in the sending tool rather than leaving it to per-message selection by an
operator, because a per-message choice is not a control.

Where the accountable principal is an organisation, the binding **MUST** carry
that organisation's verifiable registered address into the supplier package.
The sender domain and a role mailbox establish routing; they do not by
themselves establish the legal entity the supplier is being asked to trust.

### 7.2.4 What a reply means

The binding defines no reply format and **MUST NOT** require one. A supplier
replying in ordinary prose is a conforming reply.

An implementation **MUST NOT** treat any of the following as acceptance,
agreement, or an order: a reply, an out-of-office response, a read receipt, or
silence. §5.1's prohibition on inferring commitment applies to this binding
without exception.

### 7.2.5 Failure semantics

| Condition | Required behaviour |
|---|---|
| Message bounces | Record the failure against the supplier and the address. **MUST NOT** retry to a different address at the same organisation without human direction; address-guessing is what makes automated contact abusive. |
| No reply | Not a failure and **MUST NOT** be recorded as one. Silence from one supplier establishes nothing; the implementation **MUST NOT** infer refusal, capability, or unwillingness from it. |
| Reply requests human contact | A conforming outcome, not an error. The implementation **MUST** surface it to the accountable principal and **MUST NOT** auto-respond. |
| Recipient asks not to be contacted | The implementation **MUST** suppress that address permanently and **MUST NOT** require the request be repeated. |

### 7.2.6 Volume

An implementation **MUST NOT** send the same request to multiple suppliers in a
single message; each supplier receives its own. An implementation **SHOULD**
publish the maximum number of unsolicited suppliers it will contact for one
requirement, and **MUST NOT** treat this binding as a broadcast channel. A
protocol for reducing friction that produces unsolicited bulk mail has made the
supplier's day worse, which is the opposite of its purpose.

---

## 7.3 Screening ownership (normative for any implementation that fabricates)

§5.5 defines screening. This section defines **who is answerable for it**,
because a mechanism with no named owner is not a control.

An implementation that routes a request toward fabrication **MUST** publish,
before the first such request is routed:

1. **The mechanism.** What is actually checked, by what means. "AI review" and
   "human in the loop" name no mechanism. A published policy version and a
   resolvable policy URL are the minimum.
2. **The failure mode.** What the mechanism does not catch, stated in the
   affirmative. An implementation **MUST NOT** describe its screening only by
   what it catches. §5.5's limits — that pattern matching cannot infer end use,
   and cannot see across requests or assemble intent from components — are
   examples of the kind of statement required, not an exhaustive list.
3. **The owner.** A named accountable principal answerable when screening
   fails, satisfying §7.1.2. A legal entity is sufficient; a product name is
   not.

### 7.3.1 Inherited compliance is not owned screening

An implementation **MUST NOT** claim that a supplier's or platform's own
compliance layer satisfies this section. Export control, KYC, and sanctions
screening performed by a fabricator are an inherited second defence — genuinely
valuable, and not a substitute for the implementation's own duty. An
implementation that routes through a third party it does not control **MUST**
state which checks it performs itself and which it is relying on others to
perform.

This distinction is easiest to lose exactly where it matters most: when
fabrication capacity is reached through a platform in another jurisdiction, the
temptation is to treat that platform's compliance obligations as coverage. They
are that platform's obligations, discharged for that platform's reasons, and
they can change without notice.

### 7.3.2 Screening precedes capability

The rail precedes the capability it constrains. An implementation **MUST NOT**
activate a fabrication path before this section is satisfied for that path.
Satisfying it later is not remediation; the requests that flowed in between were
unscreened by an owner.

---

## 8. Versioning

Semantic versioning. Within a major version: fields MAY be added, vocabularies
MAY be extended, and no field MAY be removed or have its meaning changed.
Unknown fields MUST be ignored rather than rejected, so that a newer requester
and an older implementation continue to interoperate.

An implementation that returns engineering findings, completeness, or readiness
**MUST** identify every accepted extension field in its declared review scope
that it does not interpret. The report **MUST** use a documented,
canonical path encoding; name the field path without echoing its value; state
that the field was accepted but not interpreted; state whether it was used in
an engineering check; state the conservative readiness effect; and state
whether repair requires caller-supplied meaning. A path segment that may itself
contain private or content-bearing data **MUST** be redacted rather than echoed.

The implementation **MUST** publish the exact scopes it traverses and any
free-form subtrees it intentionally exempts. If reporting is bounded, it
**MUST** return an explicit overflow receipt that says how many accepted fields
were omitted; omission **MUST NOT** imply interpretation. Receipt order **MUST**
be deterministic for an identical requirement. A returned `quote_ready` or
`ready_to_resolve` grade **MUST NOT** remain unqualified while any accepted
field in the declared scope is reported as uninterpreted.

Readiness **MUST** be evaluated from the complete declared traversal before a
reporting bound is applied. The overflow receipt is itself a conservative
readiness gate: a field omitted from the bounded receipt array cannot disappear
from the grade calculation. An implementation **MUST NOT** determine readiness
from the length or contents of the bounded array alone.

If an implementation emits a human-readable finding for a consumption receipt,
that finding **MUST** be a generated projection of the receipt, not an
independent authority. It **MUST** preserve the receipt contract, version, kind,
path, and readiness effect and **MUST NOT** contradict them. The reference
implementation emits exactly one informational finding for each emitted
receipt, including the overflow sentinel.

A declared compatibility alias **MUST** target a canonical field that the
implementation actually consumes. Schema generation or verification **MUST**
fail when an alias target is absent; merely exempting an alias from unknown-field
reporting is not interpretation.

The implementation **MUST NOT** infer a physical conversion merely to make an
unknown field fit a known one. In particular, a mass in kilograms is not
silently a design load in newtons: support condition, acceleration, dynamic
effects, and the intended load case still belong to the requester or a bounded
engineering derivation.

This disclosure does not reject, delete, or semantically reserve an extension.
It is a consumption receipt: an HTTP success or readiness score cannot otherwise
tell a caller whether a supplied constraint actually participated in the result.
The reference implementation encodes paths as RFC 6901 JSON Pointers and bounds
the receipt array at 32 entries, reserving the final entry for an overflow
sentinel when necessary.

Vocabularies (`material`, `process`, `environment`, …) are extension points:
implementations MUST accept values outside the controlled list and SHOULD
indicate that a value was unrecognised rather than discarding it.

Silence is not compliance with that second half. An implementation that accepts
an unrecognised value, runs no check against it, and says nothing has told the
caller that everything was understood. The reference implementation did exactly
this until 2026-08-03: a submerged, chlorinated application declared three
environments, two were unrecognised, no environment check fired, and the review
returned zero findings — which reads as "nothing to worry about" and meant "two
thirds of that was not understood".

---

## 9. Design principles

Recorded because they explain the requirements above, and because implementers
facing a decision this document does not cover should decide the same way.

1. **Intent outlives specification.** Requirements change; the reason for them
   rarely does. Carry the "why" forward — every downstream substitution
   decision depends on it.
2. **Value on the first call.** An agent may not exist tomorrow. Anything of
   value delivered only asynchronously is, from a stateless caller's
   perspective, not delivered.
3. **Deterministic where possible.** Physical consequences follow from the
   response. Rules and cited data are auditable and repeatable; generated text
   is neither. Reserve generation for judgement, never for facts.
4. **Honest limits.** State what is measured versus assumed, computed versus
   quoted, known versus guessed. The protocol's value is that an agent can
   trust it, and precision about uncertainty is what earns that.
5. **Screening precedes capability.** Build the ability to refuse before the
   ability to fabricate. What a protocol brings into physical existence must be
   a net benefit to people; a capability that outruns its own restraint is a
   liability to everyone downstream of it.
6. **Open by construction.** The specification is public domain and
   implementable by anyone. Standards win by being adopted, not by being owned.

---

## 10. Reference implementation

**a2a2p.com** — MCP endpoint `https://a2a2p.com/mcp` (no authentication),
REST under `/api/`, published screening policy at `/policy`, this document at
`/spec`, and the versioned CC0 conformance kit at `/conformance`. The
specification and conformance kit are the public protocol distribution; the
reference implementation's source repository is not required to implement or
verify the protocol.

Implementations of this specification, conformance reports, and proposed
revisions are welcome: hello@a2a2p.com
