@@ -232,6 +232,13 @@ combine with `jax.vmap`.
 
 ### Caveats
 
+- `effective_order` propagates across both explicit (`jax.jit`) and
+  implicit (`jnp.*` operator) jit boundaries. The implementation binds
+  `effective_order` as an extra runtime input to each inner pjit so the
+  inner `JetTrace` reads it as a tracer and threads it into every
+  primitive rule's `_jet_scan` call. No special action needed from the
+  user — write your function in plain `jnp` style and the hint is
+  honored throughout.
 - The primitives a JAX program uses fall into three categories:
   - **Linear / zero-derivative** (`add`, `sub`, multiplication by a
     constant, `neg`, broadcasting, slicing, comparisons, …): the operation
@@ -257,6 +264,10 @@ combine with `jax.vmap`.
     short-circuit, but they don't need to — the per-entry cost is O(1)
     and the contract is satisfied because garbage-in-garbage-out for
     indices above `effective_order` is fine.
+- One-time cost: when `effective_order` is set, each inner pjit re-traces
+  with one extra input (the eff scalar). This adds a small compile-time
+  cost the first time a function is `jet`'d with `effective_order` set vs
+  without — both jaxprs are cached.
 - Because output entries above `effective_order` are unspecified for the
   second category, treat the whole `series_out[effective_order:]` slice as
   garbage even if upstream linear ops would otherwise leave it intact.
 
@@ -261,6 +261,34 @@ def traceable(f, store, in_tree_def, *primals_and_series):
     return out_flat
 
 
+@lu.transformation2
+def jet_fun_with_eff(f, order, primals, series, eff):
+    """Like jet_fun, but pulls effective_order from a runtime input."""
+    tag = core.TraceTag()
+    out_primals, out_terms = f(tag, order, eff, primals, series)
+    out_terms = [
+        jnp.zeros((order,) + p.shape) if s is zero_series else s
+        for p, s in zip(out_primals, out_terms)
+    ]
+    return out_primals, out_terms
+
+
+@lu.transformation_with_aux2
+def traceable_with_eff(f, store, in_tree_def, *all_inputs):
+    """Like traceable, but the LAST input is the effective_order scalar.
+
+    Used by _pjit_jet_rule when threading effective_order across a jit
+    boundary: the inner jaxpr accepts one extra runtime input, and the
+    inner JetTrace reads its effective_order from that input.
+    """
+    *primals_and_series, eff = all_inputs
+    primals_in, series_in = tree_unflatten(in_tree_def, primals_and_series)
+    primals_out, series_out = f(primals_in, series_in, eff)
+    out_flat, out_tree_def = tree_flatten((primals_out, series_out))
+    store.store(out_tree_def)
+    return out_flat
+
+
 class JetTracer(core.Tracer):
     __slots__ = ["primal", "terms"]
 
@@ -580,7 +608,11 @@ def def_comp(prim, comp, **kwargs):
     """
     Define the jet rule for a primitive in terms of a composition of simpler primitives.
     """
-    jet_rules[prim] = partial(jet, comp, **kwargs)
+    def comp_rule(primals_in, series_in, _jet_effective_order=None, **_):
+        return jet(comp, primals_in, series_in,
+                   effective_order=_jet_effective_order, **kwargs)
+    jet_rules[prim] = comp_rule
+    _register_eff_order_rule(prim)
 
 
 
@@ -1250,7 +1282,8 @@ def _scatter_add_terms(d_operand, d_updates):
 
 @weakref_lru_cache
 def _jet_jaxpr(
-    jaxpr: core.ClosedJaxpr, order: int, primals_and_series_avals, in_tree_def
+    jaxpr: core.ClosedJaxpr, order: int, primals_and_series_avals, in_tree_def,
+    propagate_effective_order: bool = False,
 ) -> tuple[core.ClosedJaxpr, Any]:
     # Create a minimal debug_info since JAX 0.8.0+ requires it and validates arg_names count.
     # We can't use the original jaxpr's debug_info because the number of arguments changes
@@ -1262,32 +1295,59 @@ def _jet_jaxpr(
         result_paths=None,
     )
     f = lu.wrap_init(core.jaxpr_as_fun(jaxpr), debug_info=debug_info)
