@@ 4.11.  Nesting and Cross-Service Links
H 4.11.  Nesting and Cross-Service Links

P A record links steps and runs in three ways: a step called inside another step of the same run, a run opened inside a step of another run in the same process (Section 4.11.1), and a run started by a request from another service (Sections 4.11.2 and 4.11.3).  The last is apart from the first two: it is recorded in a receipt of each side, and the manifest holds only copies.

H 4.11.1.  Steps and Runs in One Process

P A stage may run inside another stage of the same run: a step the pipeline's code calls from within a step.  The receipt of such a step MAY carry "parent", a string: the node id of the step that called it.  The caller's receipt MAY carry "children", an array of strings: the node ids of the steps it called, in call order.  A node id is the stage's "name", followed by "#" and the stage's instance where the receipt's "stage" records one as "instance".  Both members are absent at the top level and on a step that called nothing.

P Nesting records structure, not data.  A child's return that the caller used in its own work is not recorded as one of the caller's inputs.  Section 4.18 records the one thing a producer can observe at the caller's end.

P A run opened inside a step of another run, in the same process, is a nested run.  Its manifest carries "parent_run" and "parent_stage", strings: the enclosing run's "run_id" and the node id of the step it was opened in.  The enclosing step records the nested run's chain head as one entry of its "inputs" whose "name" is "run:" followed by the nested run's "run_id" and whose "digest" is that chain head, in the form of Section 4.20.  A manifest with "parent_run" and "parent_stage" whose first receipt holds no "parent_link" is a nested run in this sense.

H 4.11.2.  The Cross-Service Link

P A run started by a request from another service records the link in its own first receipt, and the step that sent the request records the call in its receipt.  Two records under two chains then name each other, and the manifest's copies are read only where they equal the receipts.  The members are:

