---
slug: process-attestation
version: "0.1"
title: "Process Attestation"
summary: "Evidence that an artifact was produced through a captured process, attested by the party that captured it and bound to a Verifier-supplied challenge."
status: draft
targetFrameworkVersion: "0.5.0"
category: provenance
keywords: [process, attestation, provenance, authorship, evidence]
authors:
  - David L. Condrey (https://github.com/dcondrey)
knownImplementations:
  - https://github.com/LF-Decentralized-Trust-labs/proof-of-effort
  - url: https://writersproof.com
    role: Holder
    name: WritersProof
parties:
  - role: Verifier
    requirement: REQUIRED
    member: issuer
    identifierScope: any
  - role: Holder
    requirement: REQUIRED
    member: recipient
    identifierScope: any
proofRequirement:
  request: OPTIONAL
  response: REQUIRED
  rationale: >-
    A response is retained by the Verifier as evidence and may be relied upon
    after the transport that carried it has closed, which is the condition under
    which SPEC §4.7.1 makes a proof mandatory. The request carries no authority
    and is protected against replay by the challenge it supplies, so requiring a
    proof on it would make the task unreachable on bindings whose integrity is
    out-of-band without buying a property the challenge does not already give.
issuedAtRequirement:
  requirement: REQUIRED
  rationale: >-
    The response is evidentiary and its anti-replay property depends on placing
    it in a bounded window alongside the challenge. A response that cannot be
    placed in time leaves a Verifier no window in which duplicate-execution
    protection is implementable.
sideEffects:
  level: none
  rationale: >-
    A read of evidence about an event that has already happened; it persists no
    state at the recipient.
exposure:
  discloses: metadata
  actsAsSubject: false
  ingests: metadata
  rationale: >-
    Returns derived aggregates only: a determination and its confidence, the
    artifact binding, session timeline bounds, integrity state, and any external
    timestamp anchors. Raw behavioral sample data and behavioral fingerprints are
    out of scope for this version; a profile that discloses them is disclosing
    `secret` material and is a different classification. The request carries an
    artifact identifier, which may itself reveal that a Verifier is interested in
    a specific document.
retention:
  class: durable
  rationale: >-
    A Verifier retains the response as its record of the determination it relied
    on, and the value of that record is precisely that it outlives the exchange.
outcomeEvidence:
  response: https://trusttasks.org/spec/process-attestation/0.1#response
  binding:
    challenge:
      initiating: /payload/challenge
      response: /payload/challenge
  rationale: >-
    A Verifier retains the response as its record that an attestation exchange
    about this artifact completed, and a credential or record the Verifier
    issues, such as an authorship credential's `taskContext` or the Verifier's
    own audit record, may cite it. The response reproduces, under the Holder's proof, the
    challenge the request freshly supplied. The challenge form is permitted
    (SPEC §7.3 item 20.5.2) because this specification requires the citing
    artifact to be issued by the request's `issuer`, the Verifier that minted
    the challenge (the outcome-evidence rule under Response), so a relying party
    already depends on that Verifier for what the artifact states.
maxDocumentBytes:
  response: 294912
  rationale: >-
    The largest member a response can carry is an inline receipt,
    `receiptReference.data`, bounded at 262144 characters of base64url text. The
    rest of the document (artifact, challenge, assessment, disclosed aggregates
    and the proof) is expected to fit in the remaining 32 KiB; the schema does
    not bound every member, and a document over the bound does not conform. A
    receipt larger than the inline bound MUST use the `uri` form, so no chunked
    transfer is needed.
errorCodes: []
related:
  - trust-ceremony-receipt
  - trust-task-error
---

## Abstract

This specification defines a Trust Task for verifying that an artifact was produced
through a captured process, with cryptographic evidence bound to the act of
production rather than to a downstream claim about the producer.

The Trust Task standardizes the request and response interaction and the Holder's
cryptographic commitment to the response. It does **not** define the receipt format,
the capture primitive, or the cryptography the receipt uses. Those remain the
concern of the underlying primitive and are verified independently under that
primitive's own specification.

## Status of this Document

Draft. Targets framework 0.5.0.

## What the Holder does and does not attest

A conforming response attests that the Holder possesses a process-attestation
receipt that the Holder associates with the identified artifact, and that the
response was produced by the Holder in reply to the supplied challenge.

It does **not** attest that:

- the receipt is cryptographically valid. A Verifier MUST obtain and verify the
  receipt under its own specification;
- the determination the receipt carries is correct;
- the artifact is unmodified since production, beyond whatever binding the
  `artifact` member's digest establishes;
- any particular person operated the process.

A valid envelope `proof` establishes that the response came from the claimed
Holder. It establishes nothing about the receipt. These are separate layers and a
Verifier MUST evaluate both before treating a determination as attested.

## Conformance

A conforming Holder:

1. MUST reply to a `#request` document with either a `#response` document or a
   `trust-task-error` document.
2. MUST echo the request's `challenge` and `artifact` verbatim in the response
   payload, on both `attested` and `unavailable` results.
3. MUST set `result` to `unavailable` where it holds no receipt for the identified
   artifact, and MUST NOT distinguish that case from a refusal to disclose at the
   envelope level.
4. MUST NOT return a disclosure category the request did not ask for.
5. MUST NOT include `assessment`, `receiptReference` or `disclosed` when `result`
   is `unavailable`.
6. MUST attach a `proof` to the response.
7. SHOULD include `digestMultibase` in a `uri` receipt reference, computed over
   the exact bytes the URI serves.

A conforming Verifier:

1. MUST NOT treat a response as authoritative unless `proof.verificationMethod`
   resolves to verification material controlled by the claimed `issuer` under a
   resolution mechanism the Verifier's trust framework accepts.
2. MUST treat a response whose `challenge` does not match the one it supplied as
   unverifiable, regardless of proof validity.
3. MUST treat a response whose `artifact` does not match the one it supplied — both
   `digest` and `algorithm`, compared exactly — as unverifiable, regardless of proof
   validity.
4. MUST verify the referenced receipt under the receipt's own specification before
   relying on `assessment`, and MUST NOT rely on `assessment` unless the receipt
   binds the same artifact the request identified.
5. MUST NOT infer from `unavailable` that no receipt exists.
6. MUST, where `receiptReference.digestMultibase` is present, compare it against
   the digest of the receipt bytes it dereferences before relying on them, and
   MUST treat a mismatch as unverifiable.
7. MUST NOT treat the `integrity` disclosure category as verification of the
   receipt. Its members are the Holder's own report of its receipt's state; rule 4
   is what verifies the receipt.

## Authorization

This task is not *consequential* under [SPEC §3](/SPEC.md#3-terminology), so
[SPEC §7.3 item 15](/SPEC.md#73-specification-requirements) does not bind it. This
section is carried anyway because the layering below is easy to get wrong, and its
presence is not a conformance claim.

The Holder's authority to respond is possession of the receipt. There is no
registry, governing body, or third-party intermediary in the interaction, and no
authority statement is consulted. A Holder MAY delegate response handling to a
service it controls, provided the binding between the response `proof` and the
Holder's identifier is preserved.

The envelope `proof` is not the authorization. It establishes that the response is
attributable and unaltered, which is what makes the later comparison against the
receipt possible; it does not entitle the Holder to any outcome, and it says nothing
about whether the receipt is valid. Where a Verifier applies policy, accepting some
Holders and not others or requiring a particular capture primitive, that policy is
the Verifier's and is out of scope here.

## Definitions

**Artifact.** The object whose production is in question, identified by a digest.

**Receipt.** Evidence produced by a capture primitive at the time of production,
independently specified and independently verifiable.

**Capture primitive.** The system that produced the receipt. Named in the response
so a Verifier knows which specification to verify the receipt under.

**Disclosure category.** A named group of derived fields a Verifier may request.

## Request

Produced by the Verifier and sent to the Holder. Described by the top-level schema
in [`payload.schema.json`](payload.schema.json).

The Verifier identifies an artifact by digest, supplies a fresh `challenge`, and
names the disclosure categories it wants. A Holder MAY return fewer categories than
requested; it MUST NOT return more.

### Requesting a determination with timeline detail

```json
{
  "id": "9f1c3a72-5e4b-4c8a-9d21-7b6e0f3a1c58",
  "type": "https://trusttasks.org/spec/process-attestation/0.1#request",
  "issuer": "did:web:verifier.example",
  "recipient": "did:web:author.example",
  "issuedAt": "2026-09-09T14:02:11Z",
  "threadId": "1c9d4e60-8a2f-4b13-bd77-2e5a6c0918af",
  "payload": {
    "artifact": {
      "digest": "hcHFbGVGLXVQqZ8mRk2vN4pT7sYwD1jB6xK0aC3eI9M",
      "algorithm": "sha-256"
    },
    "challenge": "9tKpX2mQzR7vLbN4hJ8cWfA6dY0sE5uT3gO1iZ",
    "disclosure": ["document", "timeline"]
  }
}
```

## Response

Produced by the Holder, which is the recipient of the request. Described by the
sub-schema reachable via `$anchor: "response"` in
[`payload.schema.json`](payload.schema.json).

The payload members:

- **`result`** is `attested` or `unavailable`. Both use the same response type, so
  the envelope carries no observable distinction between them.
- **`challenge`** is the request's challenge echoed verbatim. It is what binds this
  response to this Verifier's question.
- **`artifact`** repeats the requested digest, so the response stands alone as a
  record without the request beside it. It is not decoration: a Verifier MUST
  compare it against the artifact it asked about (Verifier rule 3), because a
  response is otherwise free to answer about an artifact nobody asked about.
- **`assessment`** is present only when `result` is `attested`. It is opaque at the
  task layer: `primitive` names the specification a Verifier must verify the receipt
  under, and `determination` belongs to that primitive's vocabulary. This
  specification deliberately does not normalize determinations across primitives,
  because a determination means only what the primitive that produced it defines it
  to mean.
- **`receiptReference`** is present only when `result` is `attested`. It is a tagged
  union of `uri` and `inline`; `inline` exists for Verifiers that cannot dereference
  a URI at verification time and is bounded accordingly. The `uri` form SHOULD
  carry `digestMultibase`, the digest of the receipt bytes the URI serves: the
  response's proof covers the URI, not what the URI serves, so without it the
  retained response cannot later show which receipt it referred to (Verifier
  rule 6). A response carrying an inline receipt is bounded at 294912 bytes
  ([SPEC §7.3 item 21](/SPEC.md#73-specification-requirements)); the front matter
  declares it, and a consumer MUST NOT refuse a smaller response on size alone.
- **`disclosed`** carries the requested categories, and only those.

`unavailable` is a task-level **result**, not the [SPEC §8.3](/SPEC.md#83-standard-error-codes)
error code that shares its spelling. A result travels in a `#response` document and
means the Holder answered; the error code travels in a `trust-task-error` document
and means it did not. Do not map one onto the other.

A Verifier's retained response is this exchange's *outcome evidence*
([SPEC §4.9.4](/SPEC.md#494-evidence-that-a-cited-exchange-completed)). The front
matter declares how it is bound to the request: the response reproduces, under the
Holder's proof, the `challenge` the request freshly supplied
([SPEC §7.3 item 20](/SPEC.md#73-specification-requirements)). A credential or
record that cites this exchange names the request's `id` and relies on that
reproduction; sharing a `threadId` is not a binding.

Only the Verifier vouches for the challenge's freshness: it could reuse a
challenge with a `threadId` and present one exchange's response as the outcome of
another. A credential or record that cites this exchange as evidence of completion
MUST therefore be issued by the party that issued the request, and a relying party MUST
NOT treat this response as outcome evidence for a citing artifact whose issuer is
not the request's `issuer`. A party other than the Verifier that wants to cite an
attestation runs the task itself, as its own Verifier.

Malformed requests, unsupported versions, and a missing required proof are answered
with `trust-task-error` carrying the standard §8.3 codes (`malformedRequest`,
`unsupportedVersion`, `proofRequired`), not with a `#response` document. This
specification defines no extended error codes of its own.

### An attested response

```json
{
  "id": "4b8e1f05-6c3d-42a9-8e71-0d5f2a7c91b3",
  "type": "https://trusttasks.org/spec/process-attestation/0.1#response",
  "issuer": "did:web:author.example",
  "recipient": "did:web:verifier.example",
  "issuedAt": "2026-09-09T14:02:14Z",
  "threadId": "1c9d4e60-8a2f-4b13-bd77-2e5a6c0918af",
  "payload": {
    "result": "attested",
    "challenge": "9tKpX2mQzR7vLbN4hJ8cWfA6dY0sE5uT3gO1iZ",
    "artifact": {
      "digest": "hcHFbGVGLXVQqZ8mRk2vN4pT7sYwD1jB6xK0aC3eI9M",
      "algorithm": "sha-256"
    },
    "assessment": {
      "primitive": "https://lf-decentralized-trust-labs.github.io/proof-of-effort/profiles/rats-eat-profile-pop-1.0.json",
      "determination": "authentic"
    },
    "receiptReference": {
      "type": "uri",
      "uri": "https://evidence.author.example/r/4b8e1f05.cpoe",
      "mediaType": "application/cpoe+cbor",
      "digestMultibase": "zQmetCf1LCufxasVAmp4cSBLsbD7wdQJkj6wxFjc3Mkhnuy"
    },
    "disclosed": {
      "document": {
        "mediaType": "text/markdown"
      },
      "timeline": {
        "startedAt": "2026-09-08T09:14:02Z",
        "endedAt": "2026-09-08T11:47:35Z",
        "checkpointCount": 41
      }
    }
  },
  "proof": {
    "type": "DataIntegrityProof",
    "cryptosuite": "eddsa-jcs-2022",
    "created": "2026-09-09T14:02:14Z",
    "verificationMethod": "did:web:author.example#key-1",
    "proofPurpose": "authentication",
    "proofValue": "z4oey6cnBVUCyx9YKvQZ8mR2vN4pT7sYwD1jB6xK0aC3eI9Mh"
  }
}
```

### An unavailable response

Returned where the Holder has no receipt for the artifact **and** where it declines
to say. A Verifier cannot distinguish the two, by design.

```json
{
  "id": "7d2a9c41-3f8b-4e05-a6d9-1b4c8e07f52a",
  "type": "https://trusttasks.org/spec/process-attestation/0.1#response",
  "issuer": "did:web:author.example",
  "recipient": "did:web:verifier.example",
  "issuedAt": "2026-09-09T14:02:14Z",
  "threadId": "1c9d4e60-8a2f-4b13-bd77-2e5a6c0918af",
  "payload": {
    "result": "unavailable",
    "challenge": "9tKpX2mQzR7vLbN4hJ8cWfA6dY0sE5uT3gO1iZ",
    "artifact": {
      "digest": "hcHFbGVGLXVQqZ8mRk2vN4pT7sYwD1jB6xK0aC3eI9M",
      "algorithm": "sha-256"
    }
  },
  "proof": {
    "type": "DataIntegrityProof",
    "cryptosuite": "eddsa-jcs-2022",
    "created": "2026-09-09T14:02:14Z",
    "verificationMethod": "did:web:author.example#key-1",
    "proofPurpose": "authentication",
    "proofValue": "z3xKp7mQzR2vLbN9hJ4cWfA6dY0sE5uT8gO1iZBVUCyx9"
  }
}
```

### The failure path

A request the Holder cannot parse is answered with `trust-task-error`, paired to the
request by `threadId`. Here the `challenge` fell below the 16-character floor, so the
request never reached task semantics and no `#response` document is produced.

```json
{
  "id": "c05f9a3b-71d4-4e28-9a6f-3e8b0d52147c",
  "type": "https://trusttasks.org/spec/trust-task-error/0.6",
  "issuer": "did:web:author.example",
  "recipient": "did:web:verifier.example",
  "issuedAt": "2026-09-09T14:02:12Z",
  "threadId": "1c9d4e60-8a2f-4b13-bd77-2e5a6c0918af",
  "payload": {
    "code": "malformedRequest",
    "message": "challenge is shorter than the 16-character minimum",
    "retryable": true
  }
}
```

`retryable` is `true` because the Verifier can reissue with a conforming challenge.
A Verifier MUST NOT read this as `unavailable`: an error means the Holder did not
answer the question, not that it has no receipt.

## Profile: CPoE

This section is informative. It states how a Holder whose capture primitive is
Cryptographic Proof of Effort (CPoE — the `proof-of-effort` specifications and
the WritersProof implementation) fills the members this specification leaves to
the primitive, so that two implementations of this task over CPoE agree.

**`assessment.primitive`** is
`https://lf-decentralized-trust-labs.github.io/proof-of-effort/profiles/rats-eat-profile-pop-1.0.json`,
the profile under which a CPoE attestation result is issued, published by the
LF Decentralized Trust `proof-of-effort` project. The document is
dereferenceable and self-describing. The `urn:ietf:params:` identifiers the CPoE
drafts name are not registered and are not used here.

**`assessment.determination`** is the attestation result's verdict: one of
`authentic`, `inconclusive`, `suspicious` or `invalid`. The six-value forensic
ladder a CPoE verifier computes internally is not a wire vocabulary — its top
rung is unreachable for a third-party verifier — and a Holder does not carry it
here. `assessment.confidence` is omitted: CPoE defines no numeric confidence for
a verdict.

**`receiptReference`** names one of two objects, told apart by `mediaType`:

| Receipt | `mediaType` | Extension | What a Verifier verifies |
|---|---|---|---|
| Evidence packet | `application/cpoe+cbor` | `.cpoe` | The packet under the CPoE protocol specification; the Verifier appraises it itself. |
| C2PA manifest store | `application/c2pa` | `.c2pa` | The manifest's claim signature and its hard binding to the artifact, with the evidence carried in a `com.writerslogic.process-proof` assertion (the label proposed to CAWG as `cawg.process-proof`). Preferred where the Verifier already runs a C2PA validator: the hard binding establishes that the receipt binds the artifact asked about (Verifier rule 4) without parsing CPoE. |

A Holder serving the `uri` form sets `digestMultibase` over the bytes served
(Holder rule 7).

**An artifact that carries its own receipt.** A text document with a proof block
appended, or a file with an embedded C2PA manifest, is delivered with its manifest
inside it. `artifact.digest` is then over the delivered bytes, block included, and
the Holder presents the extracted manifest store as the `application/c2pa` receipt.
Verifier rule 4 is discharged by the manifest's hard binding — `c2pa.hash.data`
with the block's range excluded — and not by comparing the receipt's digest with the
artifact's. The evidence packet inside that manifest commits to the document text
without the block, so for such an artifact the packet on its own is not the receipt.

**Disclosure categories** map as follows:

| Category | Members | CPoE source |
|---|---|---|
| `document` | `mediaType` | The media type recorded for the tracked document. |
| `timeline` | `startedAt`, `endedAt`, `checkpointCount` | The packet's session start, its creation instant, and its checkpoint count. |
| `integrity` | `chainValid`, `signatureValid`, `keyCustody` | The Holder's own appraisal of the checkpoint chain and packet signature, and the custody of the signing key: `software` for a software-only key, `tpm` for a TPM-resident key, `secureEnclave` for an Apple Secure Enclave key. A report, not a verification (Verifier rule 7). |
| `anchors` | `kind`, `anchoredAt` | One entry per external time anchor: `rfc3161` for a timestamp-authority response, `opentimestamps` for an OpenTimestamps proof, `roughtime` for a Roughtime sample, `blockchain` for a direct chain anchor. |

Raw behavioural samples, keystroke timing and behavioural fingerprints never
leave the Holder — the same commitment the CPoE evidence packet and the
`com.writerslogic.process-proof` assertion make.

## Security & Privacy

### Data carried

The request carries an artifact digest, a challenge, and a list of category names.
The response carries a determination, a receipt reference, and the derived
aggregates for the requested categories.

Disclosure categories in this version return derived values only: `document` (the
artifact's media type), `timeline` (session bounds and checkpoint count),
`integrity` (chain and signature state), and `anchors` (external timestamp
anchors). The determination is not a category, because `assessment` already
carries it on every attested response; making it one would put the same value in
two places and invite them to disagree.

The artifact's byte length is not a category either, for the same reason and by
the same rule: `artifact.byteLength` already carries it on every response, so a
`document.byteLength` beside it would be a second copy with no defined
tie-breaker when the two disagree. `document` carries only what `artifact` does
not.

Raw behavioral sample data, behavioral fingerprints, and per-region edit topology
are **out of scope for this version**. A capture primitive that holds such data MUST
NOT return it under these categories. Disclosing it is disclosing `secret` material
under [SPEC §7.3 item 14](/SPEC.md#73-specification-requirements), which makes the
task consequential and changes what a consumer is obliged to do; a profile that
needs it is a different specification with a different classification, not a
category added to this one.

### Substitution of the attested artifact

The `challenge` binds a response to one Verifier's request, but it does not by
itself bind the response to the artifact that request asked about. A Holder that
holds a receipt for artifact B and none for artifact A can, without forging
anything, answer a request about A with `result: "attested"`, `artifact: B`, and a
genuinely valid receipt for B. Every signature in that exchange verifies: the
envelope proof is the Holder's, the challenge is the one the Verifier sent, and the
receipt is authentic under its own primitive. Only the subject has been swapped.

Verifier rules 3 and 4 are what close this. Rule 3 rejects the response before the
receipt is ever fetched, and rule 4 catches the case where the response echoes A
faithfully but the receipt underneath binds B. Neither is expressible in the payload
schema, because the request is not in the response document's scope — a Verifier
that validates the schema and the proof and stops has not performed the comparison.

### Correlation

A stable Holder signing key correlates every response that key signs. Where a Holder
responds to many Verifiers about many artifacts, that is a linkage surface across
all of them. This version does not define an unlinkability mechanism; a profile that
needs one defines the key strategy and verification semantics without altering the
task semantics here.

This specification is **not** `bearer`. `trust-ceremony-receipt` is, because a
ceremony receipt is a public record of a completed flow that any party verifying the
proof may legitimately rely on. A process-attestation response is scoped to the
challenge one Verifier supplied, and accepting it audience-free would expose it to
cross-recipient replay under [SPEC §12.1](/SPEC.md#121-cross-recipient-replay): a response obtained
by one Verifier could be presented to another as though freshly obtained.

The artifact digest in a request may itself be sensitive. Where the existence of a
receipt for a given artifact is confidential, a Holder SHOULD require an
authenticated request as local policy, and the `unavailable` conflation above is
what keeps refusal indistinguishable from absence.

### Retention

A Verifier retains the response as its record of the determination. It is `durable`
by nature; a Verifier that does not need a durable record SHOULD discard it once its
decision is made, because a retained response is a retained correlation.

### Consent/purpose

This specification states what authority the task assumes and does not oblige any
consumer to authorize anything. Whether a Holder responds at all, and to whom, is
Holder policy under its own governance framework.
