feat(stack-encrypt)!: codes, help and fields on every error; dynamic input errors name the field

stack-encrypt was the one crate in the chain with no miette support: its
errors were plain thiserror enums with no codes and no help, and the
dynamic module's input errors were unit variants that could not say which
field was wrong. A Go caller got "malformed input" for a bad plan, a
record that did not fit it, an empty context and an over-long one alike.

Every error type here now derives `miette::Diagnostic` with a
`stack_encrypt::*` code, listed in `ERROR_CODES` and pinned by a test
that builds every variant: `Error`, `PlanError`, `LabelError`,
`LeafBytesError`, `sem::TermError`, `sem::TermBytesError`, and with
`dynamic`, `dynamic::Error` and `dynamic::TargetError`. Help is added
where a caller can act (`ForeignKeyset`, `DescriptorTooLong`,
`EmptyTermText`, the plan refusals), and each implements the shared
`ErrorPayload`: both keyset ids of a `ForeignKeyset`, the field and
expected type of a `FieldType`, a descriptor's length against its limit.
`Error::Kms`, `Term` and `Plan` forward the code of what they carry;
`Kms` is now transparent outright, so a ZeroKMS keyset-not-found reads as
itself.

BREAKING CHANGE: `dynamic::Error::Context`, `Plan`, `Source` and `Record`
are struct variants carrying `field: Option<String>` and a `Reason` from
the new fixed `dynamic::Reason` enum (`MissingContext`, `DuplicateOutput`,
`FieldMissing`, `NoCiphertextNode`, ...), and `Term` gains `field`.
Every site that raised one now names the field it knows, plan builder and
engine refusals included; `in_field` names it from the caller's side for
functions that never see one. `Error::Kms` loses its message prefix.
`ContextMismatch` gives the stored context's length and part count rather
than its descriptor, which a context field can fill with customer data,
and `TermError::Prf` and `MatchPositionOutOfRange` stop repeating
another library's message and a value read from term bytes. The Go
guest's status mapping matches the new shapes; its numbers are unchanged.

Refs #1099

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01URtfKsTToFUCRwq3g7gCUf

Author: claude

Cargo.lock