D parent_link: An OPTIONAL object on the callee's first receipt only.  Either it holds "run" (the caller's "run_id"), "stage" (the node id of the calling step), "head" (the caller's chain head when the request was sent), "origin" (the origin run id, as received, below) and, where the request carried a well-formed "traceparent" field, "traceparent"; or it holds "status" alone, "unreadable: " followed by the parse rule's words (Section 4.11.3), where the "onetrace-parent" field was present and did not parse.

D parent_run, parent_stage, origin_run: Members of the callee's manifest: copies of "parent_link.run", "parent_link.stage" and "parent_link.origin", read as a cross-service link only where the first receipt holds a "parent_link" that equals them (Section 6).

D calls: An OPTIONAL array on the calling step's receipt, one entry for each call, in call order.  Each entry holds "status", and "traceparent" where one was sent; an entry whose "status" is "head returned" also holds "child_run" (the callee's "run_id") and "child_head" (the callee's chain head as the response gave it), and no other entry holds either.

P "calls[].status" is exactly one of:

B "head returned": the response held a readable "onetrace-child" field;

B "called, head not returned": the request was sent, and the response held no such field;

B "unreadable: <reason>": the response's field did not parse, by the rules of Section 4.11.3;

B "not sent: <reason>": no field was sent, with the reason "longer than 1024 bytes" or "host not on ONETRACE_PROPAGATE" (Section 16).

P A call never guesses a head.  In the record, a head is a chain digest: "parent_link.head" and "calls[].child_head" are "sha256:" followed by the 64 hexadecimal digits the field carried, so they compare as strings with the digests of Section 6, or the one character "-" where the field carried "-".

P *The origin.*  The origin is the "run_id" of the run where the whole request started, copied unchanged to every hop.  A caller sends, as the origin: the "origin" of its own run's "parent_link", where it has one; otherwise, for a run nested in-process (Section 4.11.1), the origin of its in-process parent, by the same rule, up to the outermost run; otherwise its own "run_id".  A run with no parent of either kind is its own origin.  A run with no "parent_link" writes neither "parent_link.origin" nor "origin_run".  A producer refuses a parent given to it by hand without an origin, naming the field.

P *"calls" is not an input.*  A callee's run id and head differ on every call, so as an input they would make the calling step differ in every comparison.  An entry of "calls" is not one of the step's inputs, and the two fields of Section 4.11.3 are not recorded among a step's HTTP inputs, so they read as no difference.

P *What a callee takes from the field.*  A field is a claim from whoever sent the request.  Its values go only into "parent_link".  They name no file, no folder and no run id of the callee's.

P *When a head goes back.*  The callee sets "onetrace-child" when the response starts, and only on a request that carried "onetrace-parent", so a run id is not given to every caller.  A response's fields are sent before a streamed body ends and before the request's run closes, so the head a caller receives is usually an earlier receipt of the callee's chain, not its final head.  The check below reads it as such.

P *The check.*  A verifier that implements minor 5 reads a link only between folders it is given, and reports one row, "linked runs match", for each linked run it holds, read from the caller's side and from the callee's.  It reports PASS with one of:

V      <child run>: names <caller run> at <step>, and its head is the
V        head returned, origin <origin run>
V      <child run>: names <caller run> at <step>; the head returned is
V        its receipt <n> of <m>, origin <origin run>
V      <child run>: names <caller run> at <step>; it held no receipt
V        when the response started, origin <origin run>

P each one line, shown here on two.  The second is for a callee that wrote more receipts after the response started; the third is for a "child_head" of "-".  It MUST fail:

B "<child run> names <run> at <stage>, not <caller run> at <step>";

B "the head returned is not in <child run>'s chain";

B "the head <caller run> gave is not in its own chain", on a "parent_link.head" other than "-", where both folders are held;

B "<child run> names origin <x>, but <caller run>'s origin is <y>", where both folders are held: a caller's origin is its own "parent_link.origin", or, where it has none, the origin the rule above gives it, read for a nested caller as below;

B "<child run> names <caller run> at <step>, and <caller run> holds no call to it", read from the callee's side, where the caller's folder is held and holds no "calls" entry at that step;

B "the first receipt's parent_link holds no origin", on a "parent_link" that holds "run", "stage" and "head" and no "origin"; and "parent_link.origin <value> is not a run id", where its "origin" is not a run id: here a run id is any non-empty string;

B a manifest's "origin_run" that differs from the first receipt's "parent_link.origin", and any other copy of Section 6 that differs from the receipt it copies;

B a "calls" entry out of form: a "status" outside the four, "child_run" or "child_head" on any status but "head returned", or either missing on it, or a head that is neither "sha256:" followed by 64 lowercase hexadecimal digits nor "-".

P It reports NOT RUN, with the reason "<child run>: its folder was not given"; "<step>: called, head not returned"; "<step>: unreadable: <reason>"; "<step>: not sent: <reason>"; and "no link recorded", only where a linked run was given.  A "parent_link" that holds "status" alone has no origin to check, and reads NOT RUN with its status.  A run with no link, checked with no linked run given, gains no row.

P *The origin of a nested caller.*  Where the caller is a run nested in-process and holds no "parent_link", a verifier reads its origin from the outer run's folder, where the check is given it, by the rule above; otherwise, the origin's check reads NOT RUN, with the reason "<child run>: <caller run>'s origin is its outer run's, and <outer run>'s folder was not given".  A nested run's manifest does not carry its origin: "origin_run" is written only with a "parent_link".

P What a link does not show:

B A cross-service link shows that two records agree on their parent and child.  It does not show the services ran as recorded, or that the network delivered the request unaltered.

B The parent link is a claim from the request's sender until the caller's record is held and agrees.

B A head returned is one receipt of the callee's chain at the response's start.  It is not the callee's final head, and it says nothing about what the callee did after.

B A service that does not record, or a proxy that strips a field, is a gap the record shows as a gap: "called, head not returned".

B A link and a recorded trace id are equality of recorded values.  They say nothing of how one service's work affected the other's.

B The origin is what the chain of callers sent.  Where every folder is held and agrees, the records agree on where the request started.  That does not show the origin run was not itself called by a service that does not record.

H 4.11.3.  The HTTP Fields

P The link travels in two HTTP fields, each sent as one field line, in ASCII.  Their names are written in lowercase here and are case-insensitive on the wire:

V      onetrace-parent: 1.<run>.<stage>.<head>.<origin>
V      onetrace-child:  1.<run>.<head>

D 1: The version, exactly the one byte "1".

D <run>: The run id's UTF-8, in base64url with no padding [RFC4648], Section 5.

D <stage>: The calling step's node id's UTF-8, encoded in the same way.

D <head>: The chain head at that moment: the 64 lowercase hexadecimal digits of its digest, without "sha256:"; or the one byte "-" where the run has no receipt yet.

D <origin>: The origin run id's UTF-8 (Section 4.11.2), encoded as <run> is.

P A run id can hold ":" and ".", and a node id almost any character, so both are sent encoded; "." is not in the base64url alphabet.  For a first hop from run "r-1", step "approve_payment#2", a head of 64 hexadecimal digits written here in part, the caller's own run being its origin:

V      onetrace-parent: 1.ci0x.YXBwcm92ZV9wYXltZW50IzI.abab...abab.ci0x

P and the callee's answer, for its run "r-2":

V      onetrace-child: 1.ci0y.cdcd...cdcd

P In ABNF [RFC5234]:

V      onetrace-parent = "1" "." b64u "." b64u "." head "." b64u
V      onetrace-child  = "1" "." b64u "." head
V      b64u            = 1*( ALPHA / DIGIT / "-" / "_" )
V      head            = 64( DIGIT / %x61-66 ) / "-"

P A field value is at most 1024 bytes.  A producer leaves out a field it would make longer, and records "not sent: longer than 1024 bytes" on the step's call.  A reader checks the length before it decodes anything.

P A reader applies the following rules in order.  Each failure gives "parent_link.status", or on a response "calls[].status", "unreadable: " followed by the rule's words.  A parse failure never raises and never fails a request.

N 1. More than one field line, or a value with a comma: "more than one value".

N 2. Longer than 1024 bytes after optional whitespace is trimmed, counted in UTF-8 bytes after the field's bytes are read as Latin-1, as HTTP/1.1 carries them, so a byte of 0x80 or above counts two: "longer than 1024 bytes".

N 3. What comes before the first "." is not "1": "version " followed by its first 8 bytes, escaped: a printable ASCII byte other than the backslash as itself, every other byte as "\xNN", two lowercase hexadecimal digits.  A later version is not read, whatever its form, and is not an error of the record.

N 4. Not exactly five parts split on "." (three for "onetrace-child"): "not its form".

N 5. A part that is not canonical base64url (padded, in the standard alphabet, or with non-zero trailing bits), found by decoding, re-encoding and comparing: "not canonical base64url".

N 6. A decoded part that is empty, is not UTF-8, or holds a control character, a code point below 32, or 127: "not text".

N 7. A <head> in neither form: "not a head".

@@ 4.13.  The Re-run Mark: rerun
H 4.13.  The Re-run Mark: rerun

P A run that re-runs a recorded run carries the OPTIONAL object "rerun" in every receipt, the producer's own receipts included, and a copy in its manifest (Section 6).  Its members are strings, except "substituted":

D kind: Exactly one of "twin" (a re-run under another run's recorded configuration), "counterfactual" (a re-run with one step's output put in place from another run), "reproduce" (a re-run of the run's own steps), and "check" (the run a check produced, Section 4.20).

D of_run: The "run_id" of the run re-run.

D of_chain_head: That run's chain head.

D config_of_run, config_of_chain_head: The "run_id" and chain head of the run whose configuration was used.  REQUIRED for "twin"; present for "check" when the check ran under that run's configuration; absent otherwise.

D substituted: REQUIRED for "counterfactual", absent otherwise.  An object whose members are all strings: "step" (the node id substituted), "from_run" and "from_chain_head" (the run its output came from), "from_receipt" (the digest of that run's receipt at the step), and "output" and "output_digest" (the name and digest of the output put in place).

D writes_allowed: REQUIRED for "reproduce", absent for every other kind: "true" when the re-run was asked to execute steps recorded as writing (Section 12.3), "false" otherwise.

D from_stage: REQUIRED for "check", absent for every other kind: the node id the check started from.

P A producer marks only the run it opens at the top level of the re-run's process: a run nested in another run's stage (Section 4.11) is not the produced run, and carries no mark.

P The mark is in every receipt, under the chain, so a receipt read alone shows it and a run cannot lose it without its chain being re-linked.  The manifest's copy is read only where every receipt carries the same "rerun": no digest covers the manifest's other members, so the copy alone marks nothing.  A run whose receipts carry no "rerun" is an original run as far as its record says.  A re-run is never made a reference and is not counted as an original run.

P A verifier that implements minor 4 MUST fail a run whose receipts disagree on "rerun", whose manifest copy disagrees with its receipts, whose "kind" is outside the four, that lacks a member its kind requires ("writes_allowed" for "reproduce" among them), or that carries a member its kind does not allow (a "twin" carrying "writes_allowed", or a "reproduce" carrying "from_stage", among them), and a counterfactual whose substituted step's outputs do not hold "substituted.output_digest".

P *What a re-run took: rerun_from.*  From minor 5, a re-run that took parts of a run's configuration, or its code from another run (Section 12.3), carries the OPTIONAL object "rerun_from" beside "rerun", in every receipt of the re-run, equal in each, and a copy in its manifest.  No member is added inside "rerun", and "rerun.kind" stays one of the four.  Its members are:

D config_parts: The part names taken from the run whose configuration was used, sorted: those named, or, where all parts but some were asked for, the parts that resulted.

D code_of_run, code_of_chain_head: The "run_id" and chain head of the run whose code was used.

D code_commit: The commit run, in hexadecimal.

D environment: "today", always.

D lock_differs: "true", with "lock_name" and "lock_digest", where the dependency lock that run recorded (Section 4.26) differs from the one here; "false"; or "not observed".

D config_of_run, config_of_chain_head: As in "rerun", on a kind that may not hold them there.

P Which kind and which members a combination gives:

B a run's whole configuration: "twin", "rerun" as before, and no "rerun_from";

B parts of a run's configuration: "twin", with "config_parts";

B another run's code alone: "reproduce", with "writes_allowed" in "rerun", and "code_of_run", "code_of_chain_head", "code_commit", "environment" and "lock_differs";

B parts of a configuration and another run's code: "twin", with "config_parts" and the code members;

B a substitution and another run's code: "counterfactual", with the code members;

B a substitution and a configuration, whole or in parts: "counterfactual", with "config_of_run", "config_of_chain_head" and "config_parts", and the code members where code was also taken.

P Minor 4 refused a substitution with a configuration, as two kinds of re-run; minor 5 records the pair as "counterfactual" with "rerun_from" holding the configuration.

P A verifier that implements minor 5 reports "rerun_from" on the row "re-run from" as PASS, "<parts> from <run>; code from <run> at <commit>, environment today", or "no part named" where it names none.  It MUST fail receipts that disagree on "rerun_from", a manifest copy that differs from them, a "rerun_from" on a run with no "rerun", a "rerun_from" that is not an object, "config_parts" without both "config_of_run" and "config_of_chain_head" in "rerun" or in "rerun_from" ("config_parts with no config_of_run and config_of_chain_head in rerun or rerun_from"), a "code_commit" that is not 40 or 64 lowercase hexadecimal digits ("code_commit <value> is not 40 or 64 hex characters"), and an "environment" other than "today".

@@ 4.21.  State: state_reads and state_writes
H 4.21.  State: state_reads and state_writes

P A step MAY record the store data it touched as state, apart from its inputs and outputs: what it read or wrote, and at what version.  "state_reads" and "state_writes" are OPTIONAL arrays on a step's receipt, one entry for each read and for each write.  Absent says state was not recorded; "[]" says it was recorded and nothing was read, or nothing written.  An entry is an object with these members, all strings but "as_of":

D store: The store's name, as the pipeline declares it, as "orders_db.orders"; no control character.

D store_kind: Exactly one of the kinds listed below.

D key_digest: "sha256:" over the key's bytes; the default.

D key: The key in plain, in place of "key_digest", only where the pipeline asks for it (Section 17).  Exactly one of "key" and "key_digest" is present.

D version: The store's own revision, as a string as the store gives it, or the literal "not observed".  A write's version is the revision the store gave that write, where it gives one.

D version_kind: What "version" is, as listed below, or "declared"; absent with "not observed".

D digest: "sha256:" over the canonical form "digest_form" names.

D digest_form: One of the forms below.

D digest_status: "not observed: " followed by the reason, as for a streamed body the step did not read whole.

D found: "false" on a read that found nothing; absent otherwise.

D as_of: An object of "newest" and "oldest": the "last modified" times among the results, as the store gives them, never from the producer's clock; absent where the store gives none.

D ids_digest: On a vector query only: "sha256:" over the ids alone, in order.

D kept: "true" where the value's bytes are kept (below); absent otherwise.

P Exactly one of "digest", "digest_status" and "found" is present.

P *Versions.*  Where a store has no revision, "version" is "not observed".  A producer never makes one up: no counter, no hash of what was read, no clock.  Lineage then rests on the digest alone.  A pipeline that keeps its own revision gives it with "version_kind" "declared", and the record then says whose it is.  The kinds, and what "version_kind" each gives on a read and on a write:

B "langgraph" (a framework checkpointer): "checkpoint"; at open, the thread's latest.

B "postgres" (Postgres, pgvector): "lsn", on a read the value of pg_current_wal_lsn() at the read, on a write the commit's; at open, the LSN at open.

B "mysql": "gtid-set" on a read, "gtid" on a write; at open, the executed set.

B "sqlite": "data-version", within one connection only; at open, not observed.

B "iceberg": "snapshot"; at open, the current snapshot id.

B "delta": "table-version"; at open, the current version.

B "object" (S3, GCS, Azure Blob): "version-id" or "generation", else "etag"; at open, not observed.

B "search" (Elasticsearch, OpenSearch): "seq-no", written "<_primary_term>/<_seq_no>", for a document; for a search, not observed; at open, not observed.

B "document" (MongoDB): "cluster-time"; at open, not observed.

B "vector" (Pinecone, Chroma, most hosted indexes): not observed, on a read, a write and at open.

B "kv" (Redis, memcached): not observed, on a read, a write and at open.

B "git" (a git-backed store): "commit"; at open, the head commit.

B "other": as the pipeline gives it.

P *Digests.*  "JCS" below is the canonical form of [RFC8785] with every scalar a string, as in a receipt: a driver's integer or decimal is its decimal string as the driver renders it, a boolean is "true" or "false", a null is JSON null, bytes are {"b64": <base64url>}, a time is the driver's own string, and a binary floating-point value is written in the number form of [RFC8785], then as a string.  The forms:

D sql-rows/1: A SQL table read or query: JCS({"columns": [the names, sorted], "rows": [[the cells in that order], ...]}), the rows sorted by each row's JCS bytes, so a row order the query never fixed does not read as a difference.

D sql-rows-ordered/1: The same, with the rows in result order, where the pipeline says order matters.

D bytes/1: An object, a file, or a key-value value given as bytes: the bytes themselves.

D json/1: A key-value value, or any value the pipeline declares, that is not bytes: JCS(value).

D docs/1: A document store: JCS([{"id": <id>, "doc": <the document>}, ...]) in result order, with Extended JSON for BSON types.  A search's scores are not hashed.

D vector-query/1: A vector query: JCS([{"id": <id>, "score": <score>}, ...]), in returned order; "ids_digest" beside it is over JCS([ids]).

D vector-change/1: An upsert or delete: JCS([{"id": <id>, "vector": <sha256 of the raw little-endian vector, or null on a delete>, "metadata": <sha256 of JCS(metadata), or null>}, ...]), sorted by id.

D checkpoint/1: A framework checkpoint: no digest by default, and "digest_status" "not observed: a checkpoint's values are the framework's own"; the checkpoint id is the version, and lineage rests on it.

P *Keys.*  A SQL query's key is JCS({"query": <text>, "params": [<cells>]}), so two queries with other parameters have other keys.  An object's key is its path.  A key-value entry's is its key, and a namespace's its name.  A vector query's key is JCS({"index": <name>, "filter": <filter or null>, "top_k": <k>, "query_digest": <sha256 of the query vector or text>}).

P *The cap.*  A step keeps its first 1000 entries on each side, and counts the rest in "state_cut", a decimal string.  Absent, none was left out.  A verifier that implements minor 5 MUST fail a "state_cut" that is not a decimal count, "state_cut <value> is not a decimal count".  A step with a cut never reads as having told the whole of its state.

P *A kept value* is the exact bytes "digest" is over, in the file "state/<receipt stem>/reads/<n>" or "state/<receipt stem>/writes/<n>", where <n> is the entry's place in its array from 1.  It sits beside "artifacts/", as a kept configuration does (Section 4.16), so it never reads as a step's output.  It is kept only where the pipeline asks, never on a run whose "outputs_kept" is "none", and, past the size cap of Section 4.7, with no file and no "kept".

P *State at open.*  A run's first receipt MAY carry "state_at_open", an array of objects with "store", "version" and "version_kind": the revision each store reported when the run opened.  It is written only from a store that gives a cheap whole-store revision; a producer never reads a store whole to compute one.  The manifest holds a copy (Section 6).

P A step holding an entry in "state_writes" is a write to every re-run, whatever its label (Section 4.14).

P A verifier that implements minor 5 reports a step's state entries as PASS, "N read, M written, each in form", and MUST fail: a member outside the table; a "store_kind" outside the list; a digest out of form; both "key" and "key_digest", or neither; not exactly one of "digest", "digest_status" and "found"; "digest" with no "digest_form", or a "digest_form" outside the list; no "version"; a "version" other than "not observed" with no "version_kind"; a "version_kind" beside "not observed"; and a "found" other than "false".  It reads each kept value as PASS, "<store>: the kept value recomputes", or NOT RUN, "the value was not kept", and MUST fail a kept file whose SHA-256 is not "digest", "kept" with no file, "kept" on an entry with no "digest", and a file under "state/" for an entry with no "kept".  It reads "state at open" as PASS, "N stores", and MUST fail a manifest copy that differs from the first receipt's, and a "state_at_open" on any receipt but the first.  A reader cannot recompute a digest from a store it does not hold, so these checks read form, and bytes only where kept.

P What state does not show:

B Lineage is equality of recorded digests or versions.  It says run B read what run A wrote.  It does not say that data made B behave as it did.

B A version is the store's own report.  A producer does not check that a store's versions are consistent, and reports a pair with the same version and different digests as it finds it.

B A Postgres read's version is the LSN at the read, not a snapshot the read is proved to have used.

B A store reached without a hook or a declaration is not seen.

B Source age is the store's own "last modified", not when the data was true.

B A sorted "sql-rows/1" digest says which rows came back, not in what order.

B "state_at_open" is a revision the store reported at open, not a statement of the store's content.

@@ 4.23.  Messages
H 4.23.  Messages

P A step MAY record the messages it sent to another agent, a node, or a state channel, and the messages it took in.  "messages" is an OPTIONAL array on a step's receipt, what the step sent, in call order.  Each entry is an object of strings:

D seq: A decimal, from "1" within the step, in call order.

D from: The sender: the step's agent's name (Section 4.22), else its node id, unless the code names another.

D to: The receiver, as the code names it: an agent's name, a node's, or a key of a framework's shared state, as "state:messages".

D kind: A string the pipeline chooses, 1 to 64 characters, no control character.

D digest: "sha256:" over the body's bytes: bytes as given, a string as its UTF-8, any other value in canonical form; a value that cannot be is refused, naming it.

D bytes: The body's length in bytes.

D media_type: Where given or known; absent, not recorded.

D kept: "true" where its bytes are kept, as "messages/<receipt stem>/<seq>", by the run's rule for keeping outputs; absent, not kept.

P A message's id is "<node id>:<seq>", split at its last ":", since a node id can hold ":".  "messages_received" is an OPTIONAL array on a step's receipt, each entry an object of "from_step" (the sending step's node id), "seq" and "digest" for a message this step took in, or of "digest" alone where no sending step is known.

P Kept bytes sit beside "artifacts/", as a kept configuration does (Section 4.16), so a kept message never reads as a step's output.  A message is not an output and not a setting: "messages" changes no verdict, and a comparison reports it apart.  It names the first message that differs, by step in chain order and then "seq", and a message on one side only.

P *Informative: framework messages.*  Under a graph framework, a message a node adds to its message state is recorded with "kind" the message's type ("human", "ai", "system" or "tool"), "from" the node's name, "to" "state:<channel>", and "seq" its place in the node's returned list; its digest is over the message as the producer's framework encoding writes it, with every field but "id", "response_metadata" and "usage_metadata".  A message in the state a node starts from, added earlier, is in that node's "messages_received", by digest and by position.  A model's tool call is recorded as "kind" "tool request", from the model step's agent to the tool's name, its digest over JCS({"name", "args", "id"}); a tool's result as "kind" "tool result", from the tool's name to the agent that asked, or to "state:<channel>".  "to" under such a framework is the state channel: a node returns state, and the graph routes it after the node has returned, so when the receipt is written no receiver is known.  A tool result carries the id of the tool call it answers, so these records and "tool_call.requested_by" (Section 4.22) name one id.

P A verifier that implements minor 5 reports, on a record that holds the members:

D messages: PASS, "N messages, in order, each in form"; FAIL, naming each entry out of form, "messages[<n>]: <what>", on a member outside the list, a missing member, a "seq" that is not "1" to "N" in order, a digest out of form, a "bytes" that is not a decimal, and a "from", "to", "kind" or "media_type" that is not a non-empty string, "kind" being 1 to 64 characters with no control character.

D messages kept: PASS, "<seq>: the kept bytes match"; FAIL on a kept file with another digest or length, and "kept" with no file; NOT RUN, "the bytes were not kept", once for each run.

D messages_received: PASS, "N received, each from an earlier step"; FAIL on an entry out of form (an object of "from_step", "seq" and "digest", or of "digest" alone), a "from_step" not earlier in the chain, no message at that "seq", and a digest that differs from the sender's; NOT RUN, "<digest>: no sending step named".

P What a message record does not show:

B A message record shows what was sent.  It does not show that the receiver acted on it.

B "messages_received" shows the receiving step's code said it took the message in, or that a framework's state held it when the node started.  It does not show the node read it.

B "to" is what the code declared.  Under a graph framework it is a channel, not a route.

B A message passed with no declaration and no framework hook is not seen.

@@ 6.  The Chain Manifest
H 6.  The Chain Manifest

P A run's receipts are listed by a chain manifest: a JSON object in canonical form with the REQUIRED members:

D format: The string "stage-receipt-chain/0.MINOR", where MINOR is the minor of the run's receipts.

D run_id: The run identifier, equal to that of every receipt listed.

D chain: An array of objects in receipt order, each with the members "index" (decimal string), "stage" (the stage name), "file" (a path relative to the manifest, using "/" as separator) and "digest" (the digest of that file's bytes).

D chain_head: The digest of the last receipt in "chain".

D anchor: An anchor declaration for the chain as a whole, in the form of Section 10.

P The manifest MAY carry other members.  It is itself digested in canonical form when it is anchored or listed by a root over many chains.  The following are OPTIONAL, and no digest in the chain covers them:

D outputs_kept: "all" (each receipt's output files are kept beside the run) or "none" (the run declares that it keeps none; its receipts still record each output's digest and size).  With "none", every receipt says so too, as "coverage.outputs_kept".  A verifier reads the declaration only where the manifest and every receipt agree, and never as files checked.

D edges: An array of objects with the members "from" and "to": the node ids (Section 4.11) of each link the run recorded from an earlier step to the step that read its receipt.

D declared_edges: The plan the run was approved under: an array of objects with the members "from" and "to", stage names, and an OPTIONAL "repeats", the string "true" for a loop.  A verifier checks that every recorded edge, its node ids read as stage names, is a pair in "declared_edges", and that an edge from a stage to itself is declared with "repeats" "true".  An empty array is a plan that allows nothing.  Where "declared_edges" is absent, or a plan is declared and the run records no edges, the plan check is NOT RUN, with that reason.

D auto: Section 4.19.

D rerun: A copy of the receipts' "rerun", read only where every receipt carries the same (Section 4.13).

D rerun_from: A copy of the receipts' "rerun_from", read in the same way (Section 4.13).

D parent_run, parent_stage: For a nested run, the enclosing run and step (Section 4.11.1); for a run with a cross-service link, copies of "parent_link.run" and "parent_link.stage" (Section 4.11.2).

D origin_run: A copy of the first receipt's "parent_link.origin" (Section 4.11.2).

D state_at_open: A copy of the first receipt's "state_at_open" (Section 4.21).

D agent: A copy of the receipts' "run_agent", read only where every receipt carries the same (Section 4.22).

D thread_id: A copy of the first receipt's "thread_id" (Section 4.19).

D code: A copy of the first receipt's "code" (Section 4.26).

P *The copy rule.*  No digest covers a manifest member other than the chain and its head, so a member that must be bound to the record is in a receipt, and the manifest's copy is read only where it equals that receipt's member: the first receipt's, or, for a member in every receipt, every receipt's where they agree.  A verifier that implements minor 5 MUST fail a copy that differs from the member it copies, and a copy with nothing beside it in the receipts: a manifest "state_at_open", "agent", "rerun_from", "code", "thread_id" or "origin_run" whose receipts hold no such member, each on its member's row.  A manifest's "parent_run" and "parent_stage" with no "parent_link" in the first receipt are a run nested in-process (Section 4.11.1), not a copy.

P While a run is in progress, its manifest may be up to the run's manifest interval behind its receipts (Section 9).  The journal and the receipts are current.  The manifest is rewritten when the run closes and when it is recovered.

P The chain is valid when, for every receipt, "prev" equals the digest listed for the preceding receipt (null for the first), the listed digest equals the digest of the file's bytes, and "chain_head" equals the digest of the last receipt.  A chain with a missing receipt is not a chain with a gap; it is a chain that fails, and the emission declaration (Section 9) is how a producer records an absence it knew about rather than leaving a verifier to discover one.

@@ 4.15.  Expectations
H 4.15.  Expectations

P "expectations" is an OPTIONAL array on a step's receipt, one entry for each expectation the stage declared about its own output.  Each entry is an object with the members "name" (unique in the step), "kind" (exactly one of "range", "unit", "relation", or "member"), "target" (the output's name and a JSON Pointer [RFC6901] into it, as "return.json#/value"), "declaration" (the kind's own members, every one a string, such as "lo", "hi", "unit", "of", "op" and "within"), "declaration_digest" (the digest of "declaration" in canonical form), and "declared" ("with the run").  Every bound is a decimal string and is compared as a decimal.

P Each kind's "declaration":

D range: "lo", "hi", or both, and an optional "unit", a label of the bounds that the comparison does not read.  The value at "target" is at least "lo" and at most "hi".

D unit: "unit".  The member at "target" equals it.

D relation: "op", exactly one of "difference", "sum" or "ratio"; "of", two JSON Pointers into the target's own output, joined by one space; and "within".  The value at "target" is within "within" of the first value less the second, the two added, or the first divided by the second.

D member: no members.  The output holds a value at "target".

P Where the stage gives no "name", a producer names the expectation "<target> <kind>", the target as the stage gave it.

P An expectation written after the run is never added to its receipts.  It lives in an expectations file of its own: a JSON object in canonical form whose "format" is "onetrace-expectations/1", whose "expectations" array holds entries with the members above, "declared" set to "after the run", and a "step" member naming the node each applies to, and whose "seal" is the digest (Section 5) of the object with the members "seal" and "signature" left out: SHA-256 over that object's canonical bytes, written as "sha256:" followed by 64 lowercase hexadecimal digits.  A report names every row read from such a file as declared after the run.  An expectation declared after the run says nothing about what was expected when the run was made.

P An expectation that holds shows the declared rule held, not that the output was right.

P A verifier that implements minor 4 reports one row for each entry: PASS, FAIL naming the value and the rule, or NOT RUN.  An entry reads NOT RUN where its output was not kept or is not readable as JSON.

P A decimal string, as a bound and as a value, is an optional "-", then an integer part, "0" or a digit from "1" to "9" followed by any digits, then optionally "." and one or more digits.  It has no "+", no leading zero, no exponent and no other character: "-1.50" is one, and "+1", "01", "1.", ".5" and "1e-7" are not.  A value is read as a decimal from its JSON text, never through a binary floating-point value, and exactly, at any length:

B a JSON string is a decimal where it holds a decimal string;

B a JSON number is the decimal its token writes, by the number grammar of [RFC8259], an exponent included: the number 1e-7 is the decimal 0.0000001, while the string "1e-7" is not a decimal;

B "true", "false", "null", an object and an array are not decimals.

P Each kind then reads:

D range: NOT RUN where the target names no value or its value is not a decimal; otherwise PASS where the value is within the bounds, FAIL where it is not, compared exactly, with no rounding.

D unit: NOT RUN where the target names no value; otherwise PASS where the value is the string "unit" gives, FAIL where it is anything else.  The value is compared as a string and never read as a decimal.

D relation: NOT RUN where the target, or either of the two values "of" names, names no value or is not a decimal.  The difference, sum or ratio of the two values is rounded to 100 significant digits, rounding half to even, and so is the difference between the target's value and it; that difference's magnitude is then compared with "within" exactly.  A value of more than 100 significant digits is still read exactly, and the rounding applies to what is computed from it, so a relation over such values can FAIL where exact arithmetic would hold.  A ratio whose second value is zero FAILs, as does a result whose magnitude is 10 to the power 1000000 or more.

D member: FAIL where the target names no value, PASS where it names one.

P An entry of an expectations file FAILs where the run records no step of its "step", or where an earlier entry of the file has the same "name" for the same "step": the first such entry is read as above, and each later one FAILs.  A verifier MUST fail an entry whose "declaration_digest" does not recompute, and an expectations file whose "seal" does not recompute.

P *Checked during the run.*  From minor 5, a run MAY ask for its expectations to be checked as each step returns.  There are three modes: "off", "record" and "stop".  A mode is set on the run, on a stage, or on one expectation, and the narrowest wins.  "off" is the default, and it writes nothing: a run that does not ask writes the same receipts as a run of minor 4.

P An expectation checked in "record" or "stop" carries the OPTIONAL object "checked", beside "declaration", so "declaration_digest" does not change and a mode is not a changed expectation.  Its members are strings:

D when: "during the run", the one value.

D mode: "record" or "stop".

D outcome: "PASS", "FAIL" or "NOT-RUN".

D detail: The reading's own words, as a verifier gives them; a value appears in them only where the run keeps outputs (below).

D reader: The version of the code that read it, as "onetrace-verify <version>".

P The check acts at a step's return only.  The stage's body returns and its outputs are staged and hashed.  For each expectation not "off", the producer runs the reading of this section over the bytes it is about to record, read as a verifier reads them, not over the value the code returned: a binary floating-point value and the JSON number written for it can differ in their last digits.  It writes the receipt with each result in "checked".  If an expectation in "stop" read FAIL, the producer raises a stop before the step returns to its caller, and so before the next stage can be entered.

P The stop holds for the rest of the run: every later stage call raises it again before its body and writes no receipt, as it never started.  The stage that called the failing stage gets a receipt with "outcome.class" "error" and "status" "ExpectationStopped", and the run closes with the form of Section 4.12.  Where several calls run at once, those already running finish and each writes its receipt, no new stage body starts, and the stop names the first failing step in the order the calls were given.  A step recorded by a hook (Section 4.19) declares no expectations and is never stopped by one.

P The check never fails the step on its own fault.  An output it cannot read, or a value that is not a decimal, reads "NOT-RUN" with its reason, as the verifier's reading gives it, and a "stop" expectation does not stop on "NOT-RUN".  Any other fault in the check writes "NOT-RUN", "the check could not run: <class>", and the step returns as usual.

P *A batch threshold.*  An expectation over many documents of one output MAY carry a threshold, recorded not in "expectations" but in the OPTIONAL array "expectations_batch": its entries are as those of "expectations", with "batch" beside "declaration", an object with "over" (a JSON Pointer with a wildcard, as "/docs/*") and "more_than" (a decimal string).  The target's JSON Pointer holds one "*" segment, not its last, naming each document of an array, with the member read in each document after it, as "/docs/*/score"; "over" is the pointer through the "*".  Its "checked" also holds "failed" and "of", decimal counts of the documents that failed and of those read.  "outcome" is "FAIL" where "failed" is more than "more_than", and "PASS" otherwise.  Each document's result is not written, only the count.  A threshold is an option the pipeline asks for, never a default.

P *A value withheld.*  On a run whose "outputs_kept" is "none" (Section 6), a value in "checked.detail" or in "onetrace.ended_by" would be the one place the run's data appears in plain.  On such a run both read "<the value is not kept> is outside <rule>", and the outcome stands.

P A verifier that implements minor 5 re-reads every expectation as before, and adds:

D <step>.<name> as checked during the run: PASS, "the result written during the run equals this reading: <outcome>"; FAIL, "written <outcome> by <reader>, read <outcome> by <this reader>", naming the expectation and both readers; NOT RUN, "the output was not kept; written <outcome>, not re-read".  What is compared is "outcome", not "detail", so a change of words between two verifier versions is not a difference.

D <step>.<name> checked: FAIL where "checked" is out of form: a "when", "mode" or "outcome" outside its values.

D <step>.<name> batch: PASS, "<failed> of <of> failed, more than <more_than> stops"; FAIL, "written <failed> of <of> by <reader>, read <n> of <m> by <this reader>", an "outcome" other than the count gives, a "failed", "of" or "more_than" that is not a decimal, a "failed" more than "of", an "over" that names no array, and, in "record", more than "more_than" failed: "<n> of <m> failed, more than <more_than>, in record"; NOT RUN, "the output was not kept; written <failed> of <of>, not re-read".

D the run's stop: PASS, "stopped at <node>: expect <name>"; FAIL where "onetrace.ended_by" names a step or expectation with no "checked" FAIL in "stop", in "expectations" or "expectations_batch"; where a "stop" FAIL is held and a stage other than the close, and other than a step recorded by a hook, started after that step ended; and where "onetrace.ended_by" is in the stop's form with no such expectation.

P A run with no "checked" gains no row.  A "FAIL" in "record" fails the run like any other FAIL.

P What a check during the run does not show:

B A run that was not stopped shows that no "stop" expectation failed at a step's return.  It does not show the outputs were right.

B A stop guards the steps after it, never the step that failed.  What the failing step did has already happened.

B It is not a policy check before an action.  A decision recorded at the step (Section 4.25) is that.

B "checked" says what the reading gave over the bytes recorded at that moment, under "reader"'s version.

B Code the pipeline runs after catching the stop, or outside any stage, is not stopped.

B On a run that keeps no outputs, the result written during the run cannot be re-read.  It is the producer's word, under the chain.

B A batch's count is written, not which documents failed.  A batch that did not stop shows no more than "more_than" failed.

@@ 4.19.  Auto-Recorded Steps
H 4.19.  Auto-Recorded Steps

P A producer MAY record steps it observed through a library's calls, in place of steps the pipeline declared in its code.  Such a step's receipt carries the OPTIONAL object "auto", whose members are "declared", always "false"; "call", the library's public method name; "library", the distribution's name; and, for an HTTP call, "target", an object with "host", "method", "query_names" and exactly one of "path_digest" (the digest of the request path, the default) or "path"; for a model call, "target", an object with "host" alone, the host the model client's request went to; and, on a step recorded from a thread that did not carry the run's context, "context", the string "thread without the run's context".  A receipt without "auto" is a declared step, as every receipt written before minor 4 is.

P A run the producer opens itself to hold such steps is an auto-recorded run.  Its manifest carries the OPTIONAL object "auto": "boundary" ("process" or "request"), "key" (what keyed a run per request), and "hooks", an array of objects with "library", "status" and "version", where "version" is present only when the entry's "status" is "hooked".  Every auto-recorded run declares a boundary when it opens, over the steps outside the libraries observed, of "kind" "not observed", its "note" naming those steps, so its coverage never reads "complete" (Section 8).

P A run the pipeline declared in its code MAY also hold such steps, at its top level or as children of its own steps.  It is not an auto-recorded run: its manifest carries no "auto", it declares no boundary for them, and it keeps its own declared coverage, so its close receipt can read "complete".  It gains each such step's stage name in "declared_stages" (Section 8) the first time a step of that stage is recorded, before its last declared stage; no name is removed or reordered.  Each receipt's "declared_stages" is the list as known when the receipt was written, so an earlier receipt may list fewer names than a later one, and the close receipt's list is the run's whole list.

P A step recorded from an HTTP call has two outputs: "status", the canonical JSON object {"status": "<code>"}, and "response", the response body's bytes.  A call that followed redirects is one step, whose "status" is the final response's and whose "response" is the final body; a producer MAY add the number of hops to "status", as {"redirects": "<n>", "status": "<code>"}.  A streamed response is hashed as it passes and has its "response" output where the producer observed the body; one it did not observe has "status" alone.  A status that differs is thus an output that differs, whatever the body.

P What an auto-recorded step did not observe or did not write is said in constants of the producer's own (Section 4.12), which every comparison leaves out of a step's settings: "onetrace.http.body", "not observed: streamed", where the response was streamed, not observed, and there is no "response" output; "onetrace.http.request", "not observed: streamed", where the request body was streamed and there is no "request" input, or "not observed: the text cannot be encoded as it will be sent", where the body's text cannot be encoded as the library will send it; and "onetrace.model_call", "not written: the hook did not see the client's request", where a model step wrote no model-call record.  A record of minor 4 can also hold "not written: embeddings have no record format in this release"; from minor 5 an embeddings call writes an embedding-call record.

P An auto-recorded step always carries "effect_label" (Section 4.14).  A verifier that implements minor 4 MUST fail an "auto.declared" other than "false", an "auto.context" other than "thread without the run's context", and a receipt with "auto" and no "effect_label"; it checks that the label's basis is one the producer documents for that library.  It checks that an auto-recorded run holding a receipt with "auto" has the manifest's "auto" and the boundary, and it knows an auto-recorded run by either: the manifest's "auto", or that boundary in the manifest or in any receipt's coverage.  It makes no claim about an auto-recorded run rewritten without both and re-linked, which reads as a run declared in code, nor about a run declared in code that declares that boundary itself, which reads as an auto-recorded run.  Within one chain, a later receipt's "declared_stages" MAY hold more names than an earlier receipt's only where each added name is the stage of a receipt with "auto" in the chain, and every earlier name keeps its place; a verifier MUST fail a removal, a reorder, or any other added name.

P *Libraries added in minor 5.*  A step MAY be recorded from four more libraries: "anthropic", a model call whose "target" holds "host" alone; "httpx2", an HTTP call as above; and "langchain" and "langgraph", whose steps the producer records from the frameworks' own callbacks, with no "target".  A reader that implements minor 4 and does not document a library's bases reads that step's label check as NOT RUN, "<library>: no documented bases" (Section 14).

P *Framework steps.*  An auto-recorded run declares a fixed list of stage names, so two runs compare cleanly, and a node's own name is an instance, not a stage name.  "<n>" counts from 1 within the name in the run:

D langgraph.node: "auto.call" "node"; instance "<node name>.<n>", as the node id "langgraph.node#agent.1".  A graph node.

D langchain.chat_model: "auto.call" "chat_model"; instance "<n>", as "langchain.chat_model#2".  A chat model call, with its model-call record, of kind "model call".

D langchain.llm: "auto.call" "llm"; instance "<n>".  A completion model call, with its model-call record, of kind "model call".

D langchain.tool: "auto.call" "tool"; instance "<tool name>.<n>", as "langchain.tool#add.1".  A tool call, with "tool_call" (Section 4.22), of kind "tool call".

D langchain.retriever: "auto.call" "retriever"; instance "<n>".  A retrieval, of kind "retrieval".

P A call that is not a graph node and not a subgraph opens no step: its calls nest under the enclosing step.  A call that ends in error closes its step with "outcome.class" "error".  A subgraph is a nested run (Section 4.11.1), told apart by the depth of its namespace, and its head is an input of the enclosing node.  Nodes that run in one superstep are chained in the order they finished, so two runs of the same work may differ in that order.  A graph invocation at the top level of a process is one run.

P The labels the producer documents for these libraries are: for "langchain", "read" with "model call" on a chat model or completion model step, and "read" with "not classified" on a retriever step, beside "step.effect_basis" "vector query" (Section 4.14); for "langchain" and "langgraph", "read" or "write" with "declared on the stage" on a tool or node that declares its effect in the framework's own metadata, and "unknown" with "not classified" on a tool or node that declares nothing.  A node's "step.kind" is the one it declares, or "other".

P *A call is never recorded twice.*  While a framework model step is open, a lower hook (an HTTP or model client hook) records no step for the call it sees, and adds to the framework step the OPTIONAL object "step.lower_hook" (Section 4.22): "library", the lower hook's library, and "note", "already recorded by the framework hook".  A call a node or a tool makes outside a framework model step is recorded by the lower hook as minor 4 records it, nested under the node or the tool.

P A framework step whose callback could not finish recording carries "framework_error", the string "not recorded: " followed by what was not recorded; the pipeline's own call goes on.  A graph run's first receipt MAY carry "thread_id", the framework's thread id as its metadata gives it, and the manifest a copy (Section 6).  The manifest's "auto.hooks" gains entries for "langchain-core" and "langgraph", each with "library", "status" and "version" as above.  Checkpoints are recorded as state (Section 4.21), of "store_kind" "langgraph".

P A verifier that implements minor 5 checks a framework step's label against the table above, and MUST fail a label outside its library's rows; a "step.lower_hook" with a member other than its two, a "note" other than its one value, or on a step whose kind is not "model call"; a "framework_error" not of its form; a framework step whose "parent" names a step that ended before it began, where every framework step's parent is an open node or the run; two steps under one node with the same request digest (the digest of the step's input named "request"), one carrying "step.lower_hook" naming a library and the other an auto-recorded step of that library; and a manifest "thread_id" that differs from the first receipt's.

P What a framework-recorded run does not show:

B It is complete only for the events the framework's callbacks deliver, at the versions in "auto.hooks".

B Code a node runs outside the framework's calls is seen only through the lower hooks, or a declared stage.

B A model step's request is what the callback delivered, not the bytes sent.  "step.lower_hook" shows a lower hook saw a call during that step.  It does not compare the two.

B A node's agent identity (Section 4.22) is the graph's own name for it.

B A subgraph told apart by namespace depth reads what the framework reports there.

B An open coverage boundary stands, as on every auto-recorded run.

@@ 14.  Versioning
H 14.  Versioning

P The "format" member carries "stage-receipt/MAJOR.MINOR".  Within a major version, a minor revision MAY add optional members, permitted values of unenumerated strings, and required checks that only fail on records the earlier minor already forbade; it MUST NOT remove a required member, change a member's type, or change the canonical form.  A verifier MUST accept any minor version of the major it implements and MUST report NOT RUN, with a version reason, for any check the record's minor version did not define.  A major revision MAY change required semantics.

P A verifier that encounters a record whose "format" is a major version it does not implement -- including the pre-standard value "stage-receipt/0.0-preview", which corresponds to this document's golden chain before its format string was assigned -- MUST report NOT RUN with the version as the reason.  It MUST NOT report PASS, since it did not check the record against the rules the record claims, and it MUST NOT report FAIL, since the record contradicted nothing the verifier knows.

P Minor 4 adds optional members only, marked in Sections 4.11 to 4.20 and Section 6, and reserves two stage names, "onetrace.close" and "onetrace.check", and the constant prefix "onetrace.".  The reservations bind producers from minor 4.  A reader identifies a reserved receipt by the two-part rule of Section 4.12, so no record written under an earlier minor reads differently.

P Minor 5 adds optional members only, marked in Sections 4.7, 4.11, 4.12, 4.13, 4.15, 4.19, 4.21 to 4.26, 6, 8 and 9.  It adds only what a verifier that implements minor 4 reads as before: such a verifier reads a minor 5 record with the same overall result as the same record without the minor 5 members, and no check that passes on a minor 4 record reads otherwise, though its words may quote other recorded values.  Checks that verifier adds for a receipt minor 4 would not write are allowed.  There are two exceptions:

B a step of a library whose bases that verifier does not document (Section 4.19) reads NOT RUN on its label check, "<library>: no documented bases", as a step of any undocumented library does, with the overall result unchanged;

B an output kept only as a digest (Section 4.7) has no output checks under that verifier, as for a step that wrote no such output, with the overall result unchanged.

P To hold that rule, minor 5 adds no form of "onetrace.ended_by", no basis of "effect_label" and no third member in it, no member inside "rerun", no member inside a model-call record and no new format for one, no output left in "outputs" without its file, no "more_than" inside a "declaration", and no constant of a new name beginning "onetrace." on an auto-recorded step.  A member that must be bound to the record is in a receipt, and the manifest holds a copy (Section 6).  A run's agent (Section 4.22) and its cross-service link (Section 4.11.2) follow that rule.

P Minor 5 reserves the instrument kind "close-recovered" with the stage name "onetrace.close" (Section 4.12), identified by the two-part rule, and the constants "onetrace.recovered" and "onetrace.last_confirmed" within the prefix minor 4 reserved.  It gives words to the boundary kinds "queue full" and "recovered" (Section 8), and names the folders "state/", "messages/" and "authorization/" beside "artifacts/", none of which holds a step's output.  The list of "step.kind" values is closed: a new kind needs a new minor.  These bind producers from minor 5.

@@ C
P Changes from -03.  The format is unchanged: minor 5 as -03 describes it.  This revision states checks -03 left to the reference implementation, and corrects its text where the two differed.  It names the origin's two failures on the first receipt, a run id's form and the callee's failure where the caller holds no call to it, and leaves out a nested caller's origin read from its own manifest, a reading no verifier makes (Section 4.11).  It states the checks of "rerun_from" (Section 4.13), of "state_cut" (Section 4.21) and of messages (Section 4.23) as the reference implementation makes them, and the copy rule's failure for a copy with nothing beside it in the receipts (Section 6).  It defines the HTTP fields' "escaped", control character and length (Section 4.11.3), a batch threshold's wildcard pointer (Section 4.15) and a framework step's request digest (Section 4.19).  Section 14's list of the forms minor 5 does not use gains a "more_than" inside a "declaration", and single use's reading of a missing "iss" or "jti" is said in words.

@@ C/Not yet described.
P Not yet described.  The recipient confirmation's format is to be specified separately.  How the members of Sections 4.22 to 4.24 map to the OpenTelemetry GenAI semantic conventions [OTEL-GENAI] is not described here.  The members of "authorization" that earlier minors write, beyond "decisions" and "action_digest", are not yet described (Section 4.25).  The comparisons that read the new members (Section 12.1) are not revised here.  Under single use (Section 4.25), a "permit" missing "iss" or "jti" reads no value in its place beside the key check's FAIL; that reading is left open, as is a recipient's second key.  The vectors of Appendix A are unchanged; no vector for minor 5 is added to this document.
