From 561db6bae3c357dcb8f252bf5cf861575232d20a Mon Sep 17 00:00:00 2001
From: Brian Searls <briansearls1@gmail.com>
Date: Sat, 3 Oct 2026 18:33:08 +0000
Subject: [PATCH 1/2] emit_rust: hand-written supplemental impl headers carry
 the item header's bounds (WIP, mirrors not regenerated)

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 dag/gunbc/instrument_targets.dag              |  23 +++-
 .../instruments/native_emission_controls.dag  | 126 ++++++++++++++++++
 .../generic_item_clone_bound_witness_test.dag |  60 ++++++++-
 src/v1/05_emit_rust.dag                       |  99 +++++---------
 src/v1/stage0/src/target_invocation_host.rs   |   6 +
 src/v1/trait_derive_emit.dag                  |  78 +++++++----
 6 files changed, 301 insertions(+), 91 deletions(-)
 create mode 100644 dag/gunbc/instruments/native_emission_controls.dag

diff --git a/dag/gunbc/instrument_targets.dag b/dag/gunbc/instrument_targets.dag
index 2888b18b959..013817726cf 100644
--- a/dag/gunbc/instrument_targets.dag
+++ b/dag/gunbc/instrument_targets.dag
@@ -323,6 +323,19 @@ fn dag_emit_real_grammar_round_trips_entry() -> String {
   "dag/gunbc/instruments/dag_emit_real_grammar_round_trips.dag"
 }
 
+// THE NATIVE EMISSION CONTROLS: one carrier per Rust-emitter rule, emitted, built and run by the
+// NativeClaimDriver program gunbc.instruments.native_emission_controls. It is the executing evidence
+// that a rule's emission is a compilable program with the right answers -- the half a textual
+// witness over the emitted header cannot establish. Run by name, not a merge gate.
+// `gunbc test //gunbc/instruments:native-emission-controls`.
+fn native_emission_controls_label() -> Label {
+  Label { package: instruments_package() target: TargetName { name: "native-emission-controls" } }
+}
+
+fn native_emission_controls_entry() -> String {
+  "dag/gunbc/instruments/native_emission_controls.dag"
+}
+
 // O(corpus) exact-head join of evaluation_store_address callers plus the fail-closed src/v2
 // call-form scan. Not a DiscoverySelection floor witness (enrolment_bound_without_ceiling);
 // not a required CI job. `gunbc test //gunbc/instruments:evaluation-store-address-exact-head`.
@@ -497,6 +510,10 @@ fn native_app_attest_binding() -> TargetBinding {
   TargetBinding { target: native_app_attest_label() producer: NativeClaimProgramProducer { entry: native_app_attest_entry() } }
 }
 
+fn native_emission_controls_binding() -> TargetBinding {
+  TargetBinding { target: native_emission_controls_label() producer: NativeClaimProgramProducer { entry: native_emission_controls_entry() } }
+}
+
 fn dag_emit_real_grammar_round_trips_binding() -> TargetBinding {
   TargetBinding { target: dag_emit_real_grammar_round_trips_label() producer: NativeClaimProgramProducer { entry: dag_emit_real_grammar_round_trips_entry() } }
 }
@@ -652,7 +669,8 @@ fn instrument_targets() -> List<Label> {
     required_lane_resolution_census_label(), bare_reference_channel_outcome_label(),
     self_host_behavioral_equivalence_label(), dependency_demand_census_label(),
     emitted_crate_workspace_label(),
-    native_crypto_vectors_label(), native_app_attest_label(), dag_emit_real_grammar_round_trips_label()
+    native_crypto_vectors_label(), native_app_attest_label(), dag_emit_real_grammar_round_trips_label(),
+    native_emission_controls_label()
   ]
 }
 
@@ -667,7 +685,8 @@ fn instrument_bindings() -> List<TargetBinding> {
     required_lane_resolution_census_binding(), bare_reference_channel_outcome_binding(),
     self_host_behavioral_equivalence_binding(), dependency_demand_census_binding(),
     emitted_crate_workspace_binding(),
-    native_crypto_vectors_binding(), native_app_attest_binding(), dag_emit_real_grammar_round_trips_binding()
+    native_crypto_vectors_binding(), native_app_attest_binding(), dag_emit_real_grammar_round_trips_binding(),
+    native_emission_controls_binding()
   ]
 }
 