@@ -104,12 +104,12 @@ pub fn status_for_error(error: &stack_encrypt::Error) -> u32 {
 pub fn status_for_dynamic(error: &stack_encrypt::dynamic::Error) -> u32 {
     use stack_encrypt::dynamic::Error;
     match error {
-        Error::Context
+        Error::Context { .. }
         | Error::Term { .. }
-        | Error::Plan
+        | Error::Plan { .. }
         | Error::UntypedIndex { .. }
-        | Error::Source
-        | Error::Record => STATUS_ENCODING,
+        | Error::Source { .. }
+        | Error::Record { .. } => STATUS_ENCODING,
         Error::Cipher(e) => status_for_error(e),
         // A target refusal is a statement about the plan, the label or the
         // value (an unknown or unproducible type, an extended plan, a value
@@ -405,26 +405,52 @@ mod tests {
 
     #[test]
     fn dynamic_input_errors_are_encoding_and_a_library_bug_is_internal() {
-        use stack_encrypt::dynamic::Error;
+        use stack_encrypt::dynamic::{Error, Reason};
         use stack_encrypt::sem::MatchOptions;
         use stack_encrypt::target::IndexSpec;
+        let age = || Some("age".to_string());
         for (label, err) in [
-            ("a bad context", Error::Context),
+            (
+                "a bad context",
+                Error::Context {
+                    field: None,
+                    reason: Reason::EmptyContext,
+                },
+            ),
             (
                 "a bad term request",
                 Error::Term {
+                    field: age(),
                     kind: IndexSpec::Match(MatchOptions::default()),
                 },
             ),
-            ("a bad plan", Error::Plan),
+            (
+                "a bad plan",
+                Error::Plan {
+                    field: age(),
+                    reason: Reason::DuplicateOutput,
+                },
+            ),
             (
                 "an indexed field with no type",
                 Error::UntypedIndex {
                     field: "age".to_string(),
                 },
             ),
-            ("a bad source", Error::Source),
-            ("a bad record", Error::Record),
+            (
+                "a bad source",
+                Error::Source {
+                    field: age(),
+                    reason: Reason::FieldMissing,
+                },
+            ),
+            (
+                "a bad record",
+                Error::Record {
+                    field: age(),
+                    reason: Reason::NoCiphertextNode,
+                },
+            ),
         ] {
             assert_eq!(
                 status_for_dynamic(&err),

languages/golang/encrypt/guest/Cargo.lock

@@ -9,6 +9,27 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- **Every error has a miette code, help where a caller can act, and its
+  facts as structured fields.** `Error`, `PlanError`, `LabelError`,
+  `LeafBytesError`, `sem::TermError`, `sem::TermBytesError` and, with
+  `dynamic`, `dynamic::Error` and `dynamic::TargetError` derive
+  `miette::Diagnostic` with a path-style code named after the crate
+  (`stack_encrypt::aead`, `stack_encrypt::foreign_keyset`), listed in
+  `stack_encrypt::ERROR_CODES` and pinned by a test that builds every
+  variant. A variant that carries another crate's error forwards its code:
+  `Error::Kms` shows `stack_kms::keyset_not_found` itself. Each error
+  implements `ErrorPayload` (re-exported here from `stack-profile`, the
+  crate `stack-profile`, `stack-auth`, `stack-kms` and this crate share),
+  whose `payload()` gives the facts a caller branches on — both keyset ids
+  of a `ForeignKeyset`, the field of a plan refusal — and whose docs hold
+  the rule for what an error may contain: no plaintext, key material,
+  tokens, ciphertext or term bytes, or raw context values. Codes are for
+  crossing a boundary; Rust code keeps matching variants.
+- **A dynamic input error names its field and says why.** `dynamic::Reason`
+  is the fixed vocabulary (`MissingContext`, `DuplicateOutput`,
+  `FieldMissing`, `NoCiphertextNode`, ...; `as_str()` is its `snake_case`
+  name), and `dynamic::Error::field()`, `reason()` and `in_field()` read
+  and fill them.
 - **A data plan field may name an EQL type as its target.** Beside the
   output form, `dynamic::record::plan_with` reads `{"context": [...],
   "target": "TextEq", "type"?: ...}` — the two forms are exclusive — and
@@ -32,6 +53,25 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Breaking
 
+- **`dynamic::Error`'s input variants carry the field and a reason.**
+  `Context`, `Plan`, `Source` and `Record` are struct variants
+  `{ field: Option<String>, reason: Reason }`, and `Term` gains
+  `field: Option<String>`: a match on `Error::Plan` becomes
+  `Error::Plan { .. }`. The messages name both (`record plan is malformed:
+  an output is named twice (field "age")`). A source with a field the plan
+  does not name is now refused naming that field (`UnknownField`) after the
+  plan's own fields are checked, rather than first, on a field count.
+- **`Error::Kms` is transparent.** Its message, code and help are the
+  `stack_kms::Error`'s; the `ZeroKMS data-key operation failed:` prefix is
+  gone, and `source()` skips to the ZeroKMS error's own cause.
+- **Some messages leave out what an error may not contain.**
+  `Error::ContextMismatch` gives the stored context's length and number of
+  parts instead of its descriptor, which can be customer data (the
+  `stored` field still holds it). `sem::TermError::Prf` no longer repeats
+  the PRF backend's message, and
+  `sem::TermBytesError::MatchPositionOutOfRange` no longer quotes the
+  position read from the term's bytes: both stay on the error for a caller
+  in this process.
 - **A data plan field with a term output must declare its `"type"`.** A
   plan whose indexed field (`"eq"`, `"match"`, `"ore"`, `"ope"`) has no
   `"type"` is refused when it is built (`Error::UntypedIndex`, naming the

languages/golang/encrypt/guest/src/status.rs

@@ -41,6 +41,11 @@ serde = { workspace = true }
 base64ct = { version = "1.7", features = ["alloc"] }
 
 cllw-ore = { workspace = true }
+# Every error derives `miette::Diagnostic` (a code, and help where a caller
+# can act) and gives its structured fields as a `serde_json` map through
+# `ErrorPayload`. Both are already in the graph through stack-kms.
+miette = { workspace = true }
+serde_json = { workspace = true }
 thiserror = { workspace = true }
 uuid = { workspace = true }
 zeroize = { workspace = true }
@@ -63,7 +68,6 @@ dynamic = ["dep:vitaminc-aead-value"]
 test-support = ["stack-kms/test-support"]
 
 [dev-dependencies]
-serde_json = { workspace = true }
 # The deterministic key source the record fixture is sealed under
 # (`tests/common`): keys and tags derived from a seed, the descriptor and the
 # IV, so a committed record opens in another process. Same version stack-kms