@@ -1939,59 +1939,100 @@ fn the_first_fold_production_chains_cost_what_the_design_derived() {
 /// do not depend on the fold.
 struct ChainPins {
     grind_perms: usize,
+    opening_perms: usize,
     perms: usize,
     words: u32,
     lean: (usize, usize),
     classic: (usize, usize),
 }
 
 /// ★ THE PRODUCTION DEFAULT CHAIN — what `chain_config` builds with no knob
-/// set — is `first6` under the `Auto` cap, at blowup 2^2 and Q = 112, grinding
-/// before its queries alone: P2's `whir_grind=query`, one 20-bit grind and one
+/// set — is `first6` under the `Auto` cap, at blowup 2^2 and Q = 114, grinding
+/// before its queries alone: P2's `whir_grind=query`, one 18-bit grind and one
 /// nonce word a round. The legacy chain keeps its own pins above
-/// (`the_production_chain_costs…`, 185,509 / 22,828), and the opt-out
-/// (`whir_grind=all`) keeps the pins this chain had before P2
-/// ([`the_grind_opt_out_chain_keeps_the_pins_from_before_p2`]).
+/// (`the_production_chain_costs…`, 185,509 / 22,828); the same chain at 20
+/// bits (`LAMBDA_VM_ZF_WHIR_GRIND_BITS=20`, Q 112) keeps the pins the default
+/// had before the bits moved ([`the_grind_bits_opt_out_chain_keeps_its_pins`]),
+/// and the opt-out of both (`whir_grind=all` at 20 bits) the pins this chain
+/// had before P2 ([`the_grind_opt_out_chain_keeps_the_pins_from_before_p2`]).
 #[test]
 fn the_production_default_chain_is_first6_under_the_auto_cap() {
     let production = crate::multilinear_prove::chain_config_under(
         &crate::zf_format::ZfFormat::DEFAULT,
         &[(1, 25)],
     );
     let want = ChainConfig {
-        grind: GrindBits::query_only(20),
+        grind: GrindBits::query_only(18),
         format: ChainFormat {
             cap: CapPolicy::Auto,
             folds: WhirFolds::First(FirstFold::new(6).expect("6")),
             stack: multilinear::whir_chain::StackVars::new(27).expect("27"),
             nonces: NonceLayout::Spent,
             argue: multilinear::whir_chain::ArgueFormat::PerTable,
         },
-        ..config(112, 0)
+        ..config(114, 0)
     };
     assert_eq!(production, want, "the production default's chain config");
     let shape = ChainShape::new(&production, 25);
     for r in 0..shape.rounds() {
         assert_eq!(shape.carries(r), [false, false, true], "round {r}");
     }
     check_production_chain("DEFAULT", &shape, &DEFAULT_CHAIN_PINS);
-    // Both levers pay: fewer permutations than either alone, and fewer than
-    // the same chain grinding all three.
+    // The two queries the 18-bit grind buys back cost the verifier their
+    // openings (2 × 144 permutations, plus the extra queries' schedule terms):
+    // the in-circuit price of two fewer grind bits on the prover.
+    const {
+        assert!(DEFAULT_CHAIN_PINS.perms > GRIND_BITS_20_CHAIN_PINS.perms);
+        assert!(DEFAULT_CHAIN_PINS.grind_perms == GRIND_BITS_20_CHAIN_PINS.grind_perms);
+    };
+}
+
+/// ★ THE GRIND-BITS OPT-OUT'S CHAIN IS THE DEFAULT'S BEFORE THE BITS MOVED.
+/// `LAMBDA_VM_ZF_WHIR_GRIND_BITS=20` builds P2's chain at 20 bits and Q 112,
+/// with every cost it had then: these pins are the previous default's,
+/// unmoved. P2 and first6 under the auto cap both pay at this Q: fewer
+/// permutations than either alone, and fewer than the same chain grinding all
+/// three.
+#[test]
+fn the_grind_bits_opt_out_chain_keeps_its_pins() {
+    let at20 = crate::multilinear_prove::chain_config_under(
+        &crate::zf_format::ZfFormat {
+            whir_grind_bits: crate::zf_format::LEGACY_WHIR_GRIND_BITS,
+            ..crate::zf_format::ZfFormat::DEFAULT
+        },
+        &[(1, 25)],
+    );
+    let want = ChainConfig {
+        grind: GrindBits::query_only(20),
+        format: ChainFormat {
+            cap: CapPolicy::Auto,
+            folds: WhirFolds::First(FirstFold::new(6).expect("6")),
+            stack: multilinear::whir_chain::StackVars::new(27).expect("27"),
+            nonces: NonceLayout::Spent,
+            argue: multilinear::whir_chain::ArgueFormat::PerTable,
+        },
+        ..config(112, 0)
+    };
+    assert_eq!(at20, want, "the 20-bit chain config");
+    let shape = ChainShape::new(&at20, 25);
+    check_production_chain("GRIND-BITS-20", &shape, &GRIND_BITS_20_CHAIN_PINS);
     const {
-        assert!(DEFAULT_CHAIN_PINS.perms < 18_729 && DEFAULT_CHAIN_PINS.perms < 19_877);
-        assert!(DEFAULT_CHAIN_PINS.perms < GRIND_ALL_CHAIN_PINS.perms);
+        assert!(GRIND_BITS_20_CHAIN_PINS.perms < 18_729 && GRIND_BITS_20_CHAIN_PINS.perms < 19_877);
+        assert!(GRIND_BITS_20_CHAIN_PINS.perms < GRIND_ALL_CHAIN_PINS.perms);
     };
 }
 
-/// ★ THE OPT-OUT'S CHAIN IS TODAY'S. `LAMBDA_VM_ZF_WHIR_GRIND=all` builds the
-/// production default's chain exactly as it was before P2, 20-bit grinds before
-/// all three challenges and three nonce words a round, and every cost it had
-/// then: these pins are the pre-P2 default's, unmoved.
+/// ★ THE OPT-OUT'S CHAIN IS TODAY'S. `LAMBDA_VM_ZF_WHIR_GRIND=all` with
+/// `LAMBDA_VM_ZF_WHIR_GRIND_BITS=20` builds the production default's chain
+/// exactly as it was before P2, 20-bit grinds before all three challenges and
+/// three nonce words a round, and every cost it had then: these pins are the
+/// pre-P2 default's, unmoved.
 #[test]
 fn the_grind_opt_out_chain_keeps_the_pins_from_before_p2() {
     let opt_out = crate::multilinear_prove::chain_config_under(
         &crate::zf_format::ZfFormat {
             whir_grind: crate::zf_format::WhirGrind::All,
+            whir_grind_bits: crate::zf_format::LEGACY_WHIR_GRIND_BITS,
             ..crate::zf_format::ZfFormat::DEFAULT
         },
         &[(1, 25)],
@@ -2020,9 +2061,10 @@ fn check_production_chain(label: &str, shape: &ChainShape, pins: &ChainPins) {
     );
     let entry = SpongeEntry::fresh();
     println!(
-        "production {label} chain S=25 first6 cap=auto Q=112 grind={:?}: caps {:?}, {} opening \
+        "production {label} chain S=25 first6 cap=auto Q={} grind={:?}: caps {:?}, {} opening \
          permutations, {} cap permutations, {} grind permutations, {} permutations, {} words, \
          {} rows ({} shape rows)",
+        shape.num_queries,
         shape.grind,
         shape.caps,
         chain_opening_perms(shape),
@@ -2040,7 +2082,7 @@ fn check_production_chain(label: &str, shape: &ChainShape, pins: &ChainPins) {
     );
     assert_eq!(
         chain_opening_perms(shape),
-        16_166,
+        pins.opening_perms,
         "{label}: opening permutations"
     );
     assert_eq!(chain_cap_perms(shape), 38, "{label}: cap permutations");
@@ -2080,10 +2122,22 @@ fn check_production_chain(label: &str, shape: &ChainShape, pins: &ChainPins) {
 /// The production default chain's pins, derived by the closed forms and
 /// checked against the EMITTED program by
 /// [`the_production_chains_emit_their_closed_forms`]. P2's: one grind a round
-/// (6 × 2 permutations), one nonce word a round.
+/// (6 × 2 permutations), one nonce word a round; Q 114 at 18 grind bits.
 const DEFAULT_CHAIN_CAPS: &[usize] = &[3, 3, 3, 3, 3, 2];
 const DEFAULT_CHAIN_PINS: ChainPins = ChainPins {
     grind_perms: 12,
+    opening_perms: 16_454,
+    perms: 16_705,
+    words: 33_170,
+    lean: (152_175, 152_904),
+    classic: (205_730, 206_459),
+};
+
+/// The grind-bits opt-out's pins (20 bits, Q 112), which are the production
+/// default's from before the bits moved.
+const GRIND_BITS_20_CHAIN_PINS: ChainPins = ChainPins {
+    grind_perms: 12,
+    opening_perms: 16_166,
     perms: 16_411,
     words: 32_590,
     lean: (149_547, 150_258),
@@ -2094,33 +2148,44 @@ const DEFAULT_CHAIN_PINS: ChainPins = ChainPins {
 /// `3R − 1 = 17` grinds (34 permutations), three nonce words a round.
 const GRIND_ALL_CHAIN_PINS: ChainPins = ChainPins {
     grind_perms: 34,
+    opening_perms: 16_166,
     perms: 16_443,
     words: 32_602,
     lean: (150_075, 150_811),
     classic: (202_690, 203_426),
 };
 
-/// ★ The production chains, EMITTED (the F1 of the two tests above), the
-/// default and the opt-out, under both fold emissions. `#[ignore]`d like its
-/// siblings: production-shape programs; laptop-safe.
+/// ★ The production chains, EMITTED (the F1 of the three tests above), the
+/// default and the two opt-outs, under both fold emissions. `#[ignore]`d like
+/// its siblings: production-shape programs; laptop-safe.
 #[test]
 #[ignore = "builds production-shape chain programs; run with -- --ignored"]
 fn the_production_chains_emit_their_closed_forms() {
-    for (label, whir_grind, pins) in [
+    use crate::zf_format::{LEGACY_WHIR_GRIND_BITS, PRODUCTION_WHIR_GRIND_BITS, WhirGrind};
+    for (label, whir_grind, whir_grind_bits, pins) in [
         (
             "DEFAULT",
-            crate::zf_format::WhirGrind::Query,
+            WhirGrind::Query,
+            PRODUCTION_WHIR_GRIND_BITS,
             &DEFAULT_CHAIN_PINS,
         ),
+        (
+            "GRIND-BITS-20",
+            WhirGrind::Query,
+            LEGACY_WHIR_GRIND_BITS,
+            &GRIND_BITS_20_CHAIN_PINS,
+        ),
         (
             "GRIND-ALL",
-            crate::zf_format::WhirGrind::All,
+            WhirGrind::All,
+            LEGACY_WHIR_GRIND_BITS,
             &GRIND_ALL_CHAIN_PINS,
         ),
     ] {
         let production = crate::multilinear_prove::chain_config_under(
             &crate::zf_format::ZfFormat {
                 whir_grind,
+                whir_grind_bits,
                 ..crate::zf_format::ZfFormat::DEFAULT
             },
             &[(1, 25)],
@@ -2151,11 +2216,11 @@ fn the_production_chains_emit_their_closed_forms() {
                 "{label}, {fold:?}: every arena word hinted once"
             );
             println!(
-                "PRODUCTION {label} chain S=25 first6 cap=auto Q=112 grind={:?}, {fold:?} fold: \
+                "PRODUCTION {label} chain S=25 first6 cap=auto Q={} grind={:?}, {fold:?} fold: \
                  {measured} rows against {predicted} predicted; {perms} permutations against \
                  {predicted_perms} predicted; {consts} constants, {hints} hints, {instructions} \
                  instructions",
-                shape.grind
+                shape.num_queries, shape.grind
             );
             assert_eq!(measured, predicted, "{label}, {fold:?}: rows");
             assert_eq!(perms, predicted_perms, "{label}, {fold:?}: permutations");
@@ -2422,7 +2487,7 @@ fn a_query_only_chain_checks_its_query_nonce_in_every_round_on_both_sides() {
     }
 }
 
-/// ★ `LAMBDA_VM_ZF_WHIR_GRIND_BITS=18`'s trade, at a test width: the grind
+/// ★ The default's 18-bit grind (against `LAMBDA_VM_ZF_WHIR_GRIND_BITS=20`), at a test width: the grind
 /// bits and Q are verifier constants. A chain ground at fewer bits and opened
 /// at more queries executes on the machine built for its own config, and both
 /// the host and the machine refuse it under a stricter grind at the same Q; the
@@ -2628,8 +2693,9 @@ fn proof_digest(proof: &ChainProof<F, E>) -> (usize, String) {
 /// programs (instructions, a digest of all of them, arena words), the arenas and
 /// the host proofs' rkyv bytes at zero bits (the only width where two proves
 /// agree: a search returns any valid nonce), under `Three` with uniform grinds.
-/// Also the production chain under the opt-out, `whir_grind=all`, at the stacks
-/// the block reaches (25 and 27): the program the pre-P2 default emitted.
+/// Also the production chain under the opt-out, `whir_grind=all` at 20 bits, at
+/// the stacks the block reaches (25 and 27): the program the pre-P2 default
+/// emitted.
 #[test]
 fn the_legacy_nonce_layout_reproduces_the_bytes_from_before_p2() {
     const PROGRAMS: [(usize, u8, usize, u32, &str); 4] = [
@@ -2711,6 +2777,7 @@ fn the_legacy_nonce_layout_reproduces_the_bytes_from_before_p2() {
 
     let opt_out = crate::zf_format::ZfFormat {
         whir_grind: crate::zf_format::WhirGrind::All,
+        whir_grind_bits: crate::zf_format::LEGACY_WHIR_GRIND_BITS,
         ..crate::zf_format::ZfFormat::DEFAULT
     };
     for (num_vars, instrs, words, digest) in [
@@ -2745,8 +2812,8 @@ fn the_legacy_nonce_layout_reproduces_the_bytes_from_before_p2() {
 
 /// I-GRIND instrument (not a gate): the emitted chain verifier's real rows per
 /// chip at every production height, under the production format at 20 grind
-/// bits (Q 112) and at `LAMBDA_VM_ZF_WHIR_GRIND_BITS=18` (Q 114). The per-chain
-/// deltas size the recursion's table heights under the arm.
+/// bits (Q 112, the opt-out) and at the default's 18 (Q 114). The per-chain
+/// deltas size the recursion's table heights under each.
 ///
 /// cargo test -p lambda-vm-prover --lib grind_bits_chain_census -- --ignored --nocapture
 #[test]
 
@@ -164,7 +164,10 @@ fn the_production_epoch_recount() {
             production.format,
             crate::zf_format::ZfFormat::DEFAULT.chain_format()
         );
-        assert_eq!(production.num_queries, 112, "the flip keeps Q");
+        assert_eq!(
+            production.num_queries, 114,
+            "first6 keeps Q; the default's 18-bit grind buys two queries"
+        );
         assert_eq!(ChainShape::new(&production, 25).rounds(), 6, "first6 at 25");
     }
     let (layouts, _domains) = stacks(&shapes, &sizes, &config).expect("the epoch's stacks build");
 
@@ -562,8 +562,15 @@ fn the_leg_program_round_trips_as_a_w_lfm_proof() {
 ///
 /// The child publishes a NODE schema (`SchemaLayout::node(0)`), the instrument's
 /// assumption, so the two are compared like for like.
+///
+/// The pins follow the process's grind bits, which set Q (a W-LFM plan refuses
+/// artifacts built under another config, so one process costs one setting):
+/// at the default's 18 (Q 114) the 18-bit pins; under
+/// `LAMBDA_VM_ZF_WHIR_GRIND_BITS=20` (Q 112, the default before the bits moved)
+/// the 20-bit pins and the design's instrument numbers, which were taken there.
 #[test]
 fn the_w_leg_costs_at_the_sizing_shapes() {
+    use crate::zf_format::{LEGACY_WHIR_GRIND_BITS, PRODUCTION_WHIR_GRIND_BITS, ZfFormat};
     let opts = options();
     let publics = super::per_table_aggregator::SchemaLayout::node(0).total();
     let mut rows = Vec::new();
@@ -615,7 +622,54 @@ fn the_w_leg_costs_at_the_sizing_shapes() {
         );
         rows_b.push((*label, cost.perms, cost.operations(), cost.hints));
     }
-    // ★ The policy-B pins, same format.
+    let check =
+        |rows: &[(&str, usize, usize, usize)], pins: &[(&str, usize, usize, usize)], what: &str| {
+            for &(label, perms, ops, hints) in pins {
+                let row = rows
+                    .iter()
+                    .find(|(l, ..)| *l == label)
+                    .expect("the profile is in the table");
+                assert_eq!(
+                    (row.1, row.2, row.3),
+                    (perms, ops, hints),
+                    "{label} ({what}): (perms, ops, hints) moved off the pin"
+                );
+            }
+        };
+    let bits = ZfFormat::global().whir_grind_bits;
+    if bits == PRODUCTION_WHIR_GRIND_BITS {
+        // ★ THE PINS at the default's 18 bits (Q 114), both policies: two more
+        // queries a chain, so every leg costs more to verify than at 20 bits
+        // (wrap 0: +619 perms under policy A, +596 under B).
+        check(
+            &rows,
+            &[
+                ("wrap 0", 40_342, 403_062, 76_608),
+                ("global wrap", 63_558, 601_451, 119_698),
+                ("L1N0", 63_603, 602_296, 119_755),
+                ("L2N0", 83_370, 777_006, 157_349),
+                ("node -1", 41_835, 413_171, 78_887),
+            ],
+            "A, 18 bits",
+        );
+        check(
+            &rows_b,
+            &[
+                ("wrap 0", 38_970, 389_075, 75_113),
+                ("global wrap", 63_483, 598_273, 119_698),
+                ("L1N0", 63_528, 599_001, 119_755),
+                ("L2N0", 63_580, 599_687, 119_830),
+                ("node -1", 41_760, 409_686, 78_887),
+            ],
+            "B, 18 bits",
+        );
+        return;
+    }
+    assert_eq!(
+        bits, LEGACY_WHIR_GRIND_BITS,
+        "the sizing pins exist at 18 and 20 grind bits only"
+    );
+    // ★ The policy-B pins at 20 bits, same format.
     //
     // Re-blessed under P2 (the chains grind before their queries only, with
     // one spent nonce a round): each chain round drops its folding and OOD
@@ -657,9 +711,9 @@ fn the_w_leg_costs_at_the_sizing_shapes() {
         );
     }
 
-    // ★ THE PINS, at the default format (stack 27, first6, cap auto, grind 20
-    // before the queries only — P2): `(label, permutations, operations,
-    // hints)`, the exact form's values. Re-blessed under P2 as the B pins
+    // ★ THE PINS at 20 bits (stack 27, first6, cap auto, grind 20 before the
+    // queries only — P2): `(label, permutations, operations, hints)`, the exact
+    // form's values. Re-blessed under P2 as the B pins
     // above; before it: wrap 0 39,795 / 398,742 / 75,432 · global 62,651 /
     // 594,462 / 117,796 · L1N0 62,696 / 595,307 / 117,853 · L2N0 82,155 /
     // 767,664 / 154,805 · node −1 41,266 / 408,727 / 77,677.
 
@@ -1155,9 +1155,10 @@ pub fn lfm_verify_whir(
 
 /// A TEST-ONLY switch that proves W-LFM chains without grinding.
 ///
-/// A W-LFM chain grinds 20 bits before each redrawable challenge, and on a
-/// laptop's CPU that search is most of a small proof's time (≈ 24 grinds, ≈ 29 s
-/// for `TrivialV0`). The refusals the tests check do not depend on it, so they
+/// A W-LFM chain grinds before its redrawable challenges (by default 18 bits
+/// before each round's queries), and on a laptop's CPU that search is most of a
+/// small proof's time (≈ 24 grinds, ≈ 29 s for `TrivialV0` when it ground 20
+/// bits before every challenge). The refusals the tests check do not depend on it, so they
 /// run with it off; the round trip that anchors the production config keeps it
 /// on. Thread-local, and applied inside [`whir_lfm_config`], so the prover, the
 /// verifier and the emitter of one test all see the same config and a
 
@@ -114,10 +114,10 @@ fn forge(
 fn the_trivial_program_round_trips_at_the_production_config() {
     let program = trivial_program();
     let build = build(&program, HasherKind::Rpx);
-    // The production grind is P2's: 20 bits before each round's queries only.
+    // The production grind is P2's: 18 bits before each round's queries only.
     assert_eq!(
         build.artifacts.config.grind,
-        multilinear::whir_chain::GrindBits::query_only(20),
+        multilinear::whir_chain::GrindBits::query_only(18),
         "the anchor must run the production grind"
     );
     let proved = lfm_prove_whir(&program, &build, &arenas(), &options())