-    # Recursive jet calls don't propagate effective_order (inner jit boundaries)
-    f_jet, out_tree_def = traceable(jet_fun(jet_subtrace(f), order, None), in_tree_def)
+
+    if propagate_effective_order:
+        # primals_and_series_avals's last entry is the effective_order scalar.
+        # Pull it out of the input list and feed it into the inner JetTrace,
+        # so the hint survives the jit boundary.
+        f_jet, out_tree_def = traceable_with_eff(
+            jet_fun_with_eff(jet_subtrace(f), order),
+            in_tree_def,
+        )
+    else:
+        # No propagation: inner JetTrace gets effective_order=None.
+        f_jet, out_tree_def = traceable(
+            jet_fun(jet_subtrace(f), order, None),
+            in_tree_def,
+        )
     jaxpr_jet, _, consts = pe.trace_to_jaxpr_dynamic(f_jet, primals_and_series_avals)
     return core.ClosedJaxpr(jaxpr_jet, consts), out_tree_def
 
 
 def _pjit_jet_rule(primals_in, series_in, **params):
+    eff = params.get("_jet_effective_order", None)
+    propagate = eff is not None
+
     primals_and_series, in_tree_def = tree_flatten((primals_in, series_in))
 
     # FIX: Get order from enclosing jet trace if series_in is empty
     # When a pjit has no inputs, we need to inherit the order from the enclosing jet trace
     # to ensure consistent series dimensions throughout the computation.
     if len(series_in) == 0:
         # Use the order passed from the enclosing jet trace
-        order = params.pop("_jet_order", 0)
+        order = params.get("_jet_order", 0)
     else:
         order = series_in[0].shape[0]
 
+    # When propagating, append effective_order as an extra runtime input so
+    # the inner JetTrace can read it. Otherwise the hint dies at this jit
+    # boundary.
+    if propagate:
+        eff_value = jnp.asarray(eff, dtype=jnp.int32)
+        bound_inputs = list(primals_and_series) + [eff_value]
+    else:
+        bound_inputs = list(primals_and_series)
+
     primals_and_series_avals = tuple(
-        core.shaped_abstractify(x) for x in primals_and_series
+        core.shaped_abstractify(x) for x in bound_inputs
     )
     jaxpr_jet, out_tree_def = _jet_jaxpr(
-        params["jaxpr"], order, primals_and_series_avals, in_tree_def
+        params["jaxpr"], order, primals_and_series_avals, in_tree_def,
+        propagate_effective_order=propagate,
     )
     num_series_in = len(primals_in)
     num_series_out = len(params["out_shardings"])
+    num_extra = 1 if propagate else 0
 
     # Remove internal jet keys from params before passing to pjit.bind
     _jet_keys = {"_jet_order", "_jet_effective_order"}
@@ -1297,16 +1357,17 @@ def _pjit_jet_rule(primals_in, series_in, **params):
         **params_for_pjit,
         "jaxpr": jaxpr_jet,
         "in_shardings": (
-            params["in_shardings"] + (sharding_impls.UNSPECIFIED,) * num_series_in
+            params["in_shardings"]
+            + (sharding_impls.UNSPECIFIED,) * (num_series_in + num_extra)
         ),
         "out_shardings": (
             params["out_shardings"] + (sharding_impls.UNSPECIFIED,) * num_series_out
         ),
-        "in_layouts": params["in_layouts"] + (None,) * num_series_in,
+        "in_layouts": params["in_layouts"] + (None,) * (num_series_in + num_extra),
         "out_layouts": params["out_layouts"] + (None,) * num_series_out,
-        "donated_invars": params["donated_invars"] + (False,) * num_series_in,
+        "donated_invars": params["donated_invars"] + (False,) * (num_series_in + num_extra),
     }
-    result = jex.core.primitives.jit_p.bind(*primals_and_series, **new_params)
+    result = jex.core.primitives.jit_p.bind(*bound_inputs, **new_params)
     return tree_unflatten(out_tree_def(), result)
 
 
 