diff --git a/dag/gunbc/instruments/native_emission_controls.dag b/dag/gunbc/instruments/native_emission_controls.dag
new file mode 100644
index 00000000000..66231d1d616
--- /dev/null
+++ b/dag/gunbc/instruments/native_emission_controls.dag
@@ -0,0 +1,126 @@
+module gunbc.instruments.native_emission_controls
+
+import std.types { Bool, List, Set, String }
+import v2.std.algebra { filter }
+import std.compiler_entry { CompilerEntryDriver, NativeClaimDriver, NativeClaimReport, NativeClaimTerminal, NativeClaimHeld, NativeClaimNotHeld }
+
+// THE NATIVE EMISSION CONTROLS: one small carrier per Rust-emitter rule, EMITTED, BUILT AND RUN as a
+// NativeClaimDriver entry (std.compiler_entry). `gunbc test //gunbc/instruments:native-emission-controls`
+// emits this closure, builds it and runs it; nothing here is interpreted. A textual witness over the
+// emitted header (test.claim.generic_item_clone_bound_witness) says what the emitter PRINTED; only
+// rustc says whether what it printed is a program, and only a run says whether that program answers
+// correctly. So each rule's control is a carrier whose emission did not compile before the rule and
+// a set of cases over it whose answers are decided here -- a positive and a red per carrier, because
+// an impl that compiled and answered `true` for everything would pass a positive alone.
+//
+// A CONTROL THAT STOPS COMPILING IS NO OBSERVATION FOR THE WHOLE PROGRAM, and that is the intended
+// reading: every carrier in this module is one that must emit as compilable Rust, so one refusal at
+// rustc is a red on the label rather than a missing row.
+//
+// THE ROSTER IS DECLARED, NOT DERIVED FROM THE CASES, for the reason
+// gunbc.instruments.native_crypto_vectors states: the reader joins rows to this list by identity, so
+// a case that was dropped is a missing row and not a smaller green.
+data compiler_pipeline_entry: CompilerEntryDriver = NativeClaimDriver
+
+// RULE: a hand-written impl header carries the item header's bounds (v1.compiler.trait_derive_emit
+// v1_set_impl_type_params / v1_freemonoid_impl_type_params). ControlContext<C, P> is the shape of
+// std.authorization_profile PublicationContext: P reaches a Set only through ControlAudience<P>, so
+// Debug and PartialEq leave the derive list and are written by hand with `P: Ord`, while the bare
+// `context: C` field earns `C: Clone` on the struct header. The hand-written headers used to print
+// `impl<C: PartialEq, P: Ord + PartialEq>`, which rustc refuses at `ControlContext<C, P>` (E0277:
+// `C: Clone` is not satisfied). ControlDisclosure adds the List<F> field of DisclosureRequest, whose
+// `==` needs `F: Clone` for the same reason.
+type ControlAudience<P>
+  = ControlEveryone
+  | ControlListed { members: Set<P> }
+
+type ControlContext<C, P> {
+  audience: ControlAudience<P>
+  context: C
+}
+
+type ControlDisclosure<P, F, C> {
+  principal: P
+  fields: List<F>
+  audience: ControlAudience<P>
+  context: C
+}
+
+type NativeEmissionCase {
+  identity: String
+  held: Bool
+}
+
+fn control_listed(names: List<String>) -> ControlAudience<String> {
+  ControlListed { members: names |> fold(init: empty_set(), f: (acc, n) => set_insert(acc, n)) }
+}
+
+fn control_context(names: List<String>, context: String) -> ControlContext<String, String> {
+  ControlContext { audience: control_listed(names: names), context: context }
+}
+
+fn control_disclosure(fields: List<String>, names: List<String>) -> ControlDisclosure<String, String, String> {
+  ControlDisclosure { principal: "p", fields: fields, audience: control_listed(names: names), context: "c" }
+}
+
+fn header_bound_cases() -> List<NativeEmissionCase> {
+  [
+    NativeEmissionCase {
+      identity: "set_struct_eq_same_members_in_another_order",
+      held: control_context(names: ["a", "b"], context: "x") == control_context(names: ["b", "a"], context: "x")
+    },
+    NativeEmissionCase {
+      identity: "set_struct_eq_red_bare_field_differs",
+      held: !(control_context(names: ["a", "b"], context: "x") == control_context(names: ["a", "b"], context: "y"))
+    },
+    NativeEmissionCase {
+      identity: "set_struct_eq_red_set_member_differs",
+      held: !(control_context(names: ["a", "b"], context: "x") == control_context(names: ["a", "c"], context: "x"))
+    },
+    NativeEmissionCase {
+      identity: "set_struct_eq_red_everyone_is_not_a_listing",
+      held: !(ControlContext { audience: ControlEveryone, context: "x" } == control_context(names: [], context: "x"))
+    },
+    NativeEmissionCase {
+      identity: "set_and_list_struct_eq_same_fields",
+      held: control_disclosure(fields: ["f", "g"], names: ["a"]) == control_disclosure(fields: ["f", "g"], names: ["a"])
+    },
+    NativeEmissionCase {
+      identity: "set_and_list_struct_eq_red_list_order_differs",
+      held: !(control_disclosure(fields: ["f", "g"], names: ["a"]) == control_disclosure(fields: ["g", "f"], names: ["a"]))
+    }
+  ]
+}
+
+data native_emission_expected_identities: List<String> = [
+  "set_struct_eq_same_members_in_another_order",
+  "set_struct_eq_red_bare_field_differs",
+  "set_struct_eq_red_set_member_differs",
+  "set_struct_eq_red_everyone_is_not_a_listing",
+  "set_and_list_struct_eq_same_fields",
+  "set_and_list_struct_eq_red_list_order_differs"
+]
+
+fn native_emission_cases() -> List<NativeEmissionCase> {
+  header_bound_cases()
+}
+
+fn case_row(c: NativeEmissionCase) -> String {
+  concat("case ", concat(c.identity, concat(if c.held { " held" } else { " not_held" }, concat(" observed=", concat(if c.held { "as_decided" } else { "other_answer" }, "\n")))))
+}
+
+fn native_claim_report() -> NativeClaimReport {
+  let cases = native_emission_cases()
+  let roster = concat("roster ", concat(native_emission_expected_identities |> join(separator: ","), "\n"))
+  let failed = cases |> filter(c => !c.held) |> map(c => c.identity)
+  let terminal = if (failed |> count) == 0 { held_terminal() } else { not_held_terminal(reason: concat("not held: ", failed |> join(separator: ","))) }
+  NativeClaimReport { stdout: concat(roster, cases |> map(c => case_row(c: c)) |> join(separator: "")), terminal: terminal }
+}
+
+fn held_terminal() -> NativeClaimTerminal {
+  NativeClaimHeld
+}
+
+fn not_held_terminal(reason: String) -> NativeClaimTerminal {
+  NativeClaimNotHeld { reason: reason }
+}
diff --git a/dag/test/claim/generic_item_clone_bound_witness_test.dag b/dag/test/claim/generic_item_clone_bound_witness_test.dag
index 4155bf5f8f3..1195b74b886 100644
--- a/dag/test/claim/generic_item_clone_bound_witness_test.dag
+++ b/dag/test/claim/generic_item_clone_bound_witness_test.dag
@@ -164,7 +164,7 @@ test fn unbounded_declared_container_negative_control() -> Bool {
 // proving the WF trigger does not widen to every fn touching a declared type.
 // w_impl_accessor_inherits_item_bound_once locks in the already-correct IMPL-side behavior
 // (accessor impl blocks read the struct's own item-level clone_bounded_type_params via
-// emit_item_type_params_with_clone_bounds, not a fn-grain re-derivation) by asserting the accessor
+// emit_type_params_from_clone_param_names, not a fn-grain re-derivation) by asserting the accessor
 // impl header carries the bound exactly once, with doubled-spelling refusals mirroring
 // both_triggers_render_single_bound above.
 
@@ -407,3 +407,61 @@ test fn freemonoid_supplemental_struct_hand_written_impls() -> Bool {
 test fn freemonoid_supplemental_enum_hand_written_impls() -> Bool {
   w_freemonoid_supplemental_enum_hand_written_impls()
 }
+
+// A HAND-WRITTEN IMPL HEADER CARRIES ITS ITEM HEADER'S BOUNDS. The Set route removes Debug and
+// PartialEq from the derive list and writes them by hand, with the trait's own requirement on each
+// parameter. A derive would also have copied the DECLARATION's bounds onto the impl; the hand-written
+// header did not, so an item whose header earns `C: Clone` from a bare field emitted
+// `impl<C: std::fmt::Debug, P: Ord + std::fmt::Debug> std::fmt::Debug for HdrCtx<C, P>`, which rustc
+// refuses at the `for` type (E0277, `C: Clone` not satisfied) -- the std.authorization_profile
+// PublicationContext shape. The header list is taken from the same decision the struct line printed,
+// so the two are asserted TOGETHER here: the struct header and both impl headers in one emission.
+//
+// THE CONVERSE ARM IS WHAT KEEPS THIS FROM BEING "PUT Clone ON EVERYTHING". The coproduct in the
+// same fixture declares a BARE header (a Set field earns no declaration bound), so its hand-written
+// impls must stay exactly `P: Ord + ..` -- a rule that unioned Clone onto every hand-written impl
+// would pass the positive arm and over-bound this one. And P on the struct stays without Clone for
+// the same reason: the struct header does not bound it. The native half -- that the emission is a
+// program rustc accepts and that `==` answers correctly over it -- is
+// gunbc.instruments.native_emission_controls.
+fn w_set_struct_hand_written_impls_carry_header_bounds() -> Bool {
+  compile_dag_rust_emit_check(
+    "module probe_hdr_set\n\nimport std.types { Set }\n\ntype HdrAud<P>\n  = HdrEveryone\n  | HdrListed { members: Set<P> }\n\ntype HdrCtx<C, P> {\n  audience: HdrAud<P>\n  context: C\n}\n",
+    "src/probe_hdr_set.rs",
+    [
+      "pub struct HdrCtx<C: Clone, P>",
+      "impl<C: Clone + std::fmt::Debug, P: Ord + std::fmt::Debug> std::fmt::Debug for HdrCtx<C, P>",
+      "impl<C: Clone + PartialEq, P: Ord + PartialEq> PartialEq for HdrCtx<C, P>"
+    ],
+    [
+      "impl<C: std::fmt::Debug, P: Ord + std::fmt::Debug> std::fmt::Debug for HdrCtx<C, P>",
+      "impl<C: PartialEq, P: Ord + PartialEq> PartialEq for HdrCtx<C, P>",
+      "compile_error"
+    ]
+  )
+}
+
+fn w_set_coproduct_hand_written_impls_stay_at_the_bare_header() -> Bool {
+  compile_dag_rust_emit_check(
+    "module probe_hdr_set_bare\n\nimport std.types { Set }\n\ntype HdrAud<P>\n  = HdrEveryone\n  | HdrListed { members: Set<P> }\n\ntype HdrCtx<C, P> {\n  audience: HdrAud<P>\n  context: C\n}\n",
+    "src/probe_hdr_set_bare.rs",
+    [
+      "pub enum HdrAud<P>",
+      "impl<P: Ord + std::fmt::Debug> std::fmt::Debug for HdrAud<P>",
+      "impl<P: Ord + PartialEq> PartialEq for HdrAud<P>"
+    ],
+    [
+      "impl<P: Clone + Ord + std::fmt::Debug> std::fmt::Debug for HdrAud<P>",
+      "P: Clone + Ord + std::fmt::Debug> std::fmt::Debug for HdrCtx<C, P>",
+      "compile_error"
+    ]
+  )
+}
+
+test fn set_struct_hand_written_impls_carry_header_bounds() -> Bool {
+  w_set_struct_hand_written_impls_carry_header_bounds()
+}
+
+test fn set_coproduct_hand_written_impls_stay_at_the_bare_header() -> Bool {
+  w_set_coproduct_hand_written_impls_stay_at_the_bare_header()
+}
diff --git a/src/v1/05_emit_rust.dag b/src/v1/05_emit_rust.dag
index 116c353942b..ebefef52820 100644
--- a/src/v1/05_emit_rust.dag
+++ b/src/v1/05_emit_rust.dag
@@ -7718,6 +7718,12 @@ fn function_type_params_have_collision(type_params: List<Node>) -> Bool {
 // that answers it and both surfaces read the same list. Splitting `has_fn_fields` without this
 // would have put the two out of step: the header would gain a WF bound the impl header did not,
 // which does not compile.
+//
+// EVERY hand-written impl for the item reads this list, not only GroupCompletion's: the
+// FreeMonoid and Set supplemental Debug/PartialEq impls (v1.compiler.trait_derive_emit
+// v1_freemonoid_impl_type_params / v1_set_impl_type_params) take it as a parameter and union it
+// under the trait's own requirement. They used to render from the trait requirement alone, which
+// is the out-of-step state this note describes, reached through a second door.
 fn emit_item_header_clone_param_names(
   item: Node,
   item_name: String,
@@ -7756,47 +7762,17 @@ fn emit_type_params_from_clone_param_names(
   }
 }
 
-fn emit_item_type_params_with_clone_bounds(item_name: String, params: List<Node>, emit_info: EmitGraphInfo, source_indices: Map<String, NewlineIndex>) -> String {
-  let generic_param_names = params |> map(p => generic_param_name_at(n: p, source_indices: source_indices))
-  let clone_param_names = v1_item_clone_bounded_param_names(
-    item_name: item_name,
-    generic_param_names: generic_param_names,
-    bounds: emit_info.clone_bounded_type_params
-  )
-  if (clone_param_names |> count) > 0 {
-    v1_emit_type_params_with_clone_bounds(params: params, clone_param_names: clone_param_names, source_indices: source_indices)
-  } else {
-    emit_type_params(params: params, source_indices: source_indices)
-  }
-}
-
-// The SINGLE well-formedness fact the GroupCompletion supplemental impls need, read from the same
-// record `emit_item_type_params_with_clone_bounds` reads (`clone_bounded_type_params`) rather than
-// re-derived beside it. Rust REQUIRES an impl's generics to satisfy the type's own bounds, so
-// `struct S<M: Clone>` with `impl<M> Neg for S<M>` cannot compile: the item header and the impl
-// header are ONE decision rendered twice, which makes single authority the construction answer
-// here rather than a style preference.
-//
-// What crosses into `extdeps.languages.rust.emit` is this Bool — a compiler fact about the
-// carrier's declaration. The SPELLING (`Clone`, the trait paths, the where-clauses) stays in
-// extdeps, so the §3 duty is intact. It is deliberately NOT routed through
-// `spelling.where_bounds`: that field carries the OP's own requirement (a fact about `Neg`/`Add`),
-// and the carrier bound is a fact about `GroupCompletion` — merging them would recreate the fused
-// flag this change exists to split, and the two have different lifetimes (a new op row changes
-// where_bounds and never changes the carrier's WF bound).
+// THE GroupCompletion SUPPLEMENTAL IMPLS READ THE SAME DECISION. What crosses into
+// `extdeps.languages.rust.emit` is one Bool derived from the header list at the capability table
+// (`v1_emit_struct_from_capability_table`) -- a compiler fact about the carrier's declaration. The
+// SPELLING (`Clone`, the trait paths, the where-clauses) stays in extdeps, so the §3 duty is
+// intact. It is deliberately NOT routed through `spelling.where_bounds`: that field carries the
+// OP's own requirement (a fact about `Neg`/`Add`), and the carrier bound is a fact about
+// `GroupCompletion` -- merging them would recreate the fused flag that split exists to remove.
 //
 // KNOWN ASYMMETRY, named rather than fixed here: the item header is rendered compiler-side
-// (`emit_item_type_params_with_clone_bounds`) while the impl header is rendered in extdeps, so the
-// tree answers "where does a Rust bound get spelled" two different ways. Out of scope for this
-// change.
-fn v1_carrier_param_needs_clone_bound(item_name: String, generic_param_names: List<String>, emit_info: EmitGraphInfo) -> Bool {
-  (v1_item_clone_bounded_param_names(
-    item_name: item_name,
-    generic_param_names: generic_param_names,
-    bounds: emit_info.clone_bounded_type_params
-  ) |> count) > 0
-}
-
+// (`emit_type_params_from_clone_param_names`) while the GroupCompletion impl header is rendered in
+// extdeps, so the tree answers "where does a Rust bound get spelled" two different ways.
 fn emit_item_clone_bound_refusal(item: Node, item_name: String, emit_info: EmitGraphInfo, source_indices: Map<String, NewlineIndex>) -> String {
   if (item.params |> count) == 0 {
     ""
@@ -7815,7 +7791,7 @@ fn emit_item_clone_bound_refusal(item: Node, item_name: String, emit_info: EmitG
 }
 
 // Struct header bareness is keyed on the FIELD-DERIVED property, not on `impl_bodies` being
-// nonempty. `emit_item_type_params_with_clone_bounds` reads `clone_bounded_type_params`, the
+// nonempty. `emit_item_header_clone_param_names` reads `clone_bounded_type_params`, the
 // WELL-FORMEDNESS fixpoint — "does NAMING G<A..> require P: Clone" — which is exactly "does some
 // field's type require this parameter to carry a bound".
 //
@@ -7893,19 +7869,6 @@ fn emit_type_def_from_connective(item: Node, recursive_types: Set<String>, share
     )
     let sealed = item_seals_construction(item: item)
     let deserialize_forbidden = item_forbids_deserialize(item: item, emit_info: emit_info, source_indices: env.source_indices)
-    let capability_surface = v1_emit_struct_from_capability_table(
-      module_path: env.module_path,
-      name: item_text,
-      children: item.children,
-      shared_types: shared_types,
-      has_fn_fields: has_fn_fields,
-      map_key_required: set_contains(emit_info.map_key_required_type_names, item_text),
-      generic_param_names: item.params |> map(p => generic_param_name_at(n: p, source_indices: env.source_indices)),
-      source_indices: env.source_indices,
-      carrier_param_needs_clone: (header_clone_param_names |> count) > 0,
-      deserialize_forbidden: deserialize_forbidden,
-      type_decl_items: emit_info.type_decl_items
-    )
     let type_params = emit_type_params_from_clone_param_names(
       params: item.params,
       clone_param_names: header_clone_param_names,
@@ -7913,7 +7876,7 @@ fn emit_type_def_from_connective(item: Node, recursive_types: Set<String>, share
     )
     let generic_param_names = item.params |> map(p => generic_param_name_at(n: p, source_indices: env.source_indices))
     let clone_bound_refusal = emit_item_clone_bound_refusal(item: item, item_name: item_text, emit_info: emit_info, source_indices: env.source_indices)
-    let struct_text = emit_struct_from_children(name: item_text, type_params: type_params, generic_param_names: generic_param_names, children: item.children, recursive_types: recursive_types, shared_types: shared_types, sealed: sealed, deserialize_forbidden: deserialize_forbidden, env: env, emit_info: emit_info)
+    let struct_text = emit_struct_from_children(name: item_text, type_params: type_params, generic_param_names: generic_param_names, header_clone_param_names: header_clone_param_names, children: item.children, recursive_types: recursive_types, shared_types: shared_types, sealed: sealed, deserialize_forbidden: deserialize_forbidden, env: env, emit_info: emit_info)
     if clone_bound_refusal == "" { struct_text } else { concat(clone_bound_refusal, "\n", struct_text) }
   } else if is_host_optional_carrier_alias(name: item_text) {
     let type_params = emit_type_params(params: item.params, source_indices: env.source_indices)
@@ -7940,10 +7903,22 @@ fn emit_type_def_from_connective(item: Node, recursive_types: Set<String>, share
     } else {
       concat(policy_validation, "\n", rename_validations)
     }
-    let type_params = emit_item_type_params_with_clone_bounds(item_name: item_text, params: item.params, emit_info: emit_info, source_indices: env.source_indices)
     let generic_param_names = item.params |> map(p => generic_param_name_at(n: p, source_indices: env.source_indices))
+    let header_clone_param_names = emit_item_header_clone_param_names(
+      item: item,
+      item_name: item_text,
+      has_fn_fields: false,
+      generic_param_names: generic_param_names,
+      emit_info: emit_info,
+      source_indices: env.source_indices
+    )
+    let type_params = emit_type_params_from_clone_param_names(
+      params: item.params,
+      clone_param_names: header_clone_param_names,
+      source_indices: env.source_indices
+    )
     let clone_bound_refusal = emit_item_clone_bound_refusal(item: item, item_name: item_text, emit_info: emit_info, source_indices: env.source_indices)
-    let enum_text = emit_enum_from_children(name: item_text, type_params: type_params, generic_param_names: generic_param_names, children: item.children, recursive_types: recursive_types, shared_types: shared_types, env: env, serde_policy: serde_policy, emit_info: emit_info)
+    let enum_text = emit_enum_from_children(name: item_text, type_params: type_params, generic_param_names: generic_param_names, header_clone_param_names: header_clone_param_names, children: item.children, recursive_types: recursive_types, shared_types: shared_types, env: env, serde_policy: serde_policy, emit_info: emit_info)
     let validations = if clone_bound_refusal == "" {
       validations
     } else if validations == "" {
@@ -8051,7 +8026,7 @@ fn emit_sealed_struct_accessors(name: String, type_params: String, generic_param
   concat("\nimpl", type_params, " ", name, type_application_params, " {\n", fns_str, "\n}")
 }
 
-fn emit_struct_from_children(name: String, type_params: String, generic_param_names: List<String>, children: List<Node>, recursive_types: Set<String>, shared_types: Set<String>, sealed: Bool, deserialize_forbidden: Bool, env: TypeEnv, emit_info: EmitGraphInfo) -> String {
+fn emit_struct_from_children(name: String, type_params: String, generic_param_names: List<String>, header_clone_param_names: List<String>, children: List<Node>, recursive_types: Set<String>, shared_types: Set<String>, sealed: Bool, deserialize_forbidden: Bool, env: TypeEnv, emit_info: EmitGraphInfo) -> String {
   let has_fn_fields = type_has_fn_fields(name: name, emit_info: emit_info)
   let surface = v1_emit_struct_from_capability_table(
     module_path: env.module_path,
@@ -8062,11 +8037,7 @@ fn emit_struct_from_children(name: String, type_params: String, generic_param_na
     map_key_required: set_contains(emit_info.map_key_required_type_names, name),
     generic_param_names: generic_param_names,
     source_indices: env.source_indices,
-    carrier_param_needs_clone: v1_carrier_param_needs_clone_bound(
-      item_name: name,
-      generic_param_names: generic_param_names,
-      emit_info: emit_info
-    ),
+    header_clone_param_names: header_clone_param_names,
     deserialize_forbidden: deserialize_forbidden,
     type_decl_items: emit_info.type_decl_items
   )
@@ -8258,7 +8229,7 @@ fn enum_derives(name: String, children: List<Node>, has_fn_fields: Bool, deseria
 // in this scope" -- trading one error for another rather than removing it. The derive decision
 // and the attribute decision are therefore one decision with two renderings, and both read the
 // same has_fn_fields here rather than deriving it twice.
-fn emit_enum_from_children(name: String, type_params: String, generic_param_names: List<String>, children: List<Node>, recursive_types: Set<String>, shared_types: Set<String>, env: TypeEnv, serde_policy: RustEnumWireSerde, emit_info: EmitGraphInfo) -> String {
+fn emit_enum_from_children(name: String, type_params: String, generic_param_names: List<String>, header_clone_param_names: List<String>, children: List<Node>, recursive_types: Set<String>, shared_types: Set<String>, env: TypeEnv, serde_policy: RustEnumWireSerde, emit_info: EmitGraphInfo) -> String {
   let has_fn_fields = type_has_fn_fields(name: name, emit_info: emit_info)
   let deserialize_forbidden = members_forbid_deserialize(name: name, members: member_type_nodes(is_product: false, children: children), emit_info: emit_info, source_indices: env.source_indices)
   let derives = enum_derives(name: name, children: children, has_fn_fields: has_fn_fields, deserialize_forbidden: deserialize_forbidden, generic_param_names: generic_param_names, emit_info: emit_info, source_indices: env.source_indices)
@@ -8270,7 +8241,7 @@ fn emit_enum_from_children(name: String, type_params: String, generic_param_name
   let tag_line = if effective_serde_policy.enum_attr == "" { "" } else { concat(effective_serde_policy.enum_attr, "\n") }
   let enum_def = concat(derives, "\n", tag_line, rust_visibility_prefix(), rust_items().enum_keyword, " ", name, type_params, " {\n", variants_str, "\n}")
   let accessor_impl = emit_enum_shared_accessors(name: name, type_params: type_params, generic_param_names: generic_param_names, children: children, recursive_types: recursive_types, shared_types: shared_types, env: env, emit_info: emit_info)
-  let supplemental = v1_emit_enum_supplemental_impls(module_path: env.module_path, name: name, children: children, generic_param_names: generic_param_names, source_indices: env.source_indices)
+  let supplemental = v1_emit_enum_supplemental_impls(module_path: env.module_path, name: name, children: children, generic_param_names: generic_param_names, header_clone_param_names: header_clone_param_names, source_indices: env.source_indices)
   let with_accessors = if accessor_impl == "" { enum_def } else { concat(enum_def, "\n", accessor_impl) }
   if supplemental == "" { with_accessors } else { concat(with_accessors, supplemental) }
 }
diff --git a/src/v1/stage0/src/target_invocation_host.rs b/src/v1/stage0/src/target_invocation_host.rs
index 8f38a0e46c2..7f446fdbd6b 100644
--- a/src/v1/stage0/src/target_invocation_host.rs
+++ b/src/v1/stage0/src/target_invocation_host.rs
@@ -363,6 +363,12 @@ fn instrument_registry() -> Vec<(Label, TargetProducer)> {
                 entry: "dag/gunbc/instruments/dag_emit_real_grammar_round_trips.dag",
             },
         ),
+        (
+            instrument_label("native-emission-controls"),
+            TargetProducer::NativeClaimProgram {
+                entry: "dag/gunbc/instruments/native_emission_controls.dag",
+            },
+        ),
         (
             instrument_label("evaluation-store-address-exact-head"),
             TargetProducer::EvaluationStoreAddressExactHead,
diff --git a/src/v1/trait_derive_emit.dag b/src/v1/trait_derive_emit.dag
index e1bd7f6322d..d892ffde1ac 100644
--- a/src/v1/trait_derive_emit.dag
+++ b/src/v1/trait_derive_emit.dag
@@ -93,9 +93,10 @@ data trait_derive_emit_item_clone_bound_wf_propagation_note: String = "SECOND, I
 // (v1_type_param_needs_clone_bound: bare-generic return or direct container-element usage) computed
 // in v1_generic_params_needing_clone_bound — the two triggers answer different questions
 // (usage-shape vs. naming-a-bounded-declared-type) and a fn param needing either earns the bound.
-// Enum/struct IMPL surfaces (accessor impl blocks, supplemental impls) already inherit their item's
-// bounded type_params string from emit_item_type_params_with_clone_bounds at the struct/enum decl
-// site, so no separate IMPL-side propagation is needed there; the gap closed here is specifically
+// Enum/struct accessor impl blocks already inherit their item's bounded type_params string from
+// emit_type_params_from_clone_param_names at the struct/enum decl site, and the hand-written
+// supplemental impls take the same header list as a parameter (v1_item_header_bound_spellings), so
+// no separate IMPL-side derivation exists; the gap closed here is specifically
 // free FN declarations, whose type_params were computed independently of the item-level fixpoint.
 // Discovered live (not hypothetical) in deep-heron's honest regen of
 // dag/std/occurrence_binding.dag: occurrence_binding_from_candidates<N> names BindingOccurrence<N>
@@ -506,8 +507,25 @@ fn v1_freemonoid_supplemental_bound_spelling() -> String {
     |> join(separator: " + ")
 }
 
+// THE ITEM HEADER'S BOUNDS ARE PART OF EVERY HAND-WRITTEN IMPL HEADER FOR THAT ITEM. Rust requires
+// an impl's generics to satisfy the bounds the type itself declares, so `struct S<C: Clone, P>` with
+// `impl<C: Debug, P: Ord + Debug> Debug for S<C, P>` is ill-formed at `S<C, P>` (E0277) whatever the
+// impl body does. A derive never meets this: the macro copies the declaration's own bounds onto the
+// impl it writes. A hand-written impl replaces the macro, so it owes the same copy -- and the copy
+// is taken from the ONE header decision the item's declaration printed
+// (v1.compiler.emit_rust emit_item_header_clone_param_names), never re-derived here, so the two
+// headers cannot disagree. The trait's own requirement (the supplemental row and the structural
+// spelling) is unioned on top, deduplicated because a FreeMonoid row and the header may both say
+// Clone. Receipt: std.authorization_profile PublicationContext<C: Clone, P> and
+// DisclosureRequest<P: Clone, R: Clone, F: Clone, C: Clone, E: Clone>, whose Set-propagated Debug
+// and PartialEq impls emitted without the header bounds.
+fn v1_item_header_bound_spellings(param_name: String, header_clone_param_names: List<String>) -> List<String> {
+  if header_clone_param_names |> any(h => h == param_name) { ["Clone"] } else { [] }
+}
+
 fn v1_freemonoid_impl_type_params(
   generic_param_names: List<String>,
+  header_clone_param_names: List<String>,
   fm_params: List<String>,
   field_type_exprs: List<Node>,
   structural_spelling: String,
@@ -516,9 +534,10 @@ fn v1_freemonoid_impl_type_params(
   if (generic_param_names |> count) == 0 { "" } else {
     let entries = generic_param_names |> map(p =>
       let pascal = to_pascal(name: p)
+      let header = v1_item_header_bound_spellings(param_name: p, header_clone_param_names: header_clone_param_names)
       let supplemental = if fm_params |> any(f => f == p) { [v1_freemonoid_supplemental_bound_spelling()] } else { [] }
       let structural = if v1_freemonoid_param_in_fields(param_name: p, field_type_exprs: field_type_exprs, source_indices: source_indices) { [structural_spelling] } else { [] }
-      let parts = concat(supplemental, structural)
+      let parts = unique_strings(items: concat(header, concat(supplemental, structural)))
       if (parts |> count) == 0 { pascal } else { concat(pascal, ": ", parts |> join(separator: " + ")) }
     )
     concat("<", entries |> join(separator: ", "), ">")
@@ -682,12 +701,13 @@ fn v1_set_serde_bound_attr_for_traits(
 fn v1_freemonoid_struct_debug_impl(
   name: String,
   generic_param_names: List<String>,
+  header_clone_param_names: List<String>,
   fm_params: List<String>,
   children: List<Node>,
   field_type_exprs: List<Node>,
   source_indices: Map<String, NewlineIndex>
 ) -> String {
-  let tp = v1_freemonoid_impl_type_params(generic_param_names: generic_param_names, fm_params: fm_params, field_type_exprs: field_type_exprs, structural_spelling: "std::fmt::Debug", source_indices: source_indices)
+  let tp = v1_freemonoid_impl_type_params(generic_param_names: generic_param_names, header_clone_param_names: header_clone_param_names, fm_params: fm_params, field_type_exprs: field_type_exprs, structural_spelling: "std::fmt::Debug", source_indices: source_indices)
   let args = v1_freemonoid_bare_type_args(generic_param_names: generic_param_names)
   let field_calls = children |> map(f =>
     let ident = emit_ident(name: authored_name_at(source_indices: source_indices, node: f), target: Rust)
@@ -705,12 +725,13 @@ fn v1_freemonoid_struct_debug_impl(
 fn v1_freemonoid_struct_partial_eq_impl(
   name: String,
   generic_param_names: List<String>,
+  header_clone_param_names: List<String>,
   fm_params: List<String>,
   children: List<Node>,
   field_type_exprs: List<Node>,
   source_indices: Map<String, NewlineIndex>
 ) -> String {
-  let tp = v1_freemonoid_impl_type_params(generic_param_names: generic_param_names, fm_params: fm_params, field_type_exprs: field_type_exprs, structural_spelling: "PartialEq", source_indices: source_indices)
+  let tp = v1_freemonoid_impl_type_params(generic_param_names: generic_param_names, header_clone_param_names: header_clone_param_names, fm_params: fm_params, field_type_exprs: field_type_exprs, structural_spelling: "PartialEq", source_indices: source_indices)
   let args = v1_freemonoid_bare_type_args(generic_param_names: generic_param_names)
   let comparisons = children |> map(f =>
     let ident = emit_ident(name: authored_name_at(source_indices: source_indices, node: f), target: Rust)
@@ -729,12 +750,13 @@ fn v1_freemonoid_struct_partial_eq_impl(
 fn v1_freemonoid_enum_debug_impl(
   name: String,
   generic_param_names: List<String>,
+  header_clone_param_names: List<String>,
   fm_params: List<String>,
   children: List<Node>,
   field_type_exprs: List<Node>,
   source_indices: Map<String, NewlineIndex>
 ) -> String {
-  let tp = v1_freemonoid_impl_type_params(generic_param_names: generic_param_names, fm_params: fm_params, field_type_exprs: field_type_exprs, structural_spelling: "std::fmt::Debug", source_indices: source_indices)
+  let tp = v1_freemonoid_impl_type_params(generic_param_names: generic_param_names, header_clone_param_names: header_clone_param_names, fm_params: fm_params, field_type_exprs: field_type_exprs, structural_spelling: "std::fmt::Debug", source_indices: source_indices)
   let args = v1_freemonoid_bare_type_args(generic_param_names: generic_param_names)
   let arms = children |> map(variant =>
     let vname = to_pascal(name: authored_name_at(source_indices: source_indices, node: variant))
@@ -761,12 +783,13 @@ fn v1_freemonoid_enum_debug_impl(
 fn v1_freemonoid_enum_partial_eq_impl(
   name: String,
   generic_param_names: List<String>,
+  header_clone_param_names: List<String>,
   fm_params: List<String>,
   children: List<Node>,
   field_type_exprs: List<Node>,
   source_indices: Map<String, NewlineIndex>
 ) -> String {
-  let tp = v1_freemonoid_impl_type_params(generic_param_names: generic_param_names, fm_params: fm_params, field_type_exprs: field_type_exprs, structural_spelling: "PartialEq", source_indices: source_indices)
+  let tp = v1_freemonoid_impl_type_params(generic_param_names: generic_param_names, header_clone_param_names: header_clone_param_names, fm_params: fm_params, field_type_exprs: field_type_exprs, structural_spelling: "PartialEq", source_indices: source_indices)
   let args = v1_freemonoid_bare_type_args(generic_param_names: generic_param_names)
   let arms = children |> map(variant =>
     let vname = to_pascal(name: authored_name_at(source_indices: source_indices, node: variant))
@@ -794,6 +817,7 @@ fn v1_freemonoid_enum_partial_eq_impl(
 
 fn v1_set_impl_type_params(
   generic_param_names: List<String>,
+  header_clone_param_names: List<String>,
   set_params: List<String>,
   field_type_exprs: List<Node>,
   structural_spelling: String,
@@ -803,9 +827,10 @@ fn v1_set_impl_type_params(
   if (generic_param_names |> count) == 0 { "" } else {
     let entries = generic_param_names |> map(p =>
       let pascal = to_pascal(name: p)
+      let header = v1_item_header_bound_spellings(param_name: p, header_clone_param_names: header_clone_param_names)
       let supplemental = if set_params |> any(f => f == p) { [v1_set_supplemental_bound_spelling_for(derive_trait)] } else { [] }
       let structural = if v1_freemonoid_param_in_fields(param_name: p, field_type_exprs: field_type_exprs, source_indices: source_indices) { [structural_spelling] } else { [] }
-      let parts = concat(supplemental, structural)
+      let parts = unique_strings(items: concat(header, concat(supplemental, structural)))
       if (parts |> count) == 0 { pascal } else { concat(pascal, ": ", parts |> join(separator: " + ")) }
     )
     concat("<", entries |> join(separator: ", "), ">")
@@ -815,12 +840,13 @@ fn v1_set_impl_type_params(
 fn v1_set_enum_debug_impl(
   name: String,
   generic_param_names: List<String>,
+  header_clone_param_names: List<String>,
   set_params: List<String>,
   children: List<Node>,
   field_type_exprs: List<Node>,
   source_indices: Map<String, NewlineIndex>
 ) -> String {
-  let tp = v1_set_impl_type_params(generic_param_names: generic_param_names, set_params: set_params, field_type_exprs: field_type_exprs, structural_spelling: "std::fmt::Debug", derive_trait: RustDebug, source_indices: source_indices)
+  let tp = v1_set_impl_type_params(generic_param_names: generic_param_names, header_clone_param_names: header_clone_param_names, set_params: set_params, field_type_exprs: field_type_exprs, structural_spelling: "std::fmt::Debug", derive_trait: RustDebug, source_indices: source_indices)
   let args = v1_freemonoid_bare_type_args(generic_param_names: generic_param_names)
   let arms = children |> map(variant =>
     let vname = to_pascal(name: authored_name_at(source_indices: source_indices, node: variant))
@@ -847,12 +873,13 @@ fn v1_set_enum_debug_impl(
 fn v1_set_enum_partial_eq_impl(
   name: String,
   generic_param_names: List<String>,
+  header_clone_param_names: List<String>,
   set_params: List<String>,
   children: List<Node>,
   field_type_exprs: List<Node>,
   source_indices: Map<String, NewlineIndex>
 ) -> String {
-  let tp = v1_set_impl_type_params(generic_param_names: generic_param_names, set_params: set_params, field_type_exprs: field_type_exprs, structural_spelling: "PartialEq", derive_trait: RustPartialEq, source_indices: source_indices)
+  let tp = v1_set_impl_type_params(generic_param_names: generic_param_names, header_clone_param_names: header_clone_param_names, set_params: set_params, field_type_exprs: field_type_exprs, structural_spelling: "PartialEq", derive_trait: RustPartialEq, source_indices: source_indices)
   let args = v1_freemonoid_bare_type_args(generic_param_names: generic_param_names)
   let arms = children |> map(variant =>
     let vname = to_pascal(name: authored_name_at(source_indices: source_indices, node: variant))
@@ -992,12 +1019,13 @@ fn v1_item_ord_propagated_param_names(
 fn v1_set_struct_debug_impl(
   name: String,
   generic_param_names: List<String>,
+  header_clone_param_names: List<String>,
   set_params: List<String>,
   children: List<Node>,
   field_type_exprs: List<Node>,
   source_indices: Map<String, NewlineIndex>
 ) -> String {
-  let tp = v1_set_impl_type_params(generic_param_names: generic_param_names, set_params: set_params, field_type_exprs: field_type_exprs, structural_spelling: "std::fmt::Debug", derive_trait: RustDebug, source_indices: source_indices)
+  let tp = v1_set_impl_type_params(generic_param_names: generic_param_names, header_clone_param_names: header_clone_param_names, set_params: set_params, field_type_exprs: field_type_exprs, structural_spelling: "std::fmt::Debug", derive_trait: RustDebug, source_indices: source_indices)
   let args = v1_freemonoid_bare_type_args(generic_param_names: generic_param_names)
   let field_calls = children |> map(f =>
     let ident = emit_ident(name: authored_name_at(source_indices: source_indices, node: f), target: Rust)
@@ -1015,12 +1043,13 @@ fn v1_set_struct_debug_impl(
 fn v1_set_struct_partial_eq_impl(
   name: String,
   generic_param_names: List<String>,
+  header_clone_param_names: List<String>,
   set_params: List<String>,
   children: List<Node>,
   field_type_exprs: List<Node>,
   source_indices: Map<String, NewlineIndex>
 ) -> String {
-  let tp = v1_set_impl_type_params(generic_param_names: generic_param_names, set_params: set_params, field_type_exprs: field_type_exprs, structural_spelling: "PartialEq", derive_trait: RustPartialEq, source_indices: source_indices)
+  let tp = v1_set_impl_type_params(generic_param_names: generic_param_names, header_clone_param_names: header_clone_param_names, set_params: set_params, field_type_exprs: field_type_exprs, structural_spelling: "PartialEq", derive_trait: RustPartialEq, source_indices: source_indices)
   let args = v1_freemonoid_bare_type_args(generic_param_names: generic_param_names)
   let comparisons = children |> map(f =>
     let ident = emit_ident(name: authored_name_at(source_indices: source_indices, node: f), target: Rust)
@@ -2319,7 +2348,7 @@ fn v1_emit_type_params_with_bounds(
   }
 }
 
-// Adapter retained at its ORIGINAL signature on purpose: emit_item_type_params_with_clone_bounds
+// Adapter retained at its ORIGINAL signature on purpose: emit_type_params_from_clone_param_names
 // calls it, and that caller is out of scope for this lane, so generalizing in place would have
 // forced an edit there. Output is byte-identical to the literal it replaces --
 // concat(pascal, ": ", ["Clone"] |> join(" + ")) is concat(pascal, ": Clone").
@@ -2395,7 +2424,7 @@ fn v1_emit_struct_from_capability_table(
   map_key_required: Bool,
   generic_param_names: List<String>,
   source_indices: Map<String, NewlineIndex>,
-  carrier_param_needs_clone: Bool,
+  header_clone_param_names: List<String>,
   deserialize_forbidden: Bool,
   type_decl_items: Map<String, Node>
 ) -> StructCapabilityEmit {
@@ -2417,9 +2446,9 @@ fn v1_emit_struct_from_capability_table(
     )
     let impl_bodies = concat(
       "\n\n",
-      v1_freemonoid_struct_debug_impl(name: name, generic_param_names: generic_param_names, fm_params: fm_params, children: children, field_type_exprs: field_type_exprs, source_indices: source_indices),
+      v1_freemonoid_struct_debug_impl(name: name, generic_param_names: generic_param_names, header_clone_param_names: header_clone_param_names, fm_params: fm_params, children: children, field_type_exprs: field_type_exprs, source_indices: source_indices),
       "\n\n",
-      v1_freemonoid_struct_partial_eq_impl(name: name, generic_param_names: generic_param_names, fm_params: fm_params, children: children, field_type_exprs: field_type_exprs, source_indices: source_indices)
+      v1_freemonoid_struct_partial_eq_impl(name: name, generic_param_names: generic_param_names, header_clone_param_names: header_clone_param_names, fm_params: fm_params, children: children, field_type_exprs: field_type_exprs, source_indices: source_indices)
     )
     StructCapabilityEmit { derive_attr: derive_attr, impl_bodies: impl_bodies }
   } else {
@@ -2441,9 +2470,9 @@ fn v1_emit_struct_from_capability_table(
       )
       let impl_bodies = concat(
         "\n\n",
-        v1_set_struct_debug_impl(name: name, generic_param_names: generic_param_names, set_params: ord_propagated_params, children: children, field_type_exprs: field_type_exprs, source_indices: source_indices),
+        v1_set_struct_debug_impl(name: name, generic_param_names: generic_param_names, header_clone_param_names: header_clone_param_names, set_params: ord_propagated_params, children: children, field_type_exprs: field_type_exprs, source_indices: source_indices),
         "\n\n",
-        v1_set_struct_partial_eq_impl(name: name, generic_param_names: generic_param_names, set_params: ord_propagated_params, children: children, field_type_exprs: field_type_exprs, source_indices: source_indices)
+        v1_set_struct_partial_eq_impl(name: name, generic_param_names: generic_param_names, header_clone_param_names: header_clone_param_names, set_params: ord_propagated_params, children: children, field_type_exprs: field_type_exprs, source_indices: source_indices)
       )
       StructCapabilityEmit { derive_attr: derive_attr, impl_bodies: impl_bodies }
     } else {
@@ -2462,7 +2491,7 @@ fn v1_emit_struct_from_capability_table(
           kernel_int_arithmetic_traits(),
           ReprDeriveElemKernelInt
         ) {
-        rust_supplemental_impls_group_completion(carrier_param_needs_clone: carrier_param_needs_clone)
+        rust_supplemental_impls_group_completion(carrier_param_needs_clone: (header_clone_param_names |> count) > 0)
       } else {
         ""
       }
@@ -2480,6 +2509,7 @@ fn v1_emit_enum_supplemental_impls(
   name: String,
   children: List<Node>,
   generic_param_names: List<String>,
+  header_clone_param_names: List<String>,
   source_indices: Map<String, NewlineIndex>
 ) -> String {
   let field_type_exprs = v1_enum_variant_field_type_exprs(children: children)
@@ -2488,16 +2518,16 @@ fn v1_emit_enum_supplemental_impls(
   if (fm_params |> count) > 0 {
     concat(
       "\n\n",
-      v1_freemonoid_enum_debug_impl(name: name, generic_param_names: generic_param_names, fm_params: fm_params, children: children, field_type_exprs: field_type_exprs, source_indices: source_indices),
+      v1_freemonoid_enum_debug_impl(name: name, generic_param_names: generic_param_names, header_clone_param_names: header_clone_param_names, fm_params: fm_params, children: children, field_type_exprs: field_type_exprs, source_indices: source_indices),
       "\n\n",
-      v1_freemonoid_enum_partial_eq_impl(name: name, generic_param_names: generic_param_names, fm_params: fm_params, children: children, field_type_exprs: field_type_exprs, source_indices: source_indices)
+      v1_freemonoid_enum_partial_eq_impl(name: name, generic_param_names: generic_param_names, header_clone_param_names: header_clone_param_names, fm_params: fm_params, children: children, field_type_exprs: field_type_exprs, source_indices: source_indices)
     )
   } else if (set_params |> count) > 0 {
     concat(
       "\n\n",
-      v1_set_enum_debug_impl(name: name, generic_param_names: generic_param_names, set_params: set_params, children: children, field_type_exprs: field_type_exprs, source_indices: source_indices),
+      v1_set_enum_debug_impl(name: name, generic_param_names: generic_param_names, header_clone_param_names: header_clone_param_names, set_params: set_params, children: children, field_type_exprs: field_type_exprs, source_indices: source_indices),
       "\n\n",
-      v1_set_enum_partial_eq_impl(name: name, generic_param_names: generic_param_names, set_params: set_params, children: children, field_type_exprs: field_type_exprs, source_indices: source_indices)
+      v1_set_enum_partial_eq_impl(name: name, generic_param_names: generic_param_names, header_clone_param_names: header_clone_param_names, set_params: set_params, children: children, field_type_exprs: field_type_exprs, source_indices: source_indices)
     )
   } else if repr_grounding_supplemental_bool_host_bridge_target(module_path: module_path, name: name)
     && repr_grounding_derive_completeness_predicate(

From d1432938349bf1c9e0042658d425db926b1aff59 Mon Sep 17 00:00:00 2001
From: Brian Searls <briansearls1@gmail.com>
Date: Sat, 3 Oct 2026 19:15:57 +0000
Subject: [PATCH 2/2] emit_rust: regenerate the seed mirrors for the
 hand-written impl header bounds (fixed point verified at 561db6ba)

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 src/v1/stage0/src/v1_compiler_emit_rust.rs    | 105 ++++--------------
 .../src/v1_compiler_trait_derive_emit.rs      |  71 +++++++++++-
 2 files changed, 86 insertions(+), 90 deletions(-)

diff --git a/src/v1/stage0/src/v1_compiler_emit_rust.rs b/src/v1/stage0/src/v1_compiler_emit_rust.rs
index 1ad1763fdcd..e0d3a9b0b6f 100644
--- a/src/v1/stage0/src/v1_compiler_emit_rust.rs
+++ b/src/v1/stage0/src/v1_compiler_emit_rust.rs
@@ -16322,55 +16322,6 @@ pub fn emit_type_params_from_clone_param_names(
     }
 }
 
-pub fn emit_item_type_params_with_clone_bounds(
-    item_name: String,
-    params: Rc<Vec<Rc<Node>>>,
-    emit_info: Rc<EmitGraphInfo>,
-    source_indices: Rc<HashMap<String, Rc<NewlineIndex>>>,
-) -> String {
-    {
-        let generic_param_names = Rc::new({
-            let mut __result = Vec::new();
-            for p in params.iter().cloned() {
-                __result.push(crate::v1_std_core::generic_param_name_at(
-                    p.clone(),
-                    source_indices.clone(),
-                ));
-            }
-            __result
-        });
-        let clone_param_names =
-            crate::v1_compiler_trait_derive_emit::v1_item_clone_bounded_param_names(
-                item_name.clone(),
-                generic_param_names.clone(),
-                emit_info.clone_bounded_type_params.clone(),
-            );
-        if ((clone_param_names.clone().len() as i64) > 0) {
-            crate::v1_compiler_trait_derive_emit::v1_emit_type_params_with_clone_bounds(
-                params.clone(),
-                clone_param_names.clone(),
-                source_indices.clone(),
-            )
-        } else {
-            emit_type_params(params.clone(), source_indices.clone())
-        }
-    }
-}
-
-pub fn v1_carrier_param_needs_clone_bound(
-    item_name: String,
-    generic_param_names: Rc<Vec<String>>,
-    emit_info: Rc<EmitGraphInfo>,
-) -> bool {
-    ((crate::v1_compiler_trait_derive_emit::v1_item_clone_bounded_param_names(
-        item_name.clone(),
-        generic_param_names.clone(),
-        emit_info.clone_bounded_type_params.clone(),
-    )
-    .len() as i64)
-        > 0)
-}
-
 pub fn emit_item_clone_bound_refusal(
     item: Rc<Node>,
     item_name: String,
@@ -16435,32 +16386,6 @@ pub fn emit_type_def_from_connective(
                     emit_info.clone(),
                     env.source_indices.clone(),
                 );
-                let capability_surface =
-                    crate::v1_compiler_trait_derive_emit::v1_emit_struct_from_capability_table(
-                        env.module_path.clone(),
-                        item_text.clone(),
-                        item.children.clone(),
-                        shared_types.clone(),
-                        has_fn_fields.clone(),
-                        v1_rt::set_contains(
-                            &emit_info.map_key_required_type_names.clone(),
-                            item_text.clone(),
-                        ),
-                        Rc::new({
-                            let mut __result = Vec::new();
-                            for p in item.params.clone().iter().cloned() {
-                                __result.push(crate::v1_std_core::generic_param_name_at(
-                                    p.clone(),
-                                    env.source_indices.clone(),
-                                ));
-                            }
-                            __result
-                        }),
-                        env.source_indices.clone(),
-                        ((header_clone_param_names.clone().len() as i64) > 0),
-                        deserialize_forbidden.clone(),
-                        emit_info.type_decl_items.clone(),
-                    );
                 let type_params = emit_type_params_from_clone_param_names(
                     item.params.clone(),
                     header_clone_param_names.clone(),
@@ -16486,6 +16411,7 @@ pub fn emit_type_def_from_connective(
                     item_text.clone(),
                     type_params.clone(),
                     generic_param_names.clone(),
+                    header_clone_param_names.clone(),
                     item.children.clone(),
                     recursive_types.clone(),
                     shared_types.clone(),
@@ -16636,12 +16562,6 @@ pub fn emit_type_def_from_connective(
                                     )
                                 }
                             };
-                            let type_params = emit_item_type_params_with_clone_bounds(
-                                item_text.clone(),
-                                item.params.clone(),
-                                emit_info.clone(),
-                                env.source_indices.clone(),
-                            );
                             let generic_param_names = Rc::new({
                                 let mut __result = Vec::new();
                                 for p in item.params.clone().iter().cloned() {
@@ -16652,6 +16572,19 @@ pub fn emit_type_def_from_connective(
                                 }
                                 __result
                             });
+                            let header_clone_param_names = emit_item_header_clone_param_names(
+                                item.clone(),
+                                item_text.clone(),
+                                false,
+                                generic_param_names.clone(),
+                                emit_info.clone(),
+                                env.source_indices.clone(),
+                            );
+                            let type_params = emit_type_params_from_clone_param_names(
+                                item.params.clone(),
+                                header_clone_param_names.clone(),
+                                env.source_indices.clone(),
+                            );
                             let clone_bound_refusal = emit_item_clone_bound_refusal(
                                 item.clone(),
                                 item_text.clone(),
@@ -16662,6 +16595,7 @@ pub fn emit_type_def_from_connective(
                                 item_text.clone(),
                                 type_params.clone(),
                                 generic_param_names.clone(),
+                                header_clone_param_names.clone(),
                                 item.children.clone(),
                                 recursive_types.clone(),
                                 shared_types.clone(),
@@ -16920,6 +16854,7 @@ pub fn emit_struct_from_children(
     name: String,
     type_params: String,
     generic_param_names: Rc<Vec<String>>,
+    header_clone_param_names: Rc<Vec<String>>,
     children: Rc<Vec<Rc<Node>>>,
     recursive_types: Rc<BTreeSet<String>>,
     shared_types: Rc<BTreeSet<String>>,
@@ -16939,11 +16874,7 @@ pub fn emit_struct_from_children(
             v1_rt::set_contains(&emit_info.map_key_required_type_names.clone(), name.clone()),
             generic_param_names.clone(),
             env.source_indices.clone(),
-            v1_carrier_param_needs_clone_bound(
-                name.clone(),
-                generic_param_names.clone(),
-                emit_info.clone(),
-            ),
+            header_clone_param_names.clone(),
             deserialize_forbidden.clone(),
             emit_info.type_decl_items.clone(),
         );
@@ -17545,6 +17476,7 @@ pub fn emit_enum_from_children(
     name: String,
     type_params: String,
     generic_param_names: Rc<Vec<String>>,
+    header_clone_param_names: Rc<Vec<String>>,
     children: Rc<Vec<Rc<Node>>>,
     recursive_types: Rc<BTreeSet<String>>,
     shared_types: Rc<BTreeSet<String>>,
@@ -17644,6 +17576,7 @@ pub fn emit_enum_from_children(
             name.clone(),
             children.clone(),
             generic_param_names.clone(),
+            header_clone_param_names.clone(),
             env.source_indices.clone(),
         );
         let with_accessors = if (accessor_impl.clone() == "".to_string()) {
diff --git a/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs b/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs
index a191f53cb05..3ed09d08298 100644
--- a/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs
+++ b/src/v1/stage0/src/v1_compiler_trait_derive_emit.rs
@@ -716,8 +716,29 @@ pub fn v1_freemonoid_supplemental_bound_spelling() -> String {
     .join(&" + ".to_string())
 }
 
+pub fn v1_item_header_bound_spellings(
+    param_name: String,
+    header_clone_param_names: Rc<Vec<String>>,
+) -> Rc<Vec<String>> {
+    if {
+        let mut __found = false;
+        for h in header_clone_param_names.iter().cloned() {
+            if (h.clone() == param_name.clone()) {
+                __found = true;
+                break;
+            }
+        }
+        __found
+    } {
+        Rc::new(vec!["Clone".to_string()])
+    } else {
+        Rc::new(vec![])
+    }
+}
+
 pub fn v1_freemonoid_impl_type_params(
     generic_param_names: Rc<Vec<String>>,
+    header_clone_param_names: Rc<Vec<String>>,
     fm_params: Rc<Vec<String>>,
     field_type_exprs: Rc<Vec<Rc<Node>>>,
     structural_spelling: String,
@@ -732,6 +753,10 @@ pub fn v1_freemonoid_impl_type_params(
                 for p in generic_param_names.iter().cloned() {
                     __result.push({
                         let pascal = crate::v1_compiler_emit_core_support::to_pascal(p.clone());
+                        let header = v1_item_header_bound_spellings(
+                            p.clone(),
+                            header_clone_param_names.clone(),
+                        );
                         let supplemental = if {
                             let mut __found = false;
                             for f in fm_params.iter().cloned() {
@@ -755,7 +780,11 @@ pub fn v1_freemonoid_impl_type_params(
                         } else {
                             Rc::new(vec![])
                         };
-                        let parts = v1_rt::concat(supplemental.clone(), structural.clone());
+                        let parts =
+                            crate::v1_compiler_emit_core_support::unique_strings(v1_rt::concat(
+                                header.clone(),
+                                v1_rt::concat(supplemental.clone(), structural.clone()),
+                            ));
                         if ((parts.clone().len() as i64) == 0) {
                             pascal.clone()
                         } else {
@@ -1158,6 +1187,7 @@ pub fn v1_set_serde_bound_attr_for_traits(
 pub fn v1_freemonoid_struct_debug_impl(
     name: String,
     generic_param_names: Rc<Vec<String>>,
+    header_clone_param_names: Rc<Vec<String>>,
     fm_params: Rc<Vec<String>>,
     children: Rc<Vec<Rc<Node>>>,
     field_type_exprs: Rc<Vec<Rc<Node>>>,
@@ -1166,6 +1196,7 @@ pub fn v1_freemonoid_struct_debug_impl(
     {
         let tp = v1_freemonoid_impl_type_params(
             generic_param_names.clone(),
+            header_clone_param_names.clone(),
             fm_params.clone(),
             field_type_exprs.clone(),
             "std::fmt::Debug".to_string(),
@@ -1201,6 +1232,7 @@ pub fn v1_freemonoid_struct_debug_impl(
 pub fn v1_freemonoid_struct_partial_eq_impl(
     name: String,
     generic_param_names: Rc<Vec<String>>,
+    header_clone_param_names: Rc<Vec<String>>,
     fm_params: Rc<Vec<String>>,
     children: Rc<Vec<Rc<Node>>>,
     field_type_exprs: Rc<Vec<Rc<Node>>>,
@@ -1209,6 +1241,7 @@ pub fn v1_freemonoid_struct_partial_eq_impl(
     {
         let tp = v1_freemonoid_impl_type_params(
             generic_param_names.clone(),
+            header_clone_param_names.clone(),
             fm_params.clone(),
             field_type_exprs.clone(),
             "PartialEq".to_string(),
@@ -1276,6 +1309,7 @@ pub fn v1_freemonoid_struct_partial_eq_impl(
 pub fn v1_freemonoid_enum_debug_impl(
     name: String,
     generic_param_names: Rc<Vec<String>>,
+    header_clone_param_names: Rc<Vec<String>>,
     fm_params: Rc<Vec<String>>,
     children: Rc<Vec<Rc<Node>>>,
     field_type_exprs: Rc<Vec<Rc<Node>>>,
@@ -1284,6 +1318,7 @@ pub fn v1_freemonoid_enum_debug_impl(
     {
         let tp = v1_freemonoid_impl_type_params(
             generic_param_names.clone(),
+            header_clone_param_names.clone(),
             fm_params.clone(),
             field_type_exprs.clone(),
             "std::fmt::Debug".to_string(),
@@ -1382,6 +1417,7 @@ pub fn v1_freemonoid_enum_debug_impl(
 pub fn v1_freemonoid_enum_partial_eq_impl(
     name: String,
     generic_param_names: Rc<Vec<String>>,
+    header_clone_param_names: Rc<Vec<String>>,
     fm_params: Rc<Vec<String>>,
     children: Rc<Vec<Rc<Node>>>,
     field_type_exprs: Rc<Vec<Rc<Node>>>,
@@ -1390,6 +1426,7 @@ pub fn v1_freemonoid_enum_partial_eq_impl(
     {
         let tp = v1_freemonoid_impl_type_params(
             generic_param_names.clone(),
+            header_clone_param_names.clone(),
             fm_params.clone(),
             field_type_exprs.clone(),
             "PartialEq".to_string(),
@@ -1556,6 +1593,7 @@ pub fn v1_freemonoid_enum_partial_eq_impl(
 
 pub fn v1_set_impl_type_params(
     generic_param_names: Rc<Vec<String>>,
+    header_clone_param_names: Rc<Vec<String>>,
     set_params: Rc<Vec<String>>,
     field_type_exprs: Rc<Vec<Rc<Node>>>,
     structural_spelling: String,
@@ -1571,6 +1609,10 @@ pub fn v1_set_impl_type_params(
                 for p in generic_param_names.iter().cloned() {
                     __result.push({
                         let pascal = crate::v1_compiler_emit_core_support::to_pascal(p.clone());
+                        let header = v1_item_header_bound_spellings(
+                            p.clone(),
+                            header_clone_param_names.clone(),
+                        );
                         let supplemental = if {
                             let mut __found = false;
                             for f in set_params.iter().cloned() {
@@ -1596,7 +1638,11 @@ pub fn v1_set_impl_type_params(
                         } else {
                             Rc::new(vec![])
                         };
-                        let parts = v1_rt::concat(supplemental.clone(), structural.clone());
+                        let parts =
+                            crate::v1_compiler_emit_core_support::unique_strings(v1_rt::concat(
+                                header.clone(),
+                                v1_rt::concat(supplemental.clone(), structural.clone()),
+                            ));
                         if ((parts.clone().len() as i64) == 0) {
                             pascal.clone()
                         } else {
@@ -1620,6 +1666,7 @@ pub fn v1_set_impl_type_params(
 pub fn v1_set_enum_debug_impl(
     name: String,
     generic_param_names: Rc<Vec<String>>,
+    header_clone_param_names: Rc<Vec<String>>,
     set_params: Rc<Vec<String>>,
     children: Rc<Vec<Rc<Node>>>,
     field_type_exprs: Rc<Vec<Rc<Node>>>,
@@ -1628,6 +1675,7 @@ pub fn v1_set_enum_debug_impl(
     {
         let tp = v1_set_impl_type_params(
             generic_param_names.clone(),
+            header_clone_param_names.clone(),
             set_params.clone(),
             field_type_exprs.clone(),
             "std::fmt::Debug".to_string(),
@@ -1727,6 +1775,7 @@ pub fn v1_set_enum_debug_impl(
 pub fn v1_set_enum_partial_eq_impl(
     name: String,
     generic_param_names: Rc<Vec<String>>,
+    header_clone_param_names: Rc<Vec<String>>,
     set_params: Rc<Vec<String>>,
     children: Rc<Vec<Rc<Node>>>,
     field_type_exprs: Rc<Vec<Rc<Node>>>,
@@ -1735,6 +1784,7 @@ pub fn v1_set_enum_partial_eq_impl(
     {
         let tp = v1_set_impl_type_params(
             generic_param_names.clone(),
+            header_clone_param_names.clone(),
             set_params.clone(),
             field_type_exprs.clone(),
             "PartialEq".to_string(),
@@ -2033,6 +2083,7 @@ pub fn v1_item_ord_propagated_param_names(
 pub fn v1_set_struct_debug_impl(
     name: String,
     generic_param_names: Rc<Vec<String>>,
+    header_clone_param_names: Rc<Vec<String>>,
     set_params: Rc<Vec<String>>,
     children: Rc<Vec<Rc<Node>>>,
     field_type_exprs: Rc<Vec<Rc<Node>>>,
@@ -2041,6 +2092,7 @@ pub fn v1_set_struct_debug_impl(
     {
         let tp = v1_set_impl_type_params(
             generic_param_names.clone(),
+            header_clone_param_names.clone(),
             set_params.clone(),
             field_type_exprs.clone(),
             "std::fmt::Debug".to_string(),
@@ -2077,6 +2129,7 @@ pub fn v1_set_struct_debug_impl(
 pub fn v1_set_struct_partial_eq_impl(
     name: String,
     generic_param_names: Rc<Vec<String>>,
+    header_clone_param_names: Rc<Vec<String>>,
     set_params: Rc<Vec<String>>,
     children: Rc<Vec<Rc<Node>>>,
     field_type_exprs: Rc<Vec<Rc<Node>>>,
@@ -2085,6 +2138,7 @@ pub fn v1_set_struct_partial_eq_impl(
     {
         let tp = v1_set_impl_type_params(
             generic_param_names.clone(),
+            header_clone_param_names.clone(),
             set_params.clone(),
             field_type_exprs.clone(),
             "PartialEq".to_string(),
@@ -4090,7 +4144,7 @@ pub fn v1_emit_struct_from_capability_table(
     map_key_required: bool,
     generic_param_names: Rc<Vec<String>>,
     source_indices: Rc<HashMap<String, Rc<NewlineIndex>>>,
-    carrier_param_needs_clone: bool,
+    header_clone_param_names: Rc<Vec<String>>,
     deserialize_forbidden: bool,
     type_decl_items: Rc<HashMap<String, Rc<Node>>>,
 ) -> Rc<StructCapabilityEmit> {
@@ -4145,6 +4199,7 @@ pub fn v1_emit_struct_from_capability_table(
                             v1_freemonoid_struct_debug_impl(
                                 name.clone(),
                                 generic_param_names.clone(),
+                                header_clone_param_names.clone(),
                                 fm_params.clone(),
                                 children.clone(),
                                 field_type_exprs.clone(),
@@ -4156,6 +4211,7 @@ pub fn v1_emit_struct_from_capability_table(
                     v1_freemonoid_struct_partial_eq_impl(
                         name.clone(),
                         generic_param_names.clone(),
+                        header_clone_param_names.clone(),
                         fm_params.clone(),
                         children.clone(),
                         field_type_exprs.clone(),
@@ -4209,6 +4265,7 @@ pub fn v1_emit_struct_from_capability_table(
                                     v1_set_struct_debug_impl(
                                         name.clone(),
                                         generic_param_names.clone(),
+                                        header_clone_param_names.clone(),
                                         ord_propagated_params.clone(),
                                         children.clone(),
                                         field_type_exprs.clone(),
@@ -4220,6 +4277,7 @@ pub fn v1_emit_struct_from_capability_table(
                             v1_set_struct_partial_eq_impl(
                                 name.clone(),
                                 generic_param_names.clone(),
+                                header_clone_param_names.clone(),
                                 ord_propagated_params.clone(),
                                 children.clone(),
                                 field_type_exprs.clone(),
@@ -4243,7 +4301,7 @@ pub fn v1_emit_struct_from_capability_table(
                             source_indices.clone(),
                         );
                         let impl_bodies = if (crate::std_trait_derive_shape::repr_grounding_group_completion_carrier(module_path.clone(), name.clone()) && crate::std_trait_derive_shape::repr_grounding_derive_completeness_predicate(crate::extdeps_languages_rust_capabilities::rust_capability_shape_table(), crate::extdeps_languages_rust_capabilities::kernel_int_arithmetic_traits(), ReprGroundingDeriveElemShape::ReprDeriveElemKernelInt)) {
-                            crate::extdeps_languages_rust_emit::rust_supplemental_impls_group_completion(carrier_param_needs_clone.clone())
+                            crate::extdeps_languages_rust_emit::rust_supplemental_impls_group_completion(((header_clone_param_names.clone().len() as i64) > 0))
                         } else {
                             "".to_string()
                         };
@@ -4283,6 +4341,7 @@ pub fn v1_emit_enum_supplemental_impls(
     name: String,
     children: Rc<Vec<Rc<Node>>>,
     generic_param_names: Rc<Vec<String>>,
+    header_clone_param_names: Rc<Vec<String>>,
     source_indices: Rc<HashMap<String, Rc<NewlineIndex>>>,
 ) -> String {
     {
@@ -4305,6 +4364,7 @@ pub fn v1_emit_enum_supplemental_impls(
                         v1_freemonoid_enum_debug_impl(
                             name.clone(),
                             generic_param_names.clone(),
+                            header_clone_param_names.clone(),
                             fm_params.clone(),
                             children.clone(),
                             field_type_exprs.clone(),
@@ -4316,6 +4376,7 @@ pub fn v1_emit_enum_supplemental_impls(
                 v1_freemonoid_enum_partial_eq_impl(
                     name.clone(),
                     generic_param_names.clone(),
+                    header_clone_param_names.clone(),
                     fm_params.clone(),
                     children.clone(),
                     field_type_exprs.clone(),
@@ -4331,6 +4392,7 @@ pub fn v1_emit_enum_supplemental_impls(
                             v1_set_enum_debug_impl(
                                 name.clone(),
                                 generic_param_names.clone(),
+                                header_clone_param_names.clone(),
                                 set_params.clone(),
                                 children.clone(),
                                 field_type_exprs.clone(),
@@ -4342,6 +4404,7 @@ pub fn v1_emit_enum_supplemental_impls(
                     v1_set_enum_partial_eq_impl(
                         name.clone(),
                         generic_param_names.clone(),
+                        header_clone_param_names.clone(),
                         set_params.clone(),
                         children.clone(),
                         field_type_exprs.clone(),