The host checks per-frame attestations only; a signed result set and its inclusion proofs are consumed by nothing

[macanderson]

Problem

contextgraph_types::attest defines three constructions (SPEC.md §6.5): a
provenance chain head, a per-frame commitment, and an RFC 6962 Merkle root
over a whole result set with InclusionProofs. The host now consumes the
second. It consumes neither merkle_root nor root_from_proof.

That leaves the headline use case from ADR 0010 unreachable through the host:
"prove this frame was in the answer, without showing me the rest." A provider
that signs its whole answer once — cheaper than N signatures, and the only
construction that supports selective disclosure — gets no credit: every frame
reads as AttestationState::Unattested.

What is needed

• contextgraph_host::trust learns a result-set shape: one
  ProvenanceAttestation over a merkle_root, plus one InclusionProof per
  frame. Verify the root's signature once, then check each frame's inclusion
  proof against it, and record the outcome as the existing AttestationState
  so the audit does not grow a second vocabulary.
• The same F9 discipline: a bad root, a bad proof, or a proof from a
  differently-shaped tree degrades the frame to unattested and never removes it.
• The same bounded-work discipline: cap proof path length (a proof for a tree of
  N leaves has ceil(log2(N)) steps; anything longer is malformed and must be
  refused on its length before any hashing), and verify the root signature once
  per result rather than once per frame.

Constraints found while wiring the per-frame path

• Attestations reach the host through ContextProvider::query_attested
  (contextgraph-host/src/provider.rs), a defaulted trait method returning
  AttestedQueryResult. A result-set attestation is a second field on that
  struct, not a second method.
• The wire cannot carry either shape yet — see Carry ProvenanceAttestation on the wire (frames envelope + JSON Schema) #90.
• InclusionProof::leaf_count is part of the proof precisely so a verifier
  cannot be shown a proof from a differently-sized tree; a host implementation
  that ignores it has the bug the field exists to prevent.

Files

• contextgraph-host/src/trust.rs
• contextgraph-types/src/attest.rs — merkle_root, inclusion_proof, root_from_proof
• contextgraph-host/tests/attestation_composition.rs — where the tests go

Definition of done

• A host verifying a result-set attestation marks each proven frame
  attested, through the same AttestationState and the same audit field.
• A test proves a frame with a valid inclusion proof under a signed root is
  attested, and one with a proof from a differently-shaped tree is not.
• A test proves F9 holds: a malformed root or proof leaves every frame
  served.
• The root signature is verified once per result, not once per frame, and a
  test or a comment naming the bound says so.

[macanderson]

The wire shape this needs has landed in #138 (ADR 0014, SPEC.md §6.5.5). Concretely, what a host now has to consume:

• result.result_attestation — a ProvenanceAttestation whose signed_commitment is the §6.5.3 Merkle root over the commitments of exactly the frames in result.frames, in canonical FrameId order. contextgraph_types::attest::result_set_root(provider_id, &result.frames) recomputes it; verify_commitment checks the signature.
• result.frame_attestations[].inclusion_proof — optional. root_from_proof(&commitment, proof) recomputes the root from one leaf. Note proof.leaf_count must equal result.frames.len(), or the proof came from a differently-shaped tree.

#138 also adds F13, which is a host obligation nothing mechanically checks and which belongs in this issue's scope:

A host that retains a strict subset of a signed result set MUST derive and retain the proofs for the frames it keeps before dropping the rest.

That is the part that is easy to get wrong silently. Once composition drops a frame, its commitment is gone and the root can never be recomputed — so a host that filters first and thinks about evidence later has destroyed it, and every later check reports "unverifiable" rather than "the host lost it". Wiring verification into composition without also handling this ordering would make the feature look wired while quietly failing for every result the host does not keep whole.

A host-side conformance scenario for the retain-then-filter ordering would be the check. contextgraph-conformance/tests/attestation_wire.rs has the verification helpers and a positive-control shape (a_tampered_frame_is_caught_as_a_commitment_mismatch_not_a_bad_signature) to build one from.