@@ -166,3 +166,72 @@ def test_effective_order_full_K_equals_no_hint():
     _, s_no = jet(fn, (x0,), (series_in,))
     _, s_K = jet(fn, (x0,), (series_in,), effective_order=jnp.array(K))
     np.testing.assert_allclose(s_no, s_K, rtol=1e-12, atol=1e-14)
+
+
+# ----------------------------------------------------------------------------
+# Cross-jit propagation: effective_order must survive jit boundaries.
+# Regression coverage for the _pjit_jet_rule fix that threads eff as an
+# extra input to the inner pjit.
+# ----------------------------------------------------------------------------
+
+
+@pytest.mark.parametrize("name,fn_factory", [
+    # Each function uses jnp.* (which wraps in implicit jit) AND composes
+    # with jnp.exp so the high-order Taylor coefficients are non-zero —
+    # this lets us verify truncation by comparing the tail.
+    ("jnp.exp",         lambda: lambda x: jnp.exp(x)),
+    ("jnp.sin",         lambda: lambda x: jnp.exp(jnp.sin(x))),
+    ("jnp.tanh",        lambda: lambda x: jnp.exp(jnp.tanh(x))),
+    ("x**0.5",          lambda: lambda x: jnp.exp(x ** 0.5)),
+    ("x*x",             lambda: lambda x: jnp.exp(x * x)),
+    ("x**3",            lambda: lambda x: jnp.exp(x ** 3)),
+    ("compose_two",     lambda: lambda x: jnp.exp(jnp.sin(jnp.tanh(x)))),
+])
+def test_effective_order_propagates_across_implicit_jit(name, fn_factory):
+    """Functions that use jnp.* operators (which wrap each call in jit)
+    still skip work above effective_order. Without the _pjit_jet_rule fix,
+    the inner JetTrace would see effective_order=None and produce a
+    full-K series; with the fix, the eff is threaded as an extra input
+    and the series is truncated."""
+    fn = fn_factory()
+    x0 = jnp.asarray(0.5, dtype=jnp.float64)
+    series_in = jnp.zeros(K, dtype=jnp.float64).at[0].set(1.0)
+
+    _, s_ref = jet(fn, (x0,), (series_in,))
+    _, s_eff = jet(fn, (x0,), (series_in,), effective_order=jnp.array(3))
+
+    # Prefix correctness:
+    np.testing.assert_allclose(
+        s_eff[:3], s_ref[:3], rtol=RTOL, atol=ATOL,
+        err_msg=f"{name}: prefix mismatch",
+    )
+    # Tail must be truncated (zero), not full. Outer jnp.exp ensures the
+    # reference tail is non-zero, so this is a real distinguishing test.
+    assert not jnp.allclose(s_ref[3:], s_eff[3:], rtol=RTOL, atol=ATOL), (
+        f"{name}: effective_order did not actually skip work — tail equals "
+        f"the no-hint output, indicating the hint was lost across a jit "
+        f"boundary. ref={s_ref[3:]}, eff={s_eff[3:]}"
+    )
+    # Truncated entries should be exactly zero (the _jet_scan no-op path
+    # leaves them at the JetTrace's initial zero).
+    np.testing.assert_allclose(s_eff[3:], 0.0, atol=1e-12,
+                               err_msg=f"{name}: truncated tail not zero")
+
+
+def test_effective_order_propagates_across_explicit_jit():
+    """jax.jit-wrapped subroutines also propagate effective_order."""
+    @jax.jit
+    def inner(x):
+        return jnp.exp(jnp.sin(x))
+
+    fn = lambda x: inner(x) + jnp.exp(x)
+    x0 = jnp.asarray(0.5, dtype=jnp.float64)
+    series_in = jnp.zeros(K, dtype=jnp.float64).at[0].set(1.0)
+
+    _, s_ref = jet(fn, (x0,), (series_in,))
+    _, s_eff = jet(fn, (x0,), (series_in,), effective_order=jnp.array(3))
+
+    np.testing.assert_allclose(s_eff[:3], s_ref[:3], rtol=RTOL, atol=ATOL)
+    assert not jnp.allclose(s_ref[3:], s_eff[3:], rtol=RTOL, atol=ATOL), (
+        "effective_order did not propagate through jax.jit"
+